Paraunit\Configuration\DependencyInjection\ParallelContainerDefinition

Complexity

Total Complexity

12

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.56%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	configureProcess()	0	12	1
A	configureRunner()	0	17	1
A	configure()	0	16	1
A	configureConfiguration()	0	11	1
A	configureEventDispatcher()	0	19	2
A	configureFile()	0	7	1
B	configurePrinter()	0	26	1
A	configureServices()	0	15	1
A	getProcessFactoryClass()	0	11	2

<?php

declare(strict_types=1);

namespace Paraunit\Configuration\DependencyInjection;

use Paraunit\Configuration\ParallelConfiguration;
use Paraunit\Configuration\PHPUnitBinFile;
use Paraunit\Configuration\PHPUnitConfig;
use Paraunit\Configuration\TempFilenameFactory;
use Paraunit\File\Cleaner;
use Paraunit\File\TempDirectory;
use Paraunit\Filter\Filter;
use Paraunit\Printer\ConsoleFormatter;
use Paraunit\Printer\FailuresPrinter;
use Paraunit\Printer\FilesRecapPrinter;
use Paraunit\Printer\FinalPrinter;
use Paraunit\Printer\ProcessPrinter;
use Paraunit\Printer\SharkPrinter;
use Paraunit\Printer\SingleResultFormatter;
use Paraunit\Process\CommandLine;
use Paraunit\Process\ProcessBuilderFactory;
use Paraunit\Process\ProcessFactory;
use Paraunit\Process\ProcessFactoryInterface;
use Paraunit\Proxy\PHPUnitUtilXMLProxy;
use Paraunit\Runner\PipelineCollection;
use Paraunit\Runner\PipelineFactory;
use Paraunit\Runner\Runner;
use Paraunit\TestResult\TestResultList;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher;
use Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Process\Process;

class ParallelContainerDefinition
{
    /** @var ParserDefinition */
    private $parserDefinition;

    /** @var TestResultDefinition */
    private $testResult;

    public function __construct()
    {
        $this->parserDefinition = new ParserDefinition();
        $this->testResult = new TestResultDefinition();
    }

    public function configure(ContainerBuilder $container): ContainerBuilder
    {
        $container->setParameter('paraunit.max_retry_count', 3);
        $container->setParameter('kernel.root_dir', 'src');
        $this->configureConfiguration($container);
        $this->configureEventDispatcher($container);
        $this->configureFile($container);
        $this->parserDefinition->configure($container);
        $this->configurePrinter($container);
        $this->configureProcess($container);
        $this->configureRunner($container);
        $this->configureServices($container);
        $this->testResult->configure($container);

        return $container;
    }

    private function configureConfiguration(ContainerBuilder $container)
    {
        $container->setDefinition(PHPUnitBinFile::class, new Definition(PHPUnitBinFile::class));
        $container->setDefinition(PHPUnitConfig::class, new Definition(PHPUnitConfig::class, [
            '%paraunit.phpunit_config_filename%',
        ]))
            ->setPublic(true);
        $container->setDefinition(TempFilenameFactory::class, new Definition(TempFilenameFactory::class, [
            new Reference(TempDirectory::class),
        ]));
    }

    private function configureEventDispatcher(ContainerBuilder $container)
    {
        if (class_exists('Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument')) {
            $container->setDefinition(EventDispatcherInterface::class, new Definition(EventDispatcher::class));
        } else {
            $container->setDefinition(
                EventDispatcherInterface::class,
                new Definition(ContainerAwareEventDispatcher::class, [new Reference('service_container')])
            );
        }

        $container->addCompilerPass(
            new RegisterListenersPass(
                EventDispatcherInterface::class,
                '',
                ParallelConfiguration::TAG_EVENT_SUBSCRIBER
            )
        );
    }

    private function configureFile(ContainerBuilder $container)
    {
        $container->setDefinition(TempDirectory::class, new Definition(TempDirectory::class));
        $container->setDefinition(Cleaner::class, new Definition(Cleaner::class, [
            new Reference(TempDirectory::class),
        ]));
    }

    private function configurePrinter(ContainerBuilder $container)
    {
        $output = new Reference(OutputInterface::class);

        $container->setDefinition(SharkPrinter::class, new Definition(SharkPrinter::class, [
            $output,
            '%paraunit.show_logo%',
        ]));
        $container->setDefinition(ProcessPrinter::class, new Definition(ProcessPrinter::class, [
            new Reference(SingleResultFormatter::class),
            $output,
        ]));

        $finalPrinterArguments = [
            new Reference(TestResultList::class),
            $output,
        ];
        $container->setDefinition(FinalPrinter::class, new Definition(FinalPrinter::class, $finalPrinterArguments));
        $container->setDefinition(FailuresPrinter::class, new Definition(FailuresPrinter::class, $finalPrinterArguments));
        $container->setDefinition(FilesRecapPrinter::class, new Definition(FilesRecapPrinter::class, $finalPrinterArguments));

        $container->setDefinition(ConsoleFormatter::class, new Definition(ConsoleFormatter::class, [$output]));
        $container->setDefinition(SingleResultFormatter::class, new Definition(SingleResultFormatter::class, [
            new Reference(TestResultList::class),
        ]));
    }

    private function configureProcess(ContainerBuilder $container)
    {
        $container->setDefinition(CommandLine::class, new Definition(CommandLine::class, [
            new Reference(PHPUnitBinFile::class),
        ]));

        $container->setDefinition(ProcessFactoryInterface::class, new Definition($this->getProcessFactoryClass(), [
            new Reference(CommandLine::class),
            new Reference(PHPUnitConfig::class),
            new Reference(TempFilenameFactory::class),
        ]));
    }

    private function configureRunner(ContainerBuilder $container)
    {
        $container->setDefinition(PipelineFactory::class, new Definition(PipelineFactory::class, [
            new Reference(EventDispatcherInterface::class),
        ]));
        $container->setDefinition(PipelineCollection::class, new Definition(PipelineCollection::class, [
            new Reference(PipelineFactory::class),
            '%paraunit.max_process_count%',
        ]));
        $container->setDefinition(Runner::class, new Definition(Runner::class, [
            new Reference(EventDispatcherInterface::class),
            new Reference(ProcessFactoryInterface::class),
            new Reference(Filter::class),
            new Reference(PipelineCollection::class),
        ]))
            ->setPublic(true);
    }

    private function configureServices(ContainerBuilder $container)
    {
        $container->register(OutputInterface::class, OutputInterface::class)
            ->setPublic(true)
            ->setSynthetic(true);
        $container->setDefinition(PHPUnitUtilXMLProxy::class, new Definition(PHPUnitUtilXMLProxy::class));
        $container->setDefinition(\File_Iterator_Facade::class, new Definition(\File_Iterator_Facade::class));
        $container->setDefinition(Filter::class, new Definition(Filter::class, [
            new Reference(PHPUnitUtilXMLProxy::class),
            new Reference(\File_Iterator_Facade::class),
            new Reference(PHPUnitConfig::class),
            '%paraunit.testsuite%',
            '%paraunit.string_filter%',
        ]));
    }

    private function getProcessFactoryClass(): string
    {
        // only reliable way to detect symfony/process 3.3+: CLI parsing
        $process = new Process(['cmd as array']);
        if (\is_array($process->getCommandLine())) {
            // Commandline not parsed, we have Symfony < 3.3
            return ProcessBuilderFactory::class;
        }

        return ProcessFactory::class;
    }
}