Doyo\PhpSpec\CodeCoverage\Extension

Complexity

Total Complexity

29

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Test Coverage

Coverage

94.95%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	addCoverageOptions()	0	9	1
A	load()	0	4	1
B	configureReport()	0	39	8
A	loadDriver()	0	5	1
A	getDriverClass()	0	17	4
A	loadFilter()	0	17	6
A	canCollectCodeCoverage()	0	3	1
A	loadReports()	0	10	3
A	loadProcessor()	0	8	1
A	loadCoverageListener()	0	32	3

<?php


namespace Doyo\PhpSpec\CodeCoverage;

use Doyo\Bridge\CodeCoverage\Driver\Dummy;
use Doyo\PhpSpec\CodeCoverage\Listener\CoverageListener;
use Doyo\Symfony\Bridge\EventDispatcher\EventDispatcher;
use PhpSpec\Extension as BaseExtension;
use PhpSpec\ServiceContainer;
use SebastianBergmann\CodeCoverage\Driver\PHPDBG;
use SebastianBergmann\CodeCoverage\Driver\Xdebug;
use SebastianBergmann\CodeCoverage\Filter;
use SebastianBergmann\CodeCoverage\Report\Html\Facade;
use SebastianBergmann\CodeCoverage\Report\PHP;
use SebastianBergmann\Environment\Runtime;
use Symfony\Component\Console\Input\InputOption;
use Doyo\Bridge\CodeCoverage\Processor;

class Extension implements BaseExtension
{
    public function load(ServiceContainer $container, array $params)
    {
        $this->addCoverageOptions($container);
        $this->loadCoverageListener($container, $params);
    }

    public function addCoverageOptions(ServiceContainer $container)
    {
        /* @var \PhpSpec\Console\Command\RunCommand $command */
        $command = $container->get('console.commands.run');
        $command->addOption(
            'coverage',
            null,
            InputOption::VALUE_NONE,
            'Run phpspec with code coverage'
        );
    }

    public function loadCoverageListener(ServiceContainer $container, array $params)
    {
        /* @var \Symfony\Component\Console\Input\InputInterface $input */
        $input = $container->get('console.input');


        if(false === $input->hasParameterOption(['--coverage'])){
            return;
        }

        $this->loadDriver($container, $params);
        $this->loadFilter($container, $params);
        $this->loadProcessor($container, $params);
        $this->loadReports($container, $params);
        $container->define('doyo.coverage.dispatcher', function($container){

The parameter $container is not used and could be removed.

            $dispatcher = new EventDispatcher();

            return $dispatcher;
        });

        $container->define('doyo.coverage.listener',function($container){
            $dispatcher = $container->get('doyo.coverage.dispatcher');
            $consoleIO = $container->get('console.io');
            $processor = $container->get('doyo.coverage.processor');
            $canCollectCoverage = Extension::canCollectCodeCoverage();
            return new CoverageListener($dispatcher, $processor, $consoleIO, $canCollectCoverage);
        }, ['event_dispatcher.listeners']);

        $reports = $container->getByTag('doyo.coverage.reports');
        $dispatcher = $container->get('doyo.coverage.dispatcher');
        foreach($reports as $report){
            $dispatcher->addSubscriber($report);
        }
    }

    public static function getDriverClass()
    {
        static $runtime;
        if(!$runtime instanceof Runtime){
            $runtime = new Runtime();
        }

        $driverClass = Dummy::class;
        if($runtime->canCollectCodeCoverage()){
            if($runtime->isPHPDBG()){
                $driverClass = PHPDBG::class;
            }else{
                $driverClass = Xdebug::class;
            }
        }

        return $driverClass;
    }

    private function loadDriver(ServiceContainer $container, array $params)
    {
        $driverClass = static::getDriverClass();
        $container->define('doyo.coverage.driver', function() use ($params, $driverClass){

The import $params is not used and could be removed.

            return new $driverClass;
        });
    }

    private function loadFilter(ServiceContainer $container, array $params)
    {
        $container->define('doyo.coverage.filter', function() use ($params){
            $filters = $params['filters'] ?:[];
            $whitelist = isset($filters['whitelist']) ? $filters['whitelist']:[];
            $blacklist = isset($filters['blacklist']) ? $filters['blacklist']:[];
            $filter = new Filter();

            foreach($whitelist as $dir){
                $filter->addDirectoryToWhitelist($dir);
            }

            foreach($blacklist as $dir){
                $filter->removeDirectoryFromWhitelist($dir);
            }

            return $filter;
        });
    }

    private function loadProcessor(ServiceContainer $container, array $params)
    {
        $container->define('doyo.coverage.processor', function($container) use ($params){

The import $params is not used and could be removed.

            $driver = $container->get('doyo.coverage.driver');
            $filter = $container->get('doyo.coverage.filter');
            $processor = new Processor($driver, $filter);

            return $processor;
        });
    }

    private function loadReports(ServiceContainer $container, array $params)
    {
        $reports = [
            'html' => Facade::class,
            'php' => PHP::class
        ];

        $reportConfig = isset($params['reports']) ? $params['reports']:[];
        foreach($reports as $type => $class){
            $this->configureReport($container, $reportConfig, $type, $class);
        }
    }

    private function configureReport(ServiceContainer $container, array $reportConfig, $type, $class)
    {
        if(!isset($reportConfig[$type])){
            return;
        }

        $dirTypes = ['html'];
        $fsType = in_array($type, $dirTypes) ? 'dir':'file';
        $options = array();
        $test = $reportConfig[$type];

        if(is_string($test)){
            $options['target'] = $test;
        }else{
            $options = $reportConfig[$type];
        }

        $options['type'] = $fsType;
        $r = new \ReflectionClass($class);
        $constructorParams = [];

        if(!is_null($r->getConstructor())){
            foreach($r->getConstructor()->getParameters() as $parameter){
                $name = $parameter->getName();
                if($parameter->isDefaultValueAvailable()){
                    break;
                }
                $default = $parameter->getDefaultValue();
                $constructorParams[] = isset($options[$name]) ? $options[$name]:$default;
            }
        }

        $id = 'doyo.coverage.reports.'.$type;
        $container->define($id, function($container) use ($class, $constructorParams, $options){

The parameter $container is not used and could be removed.

            $r = new \ReflectionClass($class);
            $processor = $r->newInstanceArgs($constructorParams);
            $report = new Report($processor, $options);
            return $report;
        },['doyo.coverage.reports']);
    }

    public static function canCollectCodeCoverage()
    {
        return Extension::class !== Dummy::class;
    }
}