DefaultAnnotationMetadataAssembler::assemble() - Code Metrics - Inspection of "Some tests" - Majkl578/doctrine-annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — new-parser-ast-metadata (#2)

unknown

created 2018-10-11 15:37 UTC

DefaultAnnotationMetadataAssembler::assemble() A

↳ Parent: DefaultAnnotationMetadataAssembler

Complexity

Conditions	3
Paths	1

Size

Total Lines	24
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	3

Importance

Changes

Metric	Value
eloc	16
dl	0
loc	24
ccs	17
cts	17
cp	1
rs	9.7333
c	0
b	0
f	0
cc	3
nc	1
nop	2
crap	3

<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Metadata\Assembler;

use Doctrine\Annotations\Annotation\Annotation as AnnotationAnnotation;
use Doctrine\Annotations\Annotation\Required as RequiredAnnotation;
use Doctrine\Annotations\Annotation\Target as TargetAnnotation;
use Doctrine\Annotations\Annotation\Target;
use Doctrine\Annotations\Assembler\Assembler;
use Doctrine\Annotations\Metadata\AnnotationMetadata;
use Doctrine\Annotations\Metadata\AnnotationTarget;
use Doctrine\Annotations\Metadata\InternalAnnotations;
use Doctrine\Annotations\Metadata\PropertyMetadata;
use Doctrine\Annotations\Metadata\Reflection\ClassReflectionProvider;
use Doctrine\Annotations\Metadata\ScopeManufacturer;
use Doctrine\Annotations\Metadata\Type\MixedType;
use Doctrine\Annotations\Metadata\Type\NullType;
use Doctrine\Annotations\Metadata\Type\Type;
use Doctrine\Annotations\Metadata\Type\UnionType;
use Doctrine\Annotations\TypeParser\PHPStanTypeParser;
use Doctrine\Annotations\Parser\Ast\Annotations;
use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Compiler;
use Doctrine\Annotations\Parser\Reference\ReferenceResolver;
use Doctrine\Annotations\Parser\Scope;
use Doctrine\Annotations\TypeParser\TypeParser;
use ReflectionClass;
use ReflectionProperty;
use function assert;
use function is_array;
use function iterator_to_array;
use function stripos;

final class DefaultAnnotationMetadataAssembler implements AnnotationMetadataAssembler
{
    /** @var Compiler */
    private $parser;

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

    /** @var ClassReflectionProvider */
    private $classReflectionProvider;

    /** @var TypeParser */
    private $typeParser;

    /** @var ScopeManufacturer */
    private $scopeManufacturer;

    /** @var Assembler */
    private $internalAssembler;

    public function __construct(
        Compiler $parser,
        ReferenceResolver $referenceResolver,
        ClassReflectionProvider $classReflectionProvider,
        TypeParser $typeParser,
        ScopeManufacturer $scopeManufacturer,
        Assembler $internalAssembler
    ) {
        $this->parser                  = $parser;
        $this->referenceResolver       = $referenceResolver;
        $this->classReflectionProvider = $classReflectionProvider;
        $this->typeParser              = $typeParser;
        $this->scopeManufacturer       = $scopeManufacturer;
        $this->internalAssembler       = $internalAssembler;
    }

    public function assemble(Reference $reference, Scope $scope) : AnnotationMetadata
    {
        $realName        = $this->referenceResolver->resolve($reference, $scope);
        $classReflection = $this->classReflectionProvider->getClassReflection($realName);
        $docComment      = $classReflection->getDocComment();
        $hasConstructor  = $classReflection->getConstructor() !== null;

        assert($docComment !== false, 'not an annotation');

        $annotations = $this->parser->compile($docComment);
        $annotations = $this->parser->compile(/** @scrutinizer ignore-type */ $docComment);

        assert(stripos($docComment, '@') !== false);
        assert(stripos(/** @scrutinizer ignore-type */ $docComment, '@') !== false);

        $hydratedAnnotations = $this->hydrateInternalAnnotations($annotations, $scope);

        assert($this->findAnnotation(AnnotationAnnotation::class, $hydratedAnnotations) !== null, 'not annotated with @Annotation');
        assert(! $hasConstructor || $classReflection->getConstructor()->isPublic(), 'constructor must be public');
        assert(! $hasConstructor || $classReflection->getConstructor()->getNumberOfParameters() === 1, 'constructor must accept a single parameter');

        return new AnnotationMetadata(
            $realName,
            $this->determineTarget($hydratedAnnotations),
            $hasConstructor,
            $this->assembleProperties($classReflection)
        );
    }

    /**
     * @param object[] $annotations
     */
    private function determineTarget(array $annotations) : AnnotationTarget
    {
        /** @var TargetAnnotation|null $target */
        $target = $this->findAnnotation(TargetAnnotation::class, $annotations);

        if ($target === null) {
            return new AnnotationTarget(AnnotationTarget::TARGET_ALL);
        }

        return new AnnotationTarget($target->targets);

    }

    /**
     * @return object[]
     */
    private function hydrateInternalAnnotations(Annotations $annotations, Scope $scope) : array
    {
        $assembled = $this->internalAssembler->collect(
            $annotations,
            new Scope($scope->getSubject(), InternalAnnotations::createImports(), clone $scope->getIgnoredAnnotations())
        );

        return is_array($assembled) ? $assembled : iterator_to_array($assembled);
    }

    /**
     * @param object[] $annotations
     */
    private function findAnnotation(string $name, array $annotations) : ?object
    {
        foreach ($annotations as $annotation) {
            if (! $annotation instanceof $name) {
                continue;
            }

            return $annotation;
        }

        return null;
    }

    /**
     * @return PropertyMetadata[]
     */
    private function assembleProperties(ReflectionClass $class) : array
    {
        $metadatas = [];

        foreach ($class->getProperties(ReflectionProperty::IS_PUBLIC) as $i => $property) {
            $metadatas[] = $this->assembleProperty($property, $i === 0);
        }

        return $metadatas;
    }

    private function assembleProperty(ReflectionProperty $property, bool $first) : PropertyMetadata
    {
        $docBlock = $property->getDocComment();

        if ($docBlock === false) {
            return new PropertyMetadata(
                $property->getName(),
                new MixedType(),
                $first
            );
        }

        $scope               = $this->scopeManufacturer->manufacturePropertyScope($property);
        $hydratedAnnotations = $this->hydrateInternalAnnotations($this->parser->compile($docBlock), $scope);
        $hydratedAnnotations = $this->hydrateInternalAnnotations($this->parser->compile(/** @scrutinizer ignore-type */ $docBlock), $scope);

        $required = $this->findAnnotation(RequiredAnnotation::class, $hydratedAnnotations) !== null;

        $type = $this->typeParser->parsePropertyType($property->getDocComment(), $scope);
        $type = $this->typeParser->parsePropertyType(/** @scrutinizer ignore-type */ $property->getDocComment(), $scope);

        if ($required && ! $type->acceptsNull()) {
            // TODO: throw deprecated warning?
            $type = new UnionType($type, new NullType());
        }

        return new PropertyMetadata($property->getName(), $type, $first);
    }
}


Majkl578 / doctrine-annotations

Pull Request — new-parser-ast-metadata (#2)

DefaultAnnotationMetadataAssembler::assemble() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like