Doyo\Bridge\CodeCoverage\Compiler\CoveragePass

Complexity

Total Complexity

20

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Test Coverage

Coverage

76.74%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	processDriver()	0	9	2
A	process()	0	4	1
A	processFilter()	0	11	3
C	filterWhitelist()	0	37	14

<?php

/*
 * This file is part of the doyo/code-coverage project.
 *
 * (c) Anthonius Munthi <https://itstoni.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Doyo\Bridge\CodeCoverage\Compiler;

use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

class CoveragePass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container)
    {
        $this->processDriver($container);
        $this->processFilter($container);
    }

    private function processDriver(ContainerBuilder $container)
    {
        $driverClass = $container->get('runtime')->getDriverClass();
        $container->getParameterBag()->set('coverage.driver.class', $driverClass);

        $r = new \ReflectionClass($driverClass);
        if ($r->hasMethod('setFilter')) {
            $definition = $container->getDefinition('coverage.filter');
            $definition->addMethodCall('setFilter', [new Reference('coverage.filter')]);
        }
    }

    private function processFilter(ContainerBuilder $container)
    {
        $config     = $container->getParameter('config');
        $config = $config['filter'];
        $definition = $container->getDefinition('coverage.filter');

        foreach ($config as $options) {
            $this->filterWhitelist($definition, $options, 'add');
            $exclude = $options['exclude'];
            foreach ($exclude as $item) {
                $this->filterWhitelist($definition, $item, 'remove');
            }
        }
    }

    private function filterWhitelist(Definition $definition, $options, $method)
    {
        $suffix    = $options['suffix'] ?: '.php';
        $prefix    = $options['prefix'] ?: '';
        $directory = $options['directory'];
        $file      = $options['file'];
        $type      = null !== $options['directory'] ? 'directory' : 'file';

        if (null !== $directory && '' === $directory) {
            $directory = getcwd();
        }

        if (
            null !== $directory
            && preg_match('/\/\*(\..+)/', $directory, $matches)
        ) {
            $suffix    = $matches[1];
            $directory = str_replace($matches[0], '', $directory);
        }

        $methodSuffix = 'add' === $method ? 'ToWhitelist' : 'FromWhitelist';
        if ('directory' === $type) {
            $definition->addMethodCall($method.'Directory'.$methodSuffix, [$directory, $suffix, $prefix]);
        }

        if ('file' === $type) {
            $files = [$file];

            if (false !== ($pos=strpos($file, '*'))) {

The assignment to $pos is dead and can be removed.

                $files = [];
                foreach (glob($file) as $filename) {
                    $filename = realpath($filename);
                    $files[] = $filename;
                }
            }
            foreach($files as $file){
                $definition->addMethodCall($method.'File'.$methodSuffix, [$file]);
            }
        }
    }
}