Ynlo\GraphQLBundle\Definition\Loader\AnnotationLoader

Complexity

Total Complexity

20

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Test Coverage

Coverage

48.94%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	extractNamespaceClasses()	0	18	5
A	__construct()	0	5	1
B	loadDefinitions()	0	19	8
A	resolveClasses()	0	23	6

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <support@ynloultratech.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Definition\Loader;

use Doctrine\Common\Annotations\Reader;
use Symfony\Component\Finder\Finder;
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Component\HttpKernel\KernelInterface;
use Ynlo\GraphQLBundle\Definition\Loader\Annotation\AnnotationParserInterface;
use Ynlo\GraphQLBundle\Definition\Registry\Endpoint;

/**
 * Resolve and load definitions based on common annotations
 */
class AnnotationLoader implements DefinitionLoaderInterface
{
    /**
     * Folders inside bundles to locate definitions
     * TODO: allow add additional mapping on bundle config
     */
    private const DEFINITIONS_LOCATIONS = [
        'Model', //non persistent models like interfaces, or abstract classes
        'Entity', //doctrine entities
        'Mutation', //custom actions
        'Subscription', //custom subscriptions
        'Query', //custom actions
    ];

    /**
     * @var Kernel
     */
    protected $kernel;

    /**
     * @var Reader
     */
    protected $reader;

    /**
     * @var iterable|array|AnnotationParserInterface[]
     */
    protected $annotationParsers = [];

    /**
     * @param KernelInterface                      $kernel
     * @param Reader                               $reader
     * @param iterable|AnnotationParserInterface[] $annotationParsers
     */
    public function __construct(KernelInterface $kernel, Reader $reader, $annotationParsers = [])
    {
        $this->kernel = $kernel;

$kernel is of type Symfony\Component\HttpKernel\KernelInterface, but the property $kernel was declared to be of type Symfony\Component\HttpKernel\Kernel. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->reader = $reader;
        $this->annotationParsers = $annotationParsers;
    }

    /**
     * {@inheritdoc}
     */
    public function loadDefinitions(Endpoint $endpoint): void
    {
        $classesToLoad = $this->resolveClasses();
        $annotationsMapping = [];
        foreach ($classesToLoad as $class) {
            $refClass = new \ReflectionClass($class);
            $annotations = $this->reader->getClassAnnotations($refClass);
            if ($annotations) {

The expression $annotations 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.

                $annotationsMapping[$refClass->getName()] = [$refClass, $annotations];
            }
        }

        foreach ($this->annotationParsers as $parser) {
            if ($parser instanceof AnnotationParserInterface) {
                foreach ($annotationsMapping as $className => $map) {
                    list($refClass, $annotations) = $map;
                    foreach ($annotations as $annotation) {
                        if ($parser->supports($annotation)) {
                            $parser->parse($annotation, $refClass, $endpoint);
                        }
                    }
                }
            }
        }
    }

    /**
     * @return array
     */
    protected function resolveClasses(): array
    {
        $bundles = $this->kernel->getBundles();
        $classes = [[]];
        foreach (self::DEFINITIONS_LOCATIONS as $definitionLocation) {
            foreach ($bundles as $bundle) {
                $path = $bundle->getPath().'/'.$definitionLocation;
                if (file_exists($path)) {
                    $classes[] = $this->extractNamespaceClasses($path, $bundle->getNamespace(), $definitionLocation);
                }
            }

            if (Kernel::VERSION_ID >= 40000) {
                $path = $this->kernel->getRootDir().'/'.$definitionLocation;
                if (file_exists($path)) {
                    $classes[] = $this->extractNamespaceClasses($path, 'App', $definitionLocation);
                }
            }
        }

        $classes = array_merge(...$classes);

        return array_unique($classes);
    }

    /**
     * @param string $path
     * @param string $baseNamespace
     * @param string $baseLocation
     *
     * @return array
     */
    protected function extractNamespaceClasses($path, $baseNamespace, $baseLocation)
    {
        $classes = [];
        $finder = new Finder();
        foreach ($finder->in($path)->name('/.php$/')->getIterator() as $file) {
            $className = preg_replace('/.php$/', null, $file->getFilename());
            if ($file->getRelativePath()) {
                $subNamespace = str_replace('/', '\\', $file->getRelativePath());
                $fullyClassName = $baseNamespace.'\\'.$baseLocation.'\\'.$subNamespace.'\\'.$className;
            } else {
                $fullyClassName = $baseNamespace.'\\'.$baseLocation.'\\'.$className;
            }
            if (class_exists($fullyClassName) || interface_exists($fullyClassName)) {
                $classes[] = $fullyClassName;
            }
        }

        return $classes;
    }
}