DescriptorLoader::__construct() - Code Metrics - Inspection of "v2.11.0" - sunrise-php/http-router - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#80)

by Anatoly
created 2021-10-11 18:42 UTC
DescriptorLoader::__construct() A

↳ Parent: DescriptorLoader
Complexity

Conditions	2
Paths	2
Size

Total Lines	13
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	7
CRAP Score	2
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	13
ccs	7
cts	7
cp	1
rs	10
cc	2
nc	2
nop	3
crap	2
<?php declare(strict_types=1);

/**
 * It's free open-source software released under the MIT License.
 *
 * @author Anatoly Fenric <[email protected]>
 * @copyright Copyright (c) 2018, Anatoly Fenric
 * @license https://github.com/sunrise-php/http-router/blob/master/LICENSE
 * @link https://github.com/sunrise-php/http-router
 */

namespace Sunrise\Http\Router\Loader;

/**
 * Import classes
 */
use Doctrine\Common\Annotations\AnnotationException;
use Doctrine\Common\Annotations\SimpleAnnotationReader;
use Psr\Container\ContainerInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\SimpleCache\CacheInterface;
use Sunrise\Http\Router\Annotation\Host;
use Sunrise\Http\Router\Annotation\Middleware;
use Sunrise\Http\Router\Annotation\Prefix;
use Sunrise\Http\Router\Annotation\Route;
use Sunrise\Http\Router\Exception\InvalidDescriptorException;
use Sunrise\Http\Router\Exception\InvalidLoaderResourceException;
use Sunrise\Http\Router\Exception\UnresolvableReferenceException;
use Sunrise\Http\Router\ReferenceResolver;
use Sunrise\Http\Router\ReferenceResolverInterface;
use Sunrise\Http\Router\RouteCollectionFactory;
use Sunrise\Http\Router\RouteCollectionFactoryInterface;
use Sunrise\Http\Router\RouteCollectionInterface;
use Sunrise\Http\Router\RouteFactory;
use Sunrise\Http\Router\RouteFactoryInterface;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ReflectionClass;
use ReflectionMethod;
use Reflector;

/**
 * Import functions
 */
use function array_diff;
use function class_exists;
use function get_declared_classes;
use function hash;
use function is_dir;
use function sprintf;
use function usort;

/**
 * Import constants
 */
use const PHP_MAJOR_VERSION;

/**
 * DescriptorLoader
 */
class DescriptorLoader implements LoaderInterface
{

    /**
     * @var string[]
     */
    private $resources = [];

    /**
     * @var RouteCollectionFactoryInterface
     */
    private $collectionFactory;

    /**
     * @var RouteFactoryInterface
     */
    private $routeFactory;

    /**
     * @var ReferenceResolverInterface
     */
    private $referenceResolver;

    /**
     * @var SimpleAnnotationReader|null
     */
    private $annotationReader = null;

    /**
     * @var CacheInterface|null
     */
    private $cache = null;

    /**
     * @var string|null
     */
    private $cacheKey = null;

    /**
     * Constructor of the class
     *
     * @param RouteCollectionFactoryInterface|null $collectionFactory
     * @param RouteFactoryInterface|null $routeFactory
     * @param ReferenceResolverInterface|null $referenceResolver
     */
    public function __construct(
        ?RouteCollectionFactoryInterface $collectionFactory = null,
        ?RouteFactoryInterface $routeFactory = null,
        ?ReferenceResolverInterface $referenceResolver = null
    ) {
        $this->collectionFactory = $collectionFactory ?? new RouteCollectionFactory();
        $this->routeFactory = $routeFactory ?? new RouteFactory();
        $this->referenceResolver = $referenceResolver ?? new ReferenceResolver();

        // the "doctrine/annotations" package must be installed manually
        if (class_exists(SimpleAnnotationReader::class)) {
            $this->annotationReader = /** @scrutinizer ignore-deprecated */ new SimpleAnnotationReader();
            $this->annotationReader->addNamespace('Sunrise\Http\Router\Annotation');
        }
    }

