Incompass\InjectionBundle\DependencyInjection\InjectionExtension

Complexity

Total Complexity

13

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getProcessor()	0	7	2
A	setReader()	0	3	1
A	load()	0	18	4
A	getFinder()	0	7	2
A	setProcessor()	0	3	1
A	setFinder()	0	3	1
A	getReader()	0	7	2

<?php declare(strict_types=1);

namespace Incompass\InjectionBundle\DependencyInjection;

use Doctrine\Common\Annotations\AnnotationReader;
use Incompass\InjectionBundle\InjectProcessor;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Extension\Extension;
use Symfony\Component\Finder\Finder;

/**
 * Class InjectionExtension
 *
 * @author  Joe Mizzi <themizzi@me.com>
 *
 * @codeCoverageIgnore
 */
class InjectionExtension extends Extension
{
    private $processor;
    private $finder;
    private $reader;

    public function load(array $configs, ContainerBuilder $container): void
    {
        $configuration = $this->getConfiguration([], $container);
        $config = $this->processConfiguration($configuration, $configs);

It seems like $configuration can also be of type null; however, parameter $configuration of Symfony\Component\DependencyInjection\Extension\Extension::processConfiguration() does only seem to accept Symfony\Component\Config\Definition\ConfigurationInterface, maybe add an additional type check?

        $finder = $this->getFinder();
        $reader = $this->getReader();
        $projectDir = $container->getParameter('kernel.project_dir');
        $container->setParameter('injection.environment_groups', $config['environment_groups']);
        foreach ($config['paths'] as $path => $prefix) {
            foreach ($finder->in($projectDir.'/'.$path)->name('*.php') as $file => $info) {
                $pathLen = \strlen($projectDir.'/'.$path);
                $classPath = str_replace('/', '\\', substr($file, $pathLen + 1, -4));
                $class = $prefix.$classPath;
                $reflectionClass = new \ReflectionClass($class);
                $processor = $this->getProcessor();

                foreach ($reader->getClassAnnotations($reflectionClass) as $annotation) {
                    $processor->process($annotation, $class, $container);
                }
            }
        }
    }

    /**
     * @return InjectProcessor
     * @codeCoverageIgnore
     */
    public function getProcessor(): InjectProcessor
    {
        if (!$this->processor) {
            $this->processor = new InjectProcessor();
        }

        return $this->processor;
    }

    /**
     * @param InjectProcessor $processor
     * @codeCoverageIgnore
     */
    public function setProcessor(InjectProcessor $processor): void
    {
        $this->processor = $processor;
    }

    /**
     * @return Finder
     * @codeCoverageIgnore
     */
    public function getFinder(): Finder
    {
        if (!$this->finder) {
            $this->finder = new Finder();
        }

        return $this->finder;
    }

    /**
     * @param Finder $finder
     * @codeCoverageIgnore
     */
    public function setFinder(Finder $finder): void
    {
        $this->finder = $finder;
    }

    /**
     * @return AnnotationReader
     * @throws \Doctrine\Common\Annotations\AnnotationException
     * @codeCoverageIgnore
     */
    public function getReader(): AnnotationReader
    {
        if (!$this->reader) {
            $this->reader = new AnnotationReader();
        }

        return $this->reader;
    }

    /**
     * @param AnnotationReader $reader
     * @codeCoverageIgnore
     */
    public function setReader(AnnotationReader $reader): void
    {
        $this->reader = $reader;
    }
}