Paraunit\Configuration\CoverageConfiguration

Complexity

Total Complexity

14

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

97.67%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	loadCommandLineOptions()	0	15	1
A	addProcessor()	0	4	1
A	addFileProcessor()	0	14	2
A	addFileOrOutputProcessor()	0	15	2
A	addPathProcessor()	0	13	2
A	createOutputFileDefinition()	0	8	2
A	getOptionName()	0	8	2
A	optionIsEnabled()	0	4	1

<?php

declare(strict_types=1);

namespace Paraunit\Configuration;

use Paraunit\Configuration\DependencyInjection\CoverageContainerDefinition;
use Paraunit\Coverage\CoverageResult;
use Paraunit\Coverage\Processor\Clover;
use Paraunit\Coverage\Processor\CoverageProcessorInterface;
use Paraunit\Coverage\Processor\Crap4j;
use Paraunit\Coverage\Processor\Html;
use Paraunit\Coverage\Processor\Php;
use Paraunit\Coverage\Processor\Text;
use Paraunit\Coverage\Processor\TextSummary;
use Paraunit\Coverage\Processor\Xml;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Class CoverageConfiguration
 * @package Paraunit\Configuration
 */
class CoverageConfiguration extends ParallelConfiguration
{
    public function __construct(bool $createPublicServiceAliases = false)
    {
        parent::__construct($createPublicServiceAliases);
        $this->containerDefinition = new CoverageContainerDefinition();
    }

    protected function loadCommandLineOptions(ContainerBuilder $container, InputInterface $input): void
    {
        parent::loadCommandLineOptions($container, $input);

        $coverageResult = $container->getDefinition(CoverageResult::class);

        $this->addPathProcessor($coverageResult, $input, Xml::class);
        $this->addPathProcessor($coverageResult, $input, Html::class);

        $this->addFileProcessor($coverageResult, $input, Clover::class);
        $this->addFileOrOutputProcessor($coverageResult, $input, Text::class);
        $this->addFileOrOutputProcessor($coverageResult, $input, TextSummary::class);
        $this->addFileProcessor($coverageResult, $input, Crap4j::class);
        $this->addFileProcessor($coverageResult, $input, Php::class);
    }

    private function addProcessor(Definition $coverageResult, string $processorClass, array $dependencies): void
    {
        $coverageResult->addMethodCall('addCoverageProcessor', [new Definition($processorClass, $dependencies)]);
    }

    private function addFileProcessor(
        Definition $coverageResult,
        InputInterface $input,
        string $processorClass
    ): void {
        $optionName = $this->getOptionName($processorClass);

        if ($input->getOption($optionName)) {
            $this->addProcessor($coverageResult, $processorClass, [
                $this->createOutputFileDefinition($input, $optionName),
                (bool) $input->getOption('ansi'),
            ]);
        }
    }

    private function addFileOrOutputProcessor(
        Definition $coverageResult,
        InputInterface $input,
        string $processorClass
    ): void {
        $optionName = $this->getOptionName($processorClass);

        if ($this->optionIsEnabled($input, $optionName)) {
            $this->addProcessor($coverageResult, $processorClass, [
                new Reference(OutputInterface::class),
                (bool) $input->getOption('ansi'),
                $this->createOutputFileDefinition($input, $optionName),
            ]);
        }
    }

    private function addPathProcessor(
        Definition $coverageResult,
        InputInterface $input,
        string $processorClass
    ): void {
        $optionName = $this->getOptionName($processorClass);

        if ($this->optionIsEnabled($input, $optionName)) {
            $this->addProcessor($coverageResult, $processorClass, [
                new Definition(OutputPath::class, [$input->getOption($optionName)]),
            ]);
        }
    }

    private function createOutputFileDefinition(InputInterface $input, string $optionName): ?Definition
    {
        if ($input->getOption($optionName)) {
            return new Definition(OutputFile::class, [$input->getOption($optionName)]);
        }

        return null;
    }

    /**
     * @param string $processorClass
     * @return string
     * @throws \InvalidArgumentException
     */
    private function getOptionName(string $processorClass): string
    {
        if (! \in_array(CoverageProcessorInterface::class, class_implements($processorClass), true)) {
            throw new \InvalidArgumentException('Expecting FQCN of class implementing ' . CoverageProcessorInterface::class . ', got ' . $processorClass);
        }

        return $processorClass::getConsoleOptionName();
    }

    private function optionIsEnabled(InputInterface $input, string $optionName): bool
    {
        return $input->hasParameterOption('--' . $optionName);
    }
}