    /**
     * Gets the loader container
     *
     * @return ContainerInterface|null
     */
    public function getContainer() : ?ContainerInterface
    {
        return $this->referenceResolver->getContainer();
    }

    /**
     * Gets the loader cache
     *
     * @return CacheInterface|null
     */
    public function getCache() : ?CacheInterface
    {
        return $this->cache;
    }

    /**
     * Gets the loader cache key
     *
     * @return string|null
     *
     * @since 2.10.0
     */
    public function getCacheKey() : ?string
    {
        return $this->cacheKey;
    }

    /**
     * Sets the given container to the loader
     *
     * @param ContainerInterface|null $container
     *
     * @return void
     */
    public function setContainer(?ContainerInterface $container) : void
    {
        $this->referenceResolver->setContainer($container);
    }

    /**
     * Sets the given cache to the loader
     *
     * @param CacheInterface|null $cache
     *
     * @return void
     */
    public function setCache(?CacheInterface $cache) : void
    {
        $this->cache = $cache;
    }

    /**
     * Sets the given cache key to the loader
     *
     * @param string|null $cacheKey
     *
     * @return void
     *
     * @since 2.10.0
     */
    public function setCacheKey(?string $cacheKey) : void
    {
        $this->cacheKey = $cacheKey;
    }

    /**
     * {@inheritdoc}
     */
    public function attach($resource) : void
    {
        if (is_dir($resource)) {
            $resources = $this->scandir($resource);
            foreach ($resources as $resource) {

                $this->resources[] = $resource;
            }

            return;
        }

        if (!class_exists($resource)) {
            throw new InvalidLoaderResourceException(sprintf(
                'The resource "%s" is not found.',
                $resource
            ));
        }

        $this->resources[] = $resource;
    }

