AnnotationMetadataAssembler::determinePropertyConstraint() - Code Metrics - Inspection of "Value validation" - Majkl578/doctrine-annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — new-parser-ast-metadata (#3)

unknown
created 2018-10-24 17:06 UTC
determinePropertyConstraint() A

↳ Parent: AnnotationMetadataAssembler
Complexity

Conditions	6
Paths	16
Size

Total Lines	22
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	11
CRAP Score	6
Importance

Changes
Metric	Value
eloc	10
dl	0
loc	22
ccs	11
cts	11
cp	1
rs	9.2222
c	0
b	0
f	0
cc	6
nc	16
nop	3
crap	6
<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Metadata\Assembler;

use Doctrine\Annotations\Annotation\Annotation as AnnotationAnnotation;
use Doctrine\Annotations\Annotation\Enum;
use Doctrine\Annotations\Annotation\Required as RequiredAnnotation;
use Doctrine\Annotations\Annotation\Target as TargetAnnotation;
use Doctrine\Annotations\Assembler\Assembler;
use Doctrine\Annotations\Metadata\AnnotationMetadata;
use Doctrine\Annotations\Metadata\AnnotationTarget;
use Doctrine\Annotations\Metadata\Constraint\CompositeConstraint;
use Doctrine\Annotations\Metadata\Constraint\Constraint;
use Doctrine\Annotations\Metadata\Constraint\EnumConstraint;
use Doctrine\Annotations\Metadata\Constraint\RequiredConstraint;
use Doctrine\Annotations\Metadata\Constraint\TypeConstraint;
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\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 count;
use function is_array;
use function iterator_to_array;
use function stripos;

final class 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);
        }

        return $metadatas;
    }

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

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

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

        /** @var RequiredAnnotation|null $required */
        $required = $this->findAnnotation(RequiredAnnotation::class, $hydratedAnnotations);
        /** @var Enum|null $enum */
        $enum = $this->findAnnotation(Enum::class, $hydratedAnnotations);

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

        return new PropertyMetadata(
            $property->getName(),
            $this->determinePropertyConstraint($type, $required, $enum)
        );
    }

    private function determinePropertyConstraint(Type $type, ?RequiredAnnotation $required, ?Enum $enum) : Constraint
    {
        if ($required && ! $type->acceptsNull()) {
            // TODO: throw deprecated warning?
            $type = new UnionType($type, new NullType());
        }

        $constraints = [new TypeConstraint($type)];

        if ($required) {
            $constraints[] = new RequiredConstraint();
        }

        if ($enum) {
            $constraints[] = new EnumConstraint($enum->value);
        }

        if (count($constraints) === 1) {
            return $constraints[0];
        }

        return new CompositeConstraint(...$constraints);
    }
}

Majkl578 / doctrine-annotations

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

determinePropertyConstraint() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
