ApiGen\Parser\Broker\Backend

Complexity

Total Complexity

40

Size/Duplication

Total Lines	205
Duplicated Lines	3.9 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

76.92%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getConstants()	0	6	1
A	getFunctions()	0	6	1
D	parseClassLists()	0	43	10
A	processFunction()	0	14	4
C	addClass()	0	26	8
B	loadParentClassesAndInterfacesFromClassReflection()	8	16	6
A	isClassLoaded()	0	6	3
B	loadAnnotationFromReflection()	0	16	5
A	getClassFqn()	0	8	1

<?php declare(strict_types=1);

namespace ApiGen\Parser\Broker;

use ApiGen\Contracts\Parser\Broker\BackendInterface;
use ApiGen\Contracts\Parser\Reflection\Behavior\InNamespaceInterface;
use ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\ConstantReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\FunctionReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\MethodReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\TokenReflection\ReflectionFactoryInterface;
use ApiGen\Parser\Reflection\ReflectionClass;
use ApiGen\Parser\Reflection\ReflectionFunction;
use ApiGen\Parser\Reflection\ReflectionMethod;
use TokenReflection;
use TokenReflection\Broker;
use TokenReflection\IReflectionConstant;
use TokenReflection\IReflectionFunction;
use TokenReflection\Resolver;

/**
 * Customized TokenReflection broker backend.
 * Adds internal classes from @param, @var, @return, @throws annotations as well
 * as parent classes to the overall class list.
 *
 * @method TokenReflection\ReflectionNamespace[] getNamespaces()
 */
final class Backend extends Broker\Backend\Memory implements BackendInterface

There is one abstract method getClasses in this class; you could implement it, or declare this class as abstract.

