KunicMarko\SonataAnnotationBundle\DependencyInjection\Compiler\AutoRegisterCompilerPass

Complexity

Total Complexity

13

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getNamespace()	0	11	2
A	getClassName()	0	3	1
A	process()	0	27	5
A	getFullyQualifiedClassName()	0	7	2
A	findFiles()	0	6	1
A	getClassAnnotation()	0	5	1
A	getServiceId()	0	3	1

<?php

declare(strict_types=1);

namespace KunicMarko\SonataAnnotationBundle\DependencyInjection\Compiler;

use Doctrine\Common\Annotations\Reader;
use KunicMarko\SonataAnnotationBundle\Annotation\Admin;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;

/**
 * @author Marko Kunic <kunicmarko20@gmail.com>
 */
final class AutoRegisterCompilerPass implements CompilerPassInterface
{
    private const DEFAULT_SERVICE_PREFIX = 'app.admin.';

    /**
     * @var Reader
     */
    private $annotationReader;

    public function process(ContainerBuilder $container): void
    {
        $this->annotationReader = $container->get('annotation_reader');

        foreach ($this->findFiles($container->getParameter('sonata_annotation.directory')) as $file) {
            if (!($className = $this->getFullyQualifiedClassName($file))) {
                continue;
            }

            if (!\class_exists($className)) {
                continue;
            }

            if (!($annotation = $this->getClassAnnotation($reflection = new \ReflectionClass($className)))) {
                continue;
            }

            $definition = new Definition(
                $annotation->admin,
                [$annotation->code, $className, $annotation->controller]
            );

            $definition->addTag('sonata.admin', $annotation->getTagOptions());

            $container->setDefinition(
                $serviceId = ($annotation->serviceId ?? $this->getServiceId($file)),
                $definition
            );
        }
    }

    private function findFiles(string $directory): \IteratorAggregate
    {
        return Finder::create()
            ->in($directory)
            ->files()
            ->name('*.php');
    }

    private function getFullyQualifiedClassName(SplFileInfo $file): ?string
    {
        if (!($namespace = $this->getNamespace($file->getPathname()))) {
            return null;
        }

        return $namespace . '\\' . $this->getClassName($file->getFilename());
    }

    private function getNamespace(string $filePath): ?string
    {
        $namespaceLine = preg_grep('/^namespace /', file($filePath));

It seems like file($filePath) can also be of type false; however, parameter $input of preg_grep() does only seem to accept array, maybe add an additional type check?

        if (!$namespaceLine) {

The expression $namespaceLine of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return null;
        }

        preg_match('/namespace (.*);$/', trim(reset($namespaceLine)), $match);

        return array_pop($match);
    }

    private function getClassName(string $fileName): string
    {
        return str_replace('.php', '', $fileName);
    }

    private function getClassAnnotation(\ReflectionClass $class): ?Admin
    {
        return $this->annotationReader->getClassAnnotation(
            $class,
            Admin::class
        );
    }

    private function getServiceId(SplFileInfo $file): string
    {
        return self::DEFAULT_SERVICE_PREFIX . $this->getClassName($file->getFilename());
    }
}