Spiral\Attributes\Internal\DoctrineAnnotationReader

Complexity

Total Complexity

19

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

72.09%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getPropertyMetadata()	0	5	1
A	getFunctionMetadata()	0	9	2
A	getConstantMetadata()	0	3	1
A	checkAvailability()	0	7	2
A	getParameterMetadata()	0	3	1
A	wrapDoctrineExceptions()	0	21	6
A	isAvailable()	0	3	1
A	__construct()	0	6	1
A	getClassMetadata()	0	8	2
A	bootAnnotations()	0	5	2

<?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\Internal;

use ReflectionClass;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionProperty;
use ReflectionClassConstant;
use ReflectionParameter;
use Closure;
use Doctrine\Common\Annotations\AnnotationException;
use Doctrine\Common\Annotations\AnnotationReader as DoctrineReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;
use Spiral\Attributes\Exception\AttributeException;
use Spiral\Attributes\Exception\InitializationException;
use Spiral\Attributes\Exception\SemanticAttributeException;
use Spiral\Attributes\Exception\SyntaxAttributeException;
use Spiral\Attributes\Reader as BaseReader;

final class DoctrineAnnotationReader extends BaseReader
{
    private ?\Doctrine\Common\Annotations\Reader $reader = null;

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

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

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

The method getClassAnnotations() does not exist on null.

        yield from $this->filter($name, $result);

        foreach ($class->getTraits() as $trait) {
            yield from $this->getClassMetadata($trait, $name);
        }
    }

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

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

        return [];
    }

    /**
     * {@inheritDoc}
     */
    public function getPropertyMetadata(ReflectionProperty $property, string $name = null): iterable
    {
        $result = $this->wrapDoctrineExceptions(fn() => $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 [];
    }

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

    private function wrapDoctrineExceptions(Closure $then): iterable
    {
        try {
            return $then();
        } catch (AnnotationException $e) {
            switch (true) {
                case \str_starts_with($e->getMessage(), '[Syntax Error]'):
                case \str_starts_with($e->getMessage(), '[Type Error]'):
                    $class = SyntaxAttributeException::class;
                    break;

                case \str_starts_with($e->getMessage(), '[Semantical Error]'):
                case \str_starts_with($e->getMessage(), '[Creation Error]'):
                    $class = SemanticAttributeException::class;
                    break;

                default:
                    $class = AttributeException::class;
            }

            throw new $class($e->getMessage(), $e->getCode(), $e);
        }
    }

    private function bootAnnotations(): void
    {
        // 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.

        }
    }

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

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