Spiral\Attributes\AnnotationReader

Complexity

Total Complexity

15

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	isAvailable()	0	3	1
A	__construct()	0	9	2
A	filter()	0	11	4
A	getParameterMetadata()	0	3	1
A	getClassMetadata()	0	5	1
A	getPropertyMetadata()	0	5	1
A	getFunctionMetadata()	0	9	2
A	checkAvailability()	0	7	2
A	getConstantMetadata()	0	3	1

<?php

/**
 * This file is part of Spiral Framework package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Spiral\Attributes;

use Doctrine\Common\Annotations\AnnotationReader as DoctrineReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;

This use statement conflicts with another class in this namespace, Spiral\Attributes\Reader. Consider defining an alias.

use Spiral\Attributes\Exception\InitializationException;
use Spiral\Attributes\Reader as BaseReader;

final class AnnotationReader extends BaseReader
{
    /**
     * @var Reader|null
     */
    private $reader;

    /**
     * @param Reader|null $reader
     */
    public function __construct(Reader $reader = null)
    {
        $this->checkAvailability();

        $this->reader = $reader ?? new DoctrineReader();

        // doctrine/annotations ^1.0 compatibility.
        if (\method_exists(AnnotationRegistry::class, 'registerLoader')) {
            AnnotationRegistry::registerLoader('\\class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerLoader() has been deprecated: This method is deprecated and will be removed in doctrine/annotations 2.0. Annotations will be autoloaded in 2.0.

        }
    }

    /**
     * @return void
     */
    private function checkAvailability(): void
    {
        if ($this->isAvailable()) {
            return;
        }

        throw new InitializationException('Requires the "doctrine/annotations" package');
    }

    /**
     * @return bool
     */
    protected function isAvailable(): bool
    {
        return \interface_exists(Reader::class);
    }

    /**
     * {@inheritDoc}
     */
    public function getClassMetadata(\ReflectionClass $class, string $name = null): iterable
    {
        $result = $this->reader->getClassAnnotations($class);

The method getClassAnnotations() does not exist on null.

        return $this->filter($name, $result);
    }

    /**
     * @param string|null       $name
     * @param iterable|object[] $annotations
     * @return object[]
     */
    private function filter(?string $name, iterable $annotations): iterable
    {
        if ($name === null) {
            yield from $annotations;

            return;
        }

        foreach ($annotations as $annotation) {
            if ($annotation instanceof $name) {
                yield $annotation;
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function getFunctionMetadata(\ReflectionFunctionAbstract $function, string $name = null): iterable
    {
        if ($function instanceof \ReflectionMethod) {
            $result = $this->reader->getMethodAnnotations($function);

            return $this->filter($name, $result);
        }

        return [];
    }

    /**
     * {@inheritDoc}
     */
    public function getPropertyMetadata(\ReflectionProperty $property, string $name = null): iterable
    {
        $result = $this->reader->getPropertyAnnotations($property);

        return $this->filter($name, $result);
    }

    /**
     * {@inheritDoc}
     */
    public function getConstantMetadata(\ReflectionClassConstant $constant, string $name = null): iterable
    {
        return [];
    }

    /**
     * {@inheritDoc}
     */
    public function getParameterMetadata(\ReflectionParameter $parameter, string $name = null): iterable
    {
        return [];
    }
}