{
    /**
     * @var ClassReflectionInterface[][]
     */
    private $allClasses = [
        self::TOKENIZED_CLASSES => [],
        self::INTERNAL_CLASSES => [],
        self::NONEXISTENT_CLASSES => []
    ];

    /**
     * @var mixed[]
     */
    private $declared = [];

    /**
     * @var ReflectionFactoryInterface
     */
    private $reflectionFactory;

    public function __construct(ReflectionFactoryInterface $reflectionFactory)
    {
        $this->reflectionFactory = $reflectionFactory;
    }

    /**
     * @return ConstantReflectionInterface[]
     */
    public function getConstants(): array
    {
        return array_map(function (IReflectionConstant $constant) {
            return $this->reflectionFactory->createFromReflection($constant);
        }, parent::getConstants());
    }

    /**
     * @return FunctionReflectionInterface[]
     */
    public function getFunctions(): array
    {
        return array_map(function (IReflectionFunction $function) {
            return $this->reflectionFactory->createFromReflection($function);
        }, parent::getFunctions());
    }

    /**
     * @return ClassReflectionInterface[]
     */
    protected function parseClassLists(): array
    {
        $this->declared = array_flip(array_merge(get_declared_classes(), get_declared_interfaces()));

        foreach ($this->getNamespaces() as $namespace) {
            foreach ($namespace->getClasses() as $name => $ref) {
                $class = $this->reflectionFactory->createFromReflection($ref);

                $this->allClasses[self::TOKENIZED_CLASSES][$name] = $class;
                if (! $class->isDocumented()) {
                    continue;
                }

                $this->loadParentClassesAndInterfacesFromClassReflection($ref);
            }
        }

        foreach ($this->allClasses[self::TOKENIZED_CLASSES] as $class) {
            if (! $class->isDocumented()) {
                continue;
            }

            foreach ($class->getOwnMethods() as $method) {
                $this->processFunction($method);
            }

            foreach ($class->getOwnProperties() as $property) {
                $this->loadAnnotationFromReflection($class, $property->getAnnotations(), 'var');
            }
        }

        foreach ($this->getFunctions() as $function) {
            $this->processFunction($function);
        }

        array_walk_recursive($this->allClasses, function (&$reflection) {
            if (! $reflection instanceof ReflectionClass) {
                $reflection = $this->reflectionFactory->createFromReflection($reflection);
            }
        });

        return $this->allClasses;
    }

    /**
     * Processes a function/method and adds classes from annotations to the overall class array.
     *
     * @param ReflectionMethod|ReflectionFunction $reflection
     */
    private function processFunction($reflection): void
    {
        $annotations = $reflection->getAnnotations();
        foreach (['param', 'return', 'throws'] as $annotation) {
            $this->loadAnnotationFromReflection($reflection, $annotations, $annotation);
        }

        foreach ($reflection->getParameters() as $parameter) {
            $hint = $parameter->getClassName();
            if ($hint) {
                $this->addClass($hint);
            }
        }
    }

    /**
     * @return false|void
     */
    private function addClass(string $name)
    {
        $name = ltrim($name, '\\');

        if (! isset($this->declared[$name]) || $this->isClassLoaded($name)) {
            return false;
        }

        $parameterClass = $this->getBroker()->getClass($name);

        if ($parameterClass->isInternal()) {
            $this->allClasses[self::INTERNAL_CLASSES][$name] = $parameterClass;
            $parentClasses = array_merge($parameterClass->getInterfaces(), $parameterClass->getParentClasses());
            foreach ($parentClasses as $parentClass) {
                $parentName = $parentClass->getName();

                if (! isset($this->allClasses[self::INTERNAL_CLASSES][$parentName])) {
                    $this->allClasses[self::INTERNAL_CLASSES][$parentName] = $parentClass;
                }
            }
        } elseif (! $parameterClass->isTokenized()) {
            if (! isset($this->allClasses[self::NONEXISTENT_CLASSES][$name])) {
                $this->allClasses[self::NONEXISTENT_CLASSES][$name] = $parameterClass;
            }
        }
    }

    /**
     * @param TokenReflection\ReflectionClass|TokenReflection\Invalid\ReflectionClass $reflection
     */
    private function loadParentClassesAndInterfacesFromClassReflection($reflection): void
    {
        $reflectionRelatedClassElements = array_merge($reflection->getParentClasses(), $reflection->getInterfaces());
        foreach ($reflectionRelatedClassElements as $parentName => $parentReflection) {
            /** @var TokenReflection\ReflectionClass $parentReflection */
            if ($parentReflection->isInternal()) {
                if (! isset($this->allClasses[self::INTERNAL_CLASSES][$parentName])) {

This code seems to be duplicated across your project.

                    $this->allClasses[self::INTERNAL_CLASSES][$parentName] = $parentReflection;
                }
            } elseif (! $parentReflection->isTokenized()) {

This code seems to be duplicated across your project.

                if (! isset($this->allClasses[self::NONEXISTENT_CLASSES][$parentName])) {
                    $this->allClasses[self::NONEXISTENT_CLASSES][$parentName] = $parentReflection;
                }
            }
        }
    }

    private function isClassLoaded(string $name): bool
    {
        return isset($this->allClasses[self::TOKENIZED_CLASSES][$name])
            || isset($this->allClasses[self::INTERNAL_CLASSES][$name])
            || isset($this->allClasses[self::NONEXISTENT_CLASSES][$name]);
    }

    /**
     * @param ClassReflectionInterface|MethodReflectionInterface $reflection
     * @param mixed[] $annotations
     * @param string $name
     */
    private function loadAnnotationFromReflection($reflection, array $annotations, $name): void
    {
        if (! isset($annotations[$name])) {
            return;
        }

        foreach ($annotations[$name] as $doc) {
            foreach (explode('|', preg_replace('~\\s.*~', '', $doc)) as $name) {
                $name = rtrim($name, '[]');
                if ($name) {
                    $name = $this->getClassFqn($name, $reflection);
                    $this->addClass($name);
                }
            }
        }
    }

    /**
     * @param string $name
     * @param ClassReflectionInterface|MethodReflectionInterface|InNamespaceInterface $reflection
     */
    private function getClassFqn(string $name, $reflection): string
    {
        return Resolver::resolveClassFQN(
            $name,
            $reflection->getNamespaceAliases(),
            $reflection->getNamespaceName()
        );
    }
}