    /**
     * {@inheritdoc}
     */
    public function attachArray(array $resources) : void
    {
        foreach ($resources as $resource) {
            $this->attach($resource);
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws InvalidDescriptorException
     *         If one of the found descriptors isn't valid.
     *
     * @throws UnresolvableReferenceException
     *         If one of the found middlewares cannot be resolved.
     */
    public function load() : RouteCollectionInterface
    {
        $descriptors = $this->getCachedDescriptors();

        $routes = [];
        foreach ($descriptors as $descriptor) {
            $middlewares = $descriptor->middlewares;
            foreach ($middlewares as &$middleware) {
                $middleware = $this->referenceResolver->toMiddleware($middleware);
            }

            $routes[] = $this->routeFactory->createRoute(
                $descriptor->name,
                $descriptor->path,
                $descriptor->methods,
                $this->referenceResolver->toRequestHandler($descriptor->holder),
                $middlewares,
                $descriptor->attributes
            )
            ->setHost($descriptor->host)
            ->setSummary($descriptor->summary)
            ->setDescription($descriptor->description)
            ->setTags(...$descriptor->tags);
        }

        return $this->collectionFactory->createCollection(...$routes);
    }

    /**
     * Gets descriptors from the cache if they are stored in it,
     * otherwise gets them from the loader resources,
     * and then tries to cache them
     *
     * @return Route[]
     */
    private function getCachedDescriptors() : array
    {
        $key = $this->cacheKey ?? hash('md5', 'router:descriptors');

        if ($this->cache && $this->cache->has($key)) {
            return $this->cache->get($key);
        }

        $result = $this->getDescriptors();

        if ($this->cache) {
            $this->cache->set($key, $result);
        }

        return $result;
    }

    /**
     * Gets descriptors from the loader resources
     *
     * @return Route[]
     */
    private function getDescriptors() : array
    {
        $result = [];
        foreach ($this->resources as $resource) {
            $class = new ReflectionClass($resource);
            $descriptors = $this->getClassDescriptors($class);
            foreach ($descriptors as $descriptor) {
                $result[] = $descriptor;
            }
        }

        usort($result, function ($a, $b) {
            return $b->priority <=> $a->priority;
        });

        return $result;
    }

    /**
     * Gets descriptors from the given class
     *
     * @param ReflectionClass $class
     *
     * @return Route[]
     */
    private function getClassDescriptors(ReflectionClass $class) : array
    {
        $result = [];

        if ($class->isSubclassOf(RequestHandlerInterface::class)) {
            $descriptor = $this->getDescriptorFromClassOrMethod($class);
            if (isset($descriptor)) {
                $this->supplementDescriptorFromClassOrMethod($descriptor, $class);
                $descriptor->holder = $class->getName();
                $result[] = $descriptor;
            }
        }

        foreach ($class->getMethods() as $method) {
            // ignore non-available methods...
            if ($method->isStatic() ||
                $method->isPrivate() ||
                $method->isProtected()) {
                continue;
            }

            $descriptor = $this->getDescriptorFromClassOrMethod($method);
            if (isset($descriptor)) {
                $this->supplementDescriptorFromClassOrMethod($descriptor, $class);
                $this->supplementDescriptorFromClassOrMethod($descriptor, $method);
                $descriptor->holder = [$class->getName(), $method->getName()];
                $result[] = $descriptor;
            }
        }

        return $result;
    }

    /**
     * Gets a descriptor from the given class or method
     *
     * @param ReflectionClass|ReflectionMethod $classOrMethod
     *
     * @return Route|null
     *
     * @throws InvalidDescriptorException
     *         If the found descriptor isn't valid.
     */
    private function getDescriptorFromClassOrMethod(Reflector $classOrMethod) : ?Route
    {
        if (8 === PHP_MAJOR_VERSION) {
            $attributes = $classOrMethod->getAttributes(Route::class);
            $attributes = $classOrMethod->getAttributes(Route::class);
            if (isset($attributes[0])) {
                return $attributes[0]->newInstance();
            }
        }

        if (isset($this->annotationReader)) {
            try {
                return ($classOrMethod instanceof ReflectionClass) ?
                    $this->annotationReader->getClassAnnotation($classOrMethod, Route::class) :
                                             getClassAnnotation($classOrMethod, Route::class) :
                    $this->annotationReader->getMethodAnnotation($classOrMethod, Route::class);
            } catch (AnnotationException $e) {
                throw new InvalidDescriptorException($e->getMessage(), [], 0, $e);
            }
        }

        // @codeCoverageIgnoreStart
        return null;
        // @codeCoverageIgnoreEnd
    }

    /**
     * Supplements the given descriptor with a host and middlewares from the given class or method
     *
     * @param Route $descriptor
     * @param ReflectionClass|ReflectionMethod $classOrMethod
     *
     * @return void
     *
     * @since 2.11.0
     */
    private function supplementDescriptorFromClassOrMethod(Route $descriptor, Reflector $classOrMethod) : void
    {
        if (8 === PHP_MAJOR_VERSION) {
            $attributes = $classOrMethod->getAttributes(Host::class);
            if (isset($attributes[0])) {
                $descriptor->host = $attributes[0]->newInstance()->value;
            }

            $attributes = $classOrMethod->getAttributes(Middleware::class);
            foreach ($attributes as $attribute) {
                $descriptor->middlewares[] = $attribute->newInstance()->value;
            }

            $attributes = $classOrMethod->getAttributes(Prefix::class);
            if (isset($attributes[0])) {
                $descriptor->path = $attributes[0]->newInstance()->value . $descriptor->path;
            }
        }
    }

    /**
     * Scans the given directory and returns the found classes
     *
     * @param string $directory
     *
     * @return string[]
     */
    private function scandir(string $directory) : array
    {
        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($directory)
        );

        $declared = get_declared_classes();

        foreach ($files as $file) {
            if ('php' === $file->getExtension()) {
                require_once $file->getPathname();
            }
        }

        return array_diff(get_declared_classes(), $declared);
    }
}

sunrise-php / http-router

Pull Request — master (#80)

DescriptorLoader::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
