AnnotationDriver::getClassAnnotations() - Code Metrics - Inspection of "Removed PHP and Static PHP mapping drivers, since..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — develop ( 01a8a8...14ce66 )

by Guilherme
created 2017-08-10 14:45 UTC
AnnotationDriver::getClassAnnotations() A

↳ Parent: AnnotationDriver
Complexity

Conditions	3
Paths	3
Size

Total Lines	14
Code Lines	7
Duplication

Lines	14
Ratio	100 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
dl	14
loc	14
rs	9.4285
c	0
b	0
f	0
ccs	0
cts	0
cp	0
cc	3
eloc	7
nc	3
nop	1
crap	12
<?php

declare(strict_types=1);

namespace Doctrine\ORM\Mapping\Driver;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Annotation;
use Doctrine\ORM\Events;
use Doctrine\ORM\Mapping;

/**
 * The AnnotationDriver reads the mapping metadata from docblock annotations.
 *
 * @since 2.0
 * @author Benjamin Eberlei <[email protected]>
 * @author Guilherme Blanco <[email protected]>
 * @author Jonathan H. Wage <[email protected]>
 * @author Roman Borschel <[email protected]>
 */
class AnnotationDriver implements MappingDriver
{
    /**
     * {@inheritDoc}
     */
    protected $entityAnnotationClasses = [
        Annotation\Entity::class           => 1,
        Annotation\MappedSuperclass::class => 2,
    ];

    /**
     * The AnnotationReader.
     *
     * @var AnnotationReader
     */
    protected $reader;

    /**
     * The paths where to look for mapping files.
     *
     * @var array
     */
    protected $paths = [];

    /**
     * The paths excluded from path where to look for mapping files.
     *
     * @var array
     */
    protected $excludePaths = [];

    /**
     * The file extension of mapping documents.
     *
     * @var string
     */
    protected $fileExtension = '.php';

    /**
     * Cache for AnnotationDriver#getAllClassNames().
     *
     * @var array|null
     */
    protected $classNames;

    /**
     * Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
     * docblock annotations.
     *
     * @param AnnotationReader  $reader The AnnotationReader to use, duck-typed.
     * @param string|array|null $paths  One or multiple paths where mapping classes can be found.
     */
    public function __construct($reader, $paths = null)
    {
        $this->reader = $reader;
        if ($paths) {
            $this->addPaths((array) $paths);
        }
    }

    /**
     * Appends lookup paths to metadata driver.
     *
     * @param array $paths
     *
     * @return void
     */
    public function addPaths(array $paths)
    {
        $this->paths = array_unique(array_merge($this->paths, $paths));
    }

    /**
     * Retrieves the defined metadata lookup paths.
     *
     * @return array
     */
    public function getPaths()
    {
        return $this->paths;
    }

    /**
     * Append exclude lookup paths to metadata driver.
     *
     * @param array $paths
     */
    public function addExcludePaths(array $paths)
    {
        $this->excludePaths = array_unique(array_merge($this->excludePaths, $paths));
    }

    /**
     * Retrieve the defined metadata lookup exclude paths.
     *
     * @return array
     */
    public function getExcludePaths()
    {
        return $this->excludePaths;
    }

    /**
     * Retrieve the current annotation reader
     *
     * @return AnnotationReader
     */
    public function getReader()
    {
        return $this->reader;
    }

    /**
     * Gets the file extension used to look for mapping files under.
     *
     * @return string
     */
    public function getFileExtension()
    {
        return $this->fileExtension;
    }

    /**
     * Sets the file extension used to look for mapping files under.
     *
     * @param string $fileExtension The file extension to set.
     *
     * @return void
     */
    public function setFileExtension($fileExtension)
    {
        $this->fileExtension = $fileExtension;
    }

    /**
     * Returns whether the class with the specified name is transient. Only non-transient
     * classes, that is entities and mapped superclasses, should have their metadata loaded.
     *
     * A class is non-transient if it is annotated with an annotation
     * from the {@see AnnotationDriver::entityAnnotationClasses}.
     *
     * @param string $className
     *
     * @return boolean
     */
    public function isTransient($className)
    {
        $classAnnotations = $this->reader->getClassAnnotations(new \ReflectionClass($className));

        foreach ($classAnnotations as $annot) {
            if (isset($this->entityAnnotationClasses[get_class($annot)])) {
                return false;
            }
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function getAllClassNames()
    {
        if ($this->classNames !== null) {
            return $this->classNames;
        }

        if (!$this->paths) {

            throw Mapping\MappingException::pathRequired();
        }

        $classes = [];
        $includedFiles = [];

        foreach ($this->paths as $path) {
            if ( ! is_dir($path)) {
                throw Mapping\MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
            }

            $iterator = new \RegexIterator(
                new \RecursiveIteratorIterator(
                    new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS),
                    \RecursiveIteratorIterator::LEAVES_ONLY
                ),
                '/^.+' . preg_quote($this->fileExtension) . '$/i',
                \RecursiveRegexIterator::GET_MATCH
            );

            foreach ($iterator as $file) {
                $sourceFile = $file[0];

                if ( ! preg_match('(^phar:)i', $sourceFile)) {
                    $sourceFile = realpath($sourceFile);
                }

                foreach ($this->excludePaths as $excludePath) {
                    $exclude = str_replace('\\', '/', realpath($excludePath));
                    $current = str_replace('\\', '/', $sourceFile);

                    if (strpos($current, $exclude) !== false) {
                        continue 2;
                    }
                }

                require_once $sourceFile;

                $includedFiles[] = $sourceFile;
            }
        }

        $declared = get_declared_classes();

        foreach ($declared as $className) {
            $rc = new \ReflectionClass($className);
            $sourceFile = $rc->getFileName();
            if (in_array($sourceFile, $includedFiles) && ! $this->isTransient($className)) {
                $classes[] = $className;
            }
        }

        $this->classNames = $classes;

        return $classes;
    }

    /**
     * {@inheritDoc}
     */
    public function loadMetadataForClass(
        string $className,
        Mapping\ClassMetadata $metadata,
        Mapping\ClassMetadataBuildingContext $metadataBuildingContext
    ) : Mapping\ClassMetadata
    {
        $reflectionClass = $metadata->getReflectionClass();

        if (! $reflectionClass) {
            // this happens when running annotation driver in combination with
            // static reflection services. This is not the nicest fix
            $reflectionClass = new \ReflectionClass($metadata->getClassName());
        }

        $classAnnotations = $this->getClassAnnotations($reflectionClass);
        $classMetadata    = $this->convertClassAnnotationsToClassMetadata(
            $classAnnotations,
            $reflectionClass,
            $metadata
        );

        // Evaluate Table annotation
        if (isset($classAnnotations[Annotation\Table::class])) {

            $tableAnnot = $classAnnotations[Annotation\Table::class];
            $table      = $this->convertTableAnnotationToTableMetadata($tableAnnot);

            $classMetadata->setTable($table);
        }

        // Evaluate @Cache annotation
        if (isset($classAnnotations[Annotation\Cache::class])) {

            $cacheAnnot = $classAnnotations[Annotation\Cache::class];
            $cache      = $this->convertCacheAnnotationToCacheMetadata($cacheAnnot, $metadata);

            $classMetadata->setCache($cache);
        }

        // Evaluate NamedNativeQueries annotation
        if (isset($classAnnotations[Annotation\NamedNativeQueries::class])) {

            $namedNativeQueriesAnnot = $classAnnotations[Annotation\NamedNativeQueries::class];

            foreach ($namedNativeQueriesAnnot->value as $namedNativeQuery) {
                $classMetadata->addNamedNativeQuery(
                    $namedNativeQuery->name,
                    $namedNativeQuery->query,
                    [
                        'resultClass'      => $namedNativeQuery->resultClass,
                        'resultSetMapping' => $namedNativeQuery->resultSetMapping,
                    ]
                );
            }
        }

        // Evaluate SqlResultSetMappings annotation
        if (isset($classAnnotations[Annotation\SqlResultSetMappings::class])) {

            $sqlResultSetMappingsAnnot = $classAnnotations[Annotation\SqlResultSetMappings::class];

            foreach ($sqlResultSetMappingsAnnot->value as $resultSetMapping) {
                $sqlResultSetMapping = $this->convertSqlResultSetMapping($resultSetMapping);

                $classMetadata->addSqlResultSetMapping($sqlResultSetMapping);
            }
        }

        // Evaluate NamedQueries annotation
        if (isset($classAnnotations[Annotation\NamedQueries::class])) {

            $namedQueriesAnnot = $classAnnotations[Annotation\NamedQueries::class];

            if ( ! is_array($namedQueriesAnnot->value)) {
                throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
            }

            foreach ($namedQueriesAnnot->value as $namedQuery) {
                if ( ! ($namedQuery instanceof Annotation\NamedQuery)) {
                    throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
                }

                $classMetadata->addNamedQuery($namedQuery->name, $namedQuery->query);
            }
        }

        // Evaluate InheritanceType annotation
        if (isset($classAnnotations[Annotation\InheritanceType::class])) {
            $inheritanceTypeAnnot = $classAnnotations[Annotation\InheritanceType::class];

            $classMetadata->setInheritanceType(
                constant(sprintf('%s::%s', Mapping\InheritanceType::class, $inheritanceTypeAnnot->value))
            );

            if ($classMetadata->inheritanceType !== Mapping\InheritanceType::NONE) {
                $discriminatorColumn = new Mapping\DiscriminatorColumnMetadata();

                $discriminatorColumn->setTableName($classMetadata->getTableName());
                $discriminatorColumn->setColumnName('dtype');
                $discriminatorColumn->setType(Type::getType('string'));
                $discriminatorColumn->setLength(255);

                // Evaluate DiscriminatorColumn annotation
                if (isset($classAnnotations[Annotation\DiscriminatorColumn::class])) {

                    /** @var Annotation\DiscriminatorColumn $discriminatorColumnAnnotation */
                    $discriminatorColumnAnnotation = $classAnnotations[Annotation\DiscriminatorColumn::class];
                    $typeName                      = ! empty($discriminatorColumnAnnotation->type)
                        ? $discriminatorColumnAnnotation->type
                        : 'string';

                    $discriminatorColumn->setType(Type::getType($typeName));
                    $discriminatorColumn->setColumnName($discriminatorColumnAnnotation->name);

                    if (! empty($discriminatorColumnAnnotation->columnDefinition)) {
                        $discriminatorColumn->setColumnDefinition($discriminatorColumnAnnotation->columnDefinition);
                    }

                    if (! empty($discriminatorColumnAnnotation->length)) {
                        $discriminatorColumn->setLength($discriminatorColumnAnnotation->length);
                    }
                }

                $classMetadata->setDiscriminatorColumn($discriminatorColumn);

                // Evaluate DiscriminatorMap annotation
                if (isset($classAnnotations[Annotation\DiscriminatorMap::class])) {

                    $discriminatorMapAnnotation = $classAnnotations[Annotation\DiscriminatorMap::class];
                    $discriminatorMap           = array_map(
                        function ($className) use ($classMetadata) {
                            return $classMetadata->fullyQualifiedClassName($className);
                        },
                        $discriminatorMapAnnotation->value
                    );

                    $classMetadata->setDiscriminatorMap($discriminatorMap);
                }
            }
        }

        // Evaluate @ChangeTrackingPolicy annotation
        if (isset($classAnnotations[Annotation\ChangeTrackingPolicy::class])) {

            $changeTrackingAnnot = $classAnnotations[Annotation\ChangeTrackingPolicy::class];

            $classMetadata->setChangeTrackingPolicy(
                constant(sprintf('%s::%s', Mapping\ChangeTrackingPolicy::class, $changeTrackingAnnot->value))
            );
        }

        // Evaluate @EntityListeners annotation
        if (isset($classAnnotations[Annotation\EntityListeners::class])) {

            /** @var Annotation\EntityListeners $entityListenersAnnot */
            $entityListenersAnnot = $classAnnotations[Annotation\EntityListeners::class];

            foreach ($entityListenersAnnot->value as $item) {
                $listenerClassName = $metadata->fullyQualifiedClassName($item);

                if (! class_exists($listenerClassName)) {
                    throw Mapping\MappingException::entityListenerClassNotFound(
                        $listenerClassName,
                        $classMetadata->getClassName()
                    );
                }

                $listenerClass = new \ReflectionClass($listenerClassName);

                /* @var $method \ReflectionMethod */
                foreach ($listenerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                    foreach ($this->getMethodCallbacks($method) as $callback) {
                        $classMetadata->addEntityListener($callback, $listenerClassName, $method->getName());

                    }
                }
            }
        }

        // Evaluate @HasLifecycleCallbacks annotation
        if (isset($classAnnotations[Annotation\HasLifecycleCallbacks::class])) {

            /* @var $method \ReflectionMethod */
            foreach ($reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                foreach ($this->getMethodCallbacks($method) as $callback) {
                    $classMetadata->addLifecycleCallback($method->getName(), $callback);

                }
            }
        }

        // Evaluate annotations on properties/fields
        /* @var $reflProperty \ReflectionProperty */
        foreach ($reflectionClass->getProperties() as $reflProperty) {
            if ($reflProperty->getDeclaringClass()->getName() !== $reflectionClass->getName()) {

                continue;
            }

            $propertyAnnotations = $this->getPropertyAnnotations($reflProperty);

            // Field can only be annotated with one of:
            // @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany, @Embedded

            switch (true) {
                case isset($propertyAnnotations[Annotation\Column::class]):
                    // Field found
                    $fieldMetadata = $this->convertReflectionPropertyToFieldMetadata(
                        $reflProperty,
                        $propertyAnnotations
                    );

                    $classMetadata->addProperty($fieldMetadata);
                    break;

                case isset($propertyAnnotations[Annotation\OneToOne::class]):
                    $assocMetadata = $this->convertReflectionPropertyToOneToOneAssociationMetadata(
                        $reflProperty,
                        $propertyAnnotations,
                        $metadata
                    );

                    $classMetadata->addProperty($assocMetadata);
                    break;

                case isset($propertyAnnotations[Annotation\ManyToOne::class]):
                    $assocMetadata = $this->convertReflectionPropertyToManyToOneAssociationMetadata(
                        $reflProperty,
                        $propertyAnnotations,
                        $metadata
                    );

                    $classMetadata->addProperty($assocMetadata);
                    break;

                case isset($propertyAnnotations[Annotation\OneToMany::class]):
                    $assocMetadata = $this->convertReflectionPropertyToOneToManyAssociationMetadata(
                        $reflProperty,
                        $propertyAnnotations,
                        $metadata
                    );

                    $classMetadata->addProperty($assocMetadata);
                    break;

                case isset($propertyAnnotations[Annotation\ManyToMany::class]):
                    $assocMetadata = $this->convertReflectionPropertyToManyToManyAssociationMetadata(
                        $reflProperty,
                        $propertyAnnotations,
                        $metadata
                    );

                    $classMetadata->addProperty($assocMetadata);
                    break;

                case isset($propertyAnnotations[Annotation\Embedded::class]):
                    $embeddedAnnot = $propertyAnnotations[Annotation\Embedded::class];

                    $mapping['fieldName']    = $reflProperty->getName();
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                    $mapping['class']        = $embeddedAnnot->class;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                    $mapping['columnPrefix'] = $embeddedAnnot->columnPrefix;

                    $classMetadata->mapEmbedded($mapping);
                    break;

                default:
                    $property = new Mapping\TransientMetadata($reflProperty->getName());

                    $classMetadata->addProperty($property);
                    break;
            }
        }

        // Evaluate AssociationOverrides annotation
        if (isset($classAnnotations[Annotation\AssociationOverrides::class])) {
            $associationOverridesAnnot = $classAnnotations[Annotation\AssociationOverrides::class];

            foreach ($associationOverridesAnnot->value as $associationOverride) {
                $fieldName = $associationOverride->name;
                $property  = $classMetadata->getProperty($fieldName);

                if (! $property) {
                    throw Mapping\MappingException::invalidOverrideFieldName($classMetadata->getClassName(), $fieldName);
                }

                $existingClass = get_class($property);
                $override      = new $existingClass($fieldName);

                // Check for JoinColumn/JoinColumns annotations
                if ($associationOverride->joinColumns) {
                    $joinColumns = [];

                    foreach ($associationOverride->joinColumns as $joinColumnAnnot) {
                        $joinColumns[] = $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot);
                    }

                    $override->setJoinColumns($joinColumns);
                }

                // Check for JoinTable annotations
                if ($associationOverride->joinTable) {
                    $joinTableAnnot    = $associationOverride->joinTable;
                    $joinTableMetadata = $this->convertJoinTableAnnotationToJoinTableMetadata($joinTableAnnot);

                    $override->setJoinTable($joinTableMetadata);
                }

                // Check for inversedBy
                if ($associationOverride->inversedBy) {
                    $override->setInversedBy($associationOverride->inversedBy);
                }

                // Check for fetch
                if ($associationOverride->fetch) {
                    $override->setFetchMode(
                        constant(Mapping\FetchMode::class . '::' . $associationOverride->fetch)
                    );
                }

                $classMetadata->setPropertyOverride($override);
            }
        }

        // Evaluate AttributeOverrides annotation
        if (isset($classAnnotations[Annotation\AttributeOverrides::class])) {
            $attributeOverridesAnnot = $classAnnotations[Annotation\AttributeOverrides::class];

            foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) {
                $fieldMetadata = $this->convertColumnAnnotationToFieldMetadata(
                    $attributeOverrideAnnot->column,
                    $attributeOverrideAnnot->name,
                    false
                );

                $classMetadata->setPropertyOverride($fieldMetadata);
            }
        }

        return $classMetadata;
    }

    private function convertClassAnnotationsToClassMetadata(
        array $classAnnotations,
        \ReflectionClass $reflectionClass,
        Mapping\ClassMetadata $metadata
    ) : Mapping\ClassMetadata
    {
        switch (true) {
            case isset($classAnnotations[Annotation\Entity::class]):
                return $this->convertClassAnnotationsToEntityClassMetadata(
                    $classAnnotations,
                    $reflectionClass,
                    $metadata
                );

                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case isset($classAnnotations[Annotation\MappedSuperclass::class]):
                return $this->convertClassAnnotationsToMappedSuperClassMetadata(
                    $classAnnotations,
                    $reflectionClass,
                    $metadata
                );

            case isset($classAnnotations[Annotation\Embeddable::class]):
                return $this->convertClassAnnotationsToEmbeddableClassMetadata(
                    $classAnnotations,
                    $reflectionClass,
                    $metadata
                );

            default:
                throw Mapping\MappingException::classIsNotAValidEntityOrMappedSuperClass($reflectionClass->getName());

        }
    }

    /**
     * @param array                 $classAnnotations
     * @param \ReflectionClass      $reflectionClass
     * @param Mapping\ClassMetadata $metadata
     *
     * @return Mapping\ClassMetadata
     *
     * @throws Mapping\MappingException
     * @throws \UnexpectedValueException
     */
    private function convertClassAnnotationsToEntityClassMetadata(
        array $classAnnotations,
        \ReflectionClass $reflectionClass,

        Mapping\ClassMetadata $metadata
    )
    {
        /** @var Annotation\Entity $entityAnnot */
        $entityAnnot  = $classAnnotations[Annotation\Entity::class];

        if ($entityAnnot->repositoryClass !== null) {
            $metadata->setCustomRepositoryClassName(
                $metadata->fullyQualifiedClassName($entityAnnot->repositoryClass)
            );
        }

        if ($entityAnnot->readOnly) {
            $metadata->asReadOnly();
        }

        return $metadata;
    }

    /**
     * @param array                 $classAnnotations
     * @param \ReflectionClass      $reflectionClass
     * @param Mapping\ClassMetadata $metadata
     *
     * @return Mapping\ClassMetadata
     */
    private function convertClassAnnotationsToMappedSuperClassMetadata(
        array $classAnnotations,
        \ReflectionClass $reflectionClass,

        Mapping\ClassMetadata $metadata
    ) : Mapping\ClassMetadata
    {
        /** @var Annotation\MappedSuperclass $mappedSuperclassAnnot */
        $mappedSuperclassAnnot = $classAnnotations[Annotation\MappedSuperclass::class];

        if ($mappedSuperclassAnnot->repositoryClass !== null) {
            $metadata->setCustomRepositoryClassName(
                $metadata->fullyQualifiedClassName($mappedSuperclassAnnot->repositoryClass)
            );
        }

        $metadata->isMappedSuperclass = true;
        $metadata->isEmbeddedClass = false;

        return $metadata;
    }

    /**
     * @param array                 $classAnnotations
     * @param \ReflectionClass      $reflectionClass
     * @param Mapping\ClassMetadata $metadata
     *
     * @return Mapping\ClassMetadata
     */
    private function convertClassAnnotationsToEmbeddableClassMetadata(
        array $classAnnotations,

        \ReflectionClass $reflectionClass,

        Mapping\ClassMetadata $metadata
    ) : Mapping\ClassMetadata
    {
        $metadata->isMappedSuperclass = false;
        $metadata->isEmbeddedClass = true;

        return $metadata;
    }

    /**
     * @param Annotation\SqlResultSetMapping $resultSetMapping
     *
     * @return array
     */
    private function convertSqlResultSetMapping(Annotation\SqlResultSetMapping $resultSetMapping)
    {
        $entities = [];

        foreach ($resultSetMapping->entities as $entityResultAnnot) {
            $entityResult = [
                'fields'                => [],
                'entityClass'           => $entityResultAnnot->entityClass,
                'discriminatorColumn'   => $entityResultAnnot->discriminatorColumn,
            ];

            foreach ($entityResultAnnot->fields as $fieldResultAnnot) {
                $entityResult['fields'][] = [
                    'name'      => $fieldResultAnnot->name,
                    'column'    => $fieldResultAnnot->column
                ];
            }

            $entities[] = $entityResult;
        }

        $columns = [];

        foreach ($resultSetMapping->columns as $columnResultAnnot) {
            $columns[] = [
                'name' => $columnResultAnnot->name,
            ];
        }

        return [
            'name'     => $resultSetMapping->name,
            'entities' => $entities,
            'columns'  => $columns
        ];
    }

    private function convertReflectionPropertyToFieldMetadata(
        \ReflectionProperty $reflProperty,
        array $propertyAnnotations
    )
    {
        $className   = $reflProperty->getDeclaringClass()->getName();

        $fieldName   = $reflProperty->getName();
        $isVersioned = isset($propertyAnnotations[Annotation\Version::class]);
        $columnAnnot = $propertyAnnotations[Annotation\Column::class];

        if ($columnAnnot->type == null) {
            throw Mapping\MappingException::propertyTypeIsRequired($className, $fieldName);
        }

        $fieldMetadata = $this->convertColumnAnnotationToFieldMetadata($columnAnnot, $fieldName, $isVersioned);

        // Check for Id
        if (isset($propertyAnnotations[Annotation\Id::class])) {
            $fieldMetadata->setPrimaryKey(true);
        }

        // Check for GeneratedValue strategy
        if (isset($propertyAnnotations[Annotation\GeneratedValue::class])) {
            $generatedValueAnnot = $propertyAnnotations[Annotation\GeneratedValue::class];
            $strategy = strtoupper($generatedValueAnnot->strategy);
            $idGeneratorType = constant(sprintf('%s::%s', Mapping\GeneratorType::class, $strategy));

            if ($idGeneratorType !== Mapping\GeneratorType::NONE) {
                $idGeneratorDefinition = [];

                // Check for CustomGenerator/SequenceGenerator/TableGenerator definition
                switch (true) {
                    case isset($propertyAnnotations[Annotation\SequenceGenerator::class]):
                        $seqGeneratorAnnot = $propertyAnnotations[Annotation\SequenceGenerator::class];

                        $idGeneratorDefinition = [
                            'sequenceName' => $seqGeneratorAnnot->sequenceName,
                            'allocationSize' => $seqGeneratorAnnot->allocationSize,
                        ];

                        break;

                    case isset($propertyAnnotations[Annotation\CustomIdGenerator::class]):
                        $customGeneratorAnnot = $propertyAnnotations[Annotation\CustomIdGenerator::class];

                        $idGeneratorDefinition = [
                            'class' => $customGeneratorAnnot->class,
                            'arguments' => $customGeneratorAnnot->arguments,
                        ];

                        break;

                    /* @todo If it is not supported, why does this exist? */
                    case isset($propertyAnnotations['Doctrine\ORM\Mapping\TableGenerator']):
                        throw Mapping\MappingException::tableIdGeneratorNotImplemented($className);
                }

                $fieldMetadata->setValueGenerator(new Mapping\ValueGeneratorMetadata($idGeneratorType, $idGeneratorDefinition));
            }
        }

        return $fieldMetadata;
    }

    private function convertReflectionPropertyToOneToOneAssociationMetadata(
        \ReflectionProperty $reflProperty,
        array $propertyAnnotations,
        Mapping\ClassMetadata $metadata
    )
    {
        $className     = $reflProperty->getDeclaringClass()->getName();

        $fieldName     = $reflProperty->getName();
        $oneToOneAnnot = $propertyAnnotations[Annotation\OneToOne::class];
        $assocMetadata = new Mapping\OneToOneAssociationMetadata($fieldName);
        $targetEntity  = $metadata->fullyQualifiedClassName($oneToOneAnnot->targetEntity);

        $assocMetadata->setTargetEntity($targetEntity);
        $assocMetadata->setCascade($this->getCascade($className, $fieldName, $oneToOneAnnot->cascade));
        $assocMetadata->setOrphanRemoval($oneToOneAnnot->orphanRemoval);
        $assocMetadata->setFetchMode($this->getFetchMode($className, $oneToOneAnnot->fetch));

        if (! empty($oneToOneAnnot->mappedBy)) {
            $assocMetadata->setMappedBy($oneToOneAnnot->mappedBy);
        }

        if (! empty($oneToOneAnnot->inversedBy)) {
            $assocMetadata->setInversedBy($oneToOneAnnot->inversedBy);
        }

        // Check for Id
        if (isset($propertyAnnotations[Annotation\Id::class])) {
            $assocMetadata->setPrimaryKey(true);
        }

        // Check for Cache
        if (isset($propertyAnnotations[Annotation\Cache::class])) {

            $cacheAnnot    = $propertyAnnotations[Annotation\Cache::class];
            $cacheMetadata = $this->convertCacheAnnotationToCacheMetadata($cacheAnnot, $metadata, $fieldName);

            $assocMetadata->setCache($cacheMetadata);
        }

        // Check for JoinColumn/JoinColumns annotations
        switch (true) {

            case isset($propertyAnnotations[Annotation\JoinColumn::class]):
                $joinColumnAnnot = $propertyAnnotations[Annotation\JoinColumn::class];

                $assocMetadata->addJoinColumn(
                    $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot)
                );

                break;

            case isset($propertyAnnotations[Annotation\JoinColumns::class]):
                $joinColumnsAnnot = $propertyAnnotations[Annotation\JoinColumns::class];

                foreach ($joinColumnsAnnot->value as $joinColumnAnnot) {
                    $assocMetadata->addJoinColumn(
                        $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot)
                    );
                }

                break;
        }

        return $assocMetadata;
    }

    private function convertReflectionPropertyToManyToOneAssociationMetadata(
        \ReflectionProperty $reflProperty,
        array $propertyAnnotations,
        Mapping\ClassMetadata $metadata
    )
    {
        $className      = $reflProperty->getDeclaringClass()->getName();

        $fieldName      = $reflProperty->getName();
        $manyToOneAnnot = $propertyAnnotations[Annotation\ManyToOne::class];
        $assocMetadata  = new Mapping\ManyToOneAssociationMetadata($fieldName);
        $targetEntity  = $metadata->fullyQualifiedClassName($manyToOneAnnot->targetEntity);

        $assocMetadata->setTargetEntity($targetEntity);
        $assocMetadata->setCascade($this->getCascade($className, $fieldName, $manyToOneAnnot->cascade));
        $assocMetadata->setFetchMode($this->getFetchMode($className, $manyToOneAnnot->fetch));

        if (! empty($manyToOneAnnot->inversedBy)) {
            $assocMetadata->setInversedBy($manyToOneAnnot->inversedBy);
        }

        // Check for Id
        if (isset($propertyAnnotations[Annotation\Id::class])) {
            $assocMetadata->setPrimaryKey(true);
        }

        // Check for Cache
        if (isset($propertyAnnotations[Annotation\Cache::class])) {

            $cacheAnnot    = $propertyAnnotations[Annotation\Cache::class];
            $cacheMetadata = $this->convertCacheAnnotationToCacheMetadata($cacheAnnot, $metadata, $fieldName);

            $assocMetadata->setCache($cacheMetadata);
        }

        // Check for JoinColumn/JoinColumns annotations
        switch (true) {

            case isset($propertyAnnotations[Annotation\JoinColumn::class]):
                $joinColumnAnnot = $propertyAnnotations[Annotation\JoinColumn::class];

                $assocMetadata->addJoinColumn(
                    $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot)
                );

                break;

            case isset($propertyAnnotations[Annotation\JoinColumns::class]):
                $joinColumnsAnnot = $propertyAnnotations[Annotation\JoinColumns::class];

                foreach ($joinColumnsAnnot->value as $joinColumnAnnot) {
                    $assocMetadata->addJoinColumn(
                        $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot)
                    );
                }

                break;
        }

        return $assocMetadata;
    }

    private function convertReflectionPropertyToOneToManyAssociationMetadata(
        \ReflectionProperty $reflProperty,
        array $propertyAnnotations,
        Mapping\ClassMetadata $metadata
    )
    {
        $className      = $reflProperty->getDeclaringClass()->getName();

        $fieldName      = $reflProperty->getName();
        $oneToManyAnnot = $propertyAnnotations[Annotation\OneToMany::class];
        $assocMetadata  = new Mapping\OneToManyAssociationMetadata($fieldName);
        $targetEntity  = $metadata->fullyQualifiedClassName($oneToManyAnnot->targetEntity);

        $assocMetadata->setTargetEntity($targetEntity);
        $assocMetadata->setCascade($this->getCascade($className, $fieldName, $oneToManyAnnot->cascade));
        $assocMetadata->setOrphanRemoval($oneToManyAnnot->orphanRemoval);
        $assocMetadata->setFetchMode($this->getFetchMode($className, $oneToManyAnnot->fetch));

        if (! empty($oneToManyAnnot->mappedBy)) {
            $assocMetadata->setMappedBy($oneToManyAnnot->mappedBy);
        }

        if (! empty($oneToManyAnnot->indexBy)) {
            $assocMetadata->setIndexedBy($oneToManyAnnot->indexBy);
        }

        // Check for OrderBy
        if (isset($propertyAnnotations[Annotation\OrderBy::class])) {

            $orderByAnnot = $propertyAnnotations[Annotation\OrderBy::class];

            $assocMetadata->setOrderBy($orderByAnnot->value);
        }

        // Check for Id
        if (isset($propertyAnnotations[Annotation\Id::class])) {
            $assocMetadata->setPrimaryKey(true);
        }

        // Check for Cache
        if (isset($propertyAnnotations[Annotation\Cache::class])) {

            $cacheAnnot    = $propertyAnnotations[Annotation\Cache::class];
            $cacheMetadata = $this->convertCacheAnnotationToCacheMetadata($cacheAnnot, $metadata, $fieldName);

            $assocMetadata->setCache($cacheMetadata);
        }

        return $assocMetadata;
    }

    private function convertReflectionPropertyToManyToManyAssociationMetadata(
        \ReflectionProperty $reflProperty,
        array $propertyAnnotations,
        Mapping\ClassMetadata $metadata
    )
    {
        $className       = $reflProperty->getDeclaringClass()->getName();

        $fieldName       = $reflProperty->getName();
        $manyToManyAnnot = $propertyAnnotations[Annotation\ManyToMany::class];
        $assocMetadata   = new Mapping\ManyToManyAssociationMetadata($fieldName);
        $targetEntity    = $metadata->fullyQualifiedClassName($manyToManyAnnot->targetEntity);

        $assocMetadata->setTargetEntity($targetEntity);
        $assocMetadata->setCascade($this->getCascade($className, $fieldName, $manyToManyAnnot->cascade));
        $assocMetadata->setOrphanRemoval($manyToManyAnnot->orphanRemoval);
        $assocMetadata->setFetchMode($this->getFetchMode($className, $manyToManyAnnot->fetch));

        if (! empty($manyToManyAnnot->mappedBy)) {
            $assocMetadata->setMappedBy($manyToManyAnnot->mappedBy);
        }

        if (! empty($manyToManyAnnot->inversedBy)) {
            $assocMetadata->setInversedBy($manyToManyAnnot->inversedBy);
        }

        if (! empty($manyToManyAnnot->indexBy)) {
            $assocMetadata->setIndexedBy($manyToManyAnnot->indexBy);
        }

        // Check for JoinTable
        if (isset($propertyAnnotations[Annotation\JoinTable::class])) {

            $joinTableAnnot    = $propertyAnnotations[Annotation\JoinTable::class];
            $joinTableMetadata = $this->convertJoinTableAnnotationToJoinTableMetadata($joinTableAnnot);

            $assocMetadata->setJoinTable($joinTableMetadata);
        }

        // Check for OrderBy
        if (isset($propertyAnnotations[Annotation\OrderBy::class])) {

            $orderByAnnot = $propertyAnnotations[Annotation\OrderBy::class];

            $assocMetadata->setOrderBy($orderByAnnot->value);
        }

        // Check for Id
        if (isset($propertyAnnotations[Annotation\Id::class])) {
            $assocMetadata->setPrimaryKey(true);
        }

        // Check for Cache
        if (isset($propertyAnnotations[Annotation\Cache::class])) {

            $cacheAnnot    = $propertyAnnotations[Annotation\Cache::class];
            $cacheMetadata = $this->convertCacheAnnotationToCacheMetadata($cacheAnnot, $metadata, $fieldName);

            $assocMetadata->setCache($cacheMetadata);
        }

        return $assocMetadata;
    }

    /**
     * Parse the given Column as FieldMetadata
     *
     * @param Annotation\Column $columnAnnot
     * @param string            $fieldName
     * @param bool              $isVersioned
     *
     * @return Mapping\FieldMetadata
     */
    private function convertColumnAnnotationToFieldMetadata(
        Annotation\Column $columnAnnot,
        string $fieldName,
        bool $isVersioned
    ) : Mapping\FieldMetadata
    {
        $fieldMetadata = $isVersioned
            ? new Mapping\VersionFieldMetadata($fieldName)
            : new Mapping\FieldMetadata($fieldName)
        ;

        $fieldMetadata->setType(Type::getType($columnAnnot->type));

        if (! empty($columnAnnot->name)) {
            $fieldMetadata->setColumnName($columnAnnot->name);
        }

        if (! empty($columnAnnot->columnDefinition)) {
            $fieldMetadata->setColumnDefinition($columnAnnot->columnDefinition);
        }

        if (! empty($columnAnnot->length)) {
            $fieldMetadata->setLength($columnAnnot->length);
        }

        if ($columnAnnot->options) {

            $fieldMetadata->setOptions($columnAnnot->options);
        }

        $fieldMetadata->setScale($columnAnnot->scale);
        $fieldMetadata->setPrecision($columnAnnot->precision);
        $fieldMetadata->setNullable($columnAnnot->nullable);
        $fieldMetadata->setUnique($columnAnnot->unique);

        return $fieldMetadata;
    }

    /**
     * Parse the given Table as TableMetadata
     *
     * @param Annotation\Table $tableAnnot
     *
     * @return Mapping\TableMetadata
     */
    private function convertTableAnnotationToTableMetadata(
        Annotation\Table $tableAnnot
    ) : Mapping\TableMetadata
    {
        $table = new Mapping\TableMetadata();

        if (! empty($tableAnnot->name)) {
            $table->setName($tableAnnot->name);
        }

        if (! empty($tableAnnot->schema)) {
            $table->setSchema($tableAnnot->schema);
        }

        foreach ($tableAnnot->options as $optionName => $optionValue) {
            $table->addOption($optionName, $optionValue);
        }

        foreach ($tableAnnot->indexes as $indexAnnot) {
            $table->addIndex([
                'name'    => $indexAnnot->name,
                'columns' => $indexAnnot->columns,
                'unique'  => $indexAnnot->unique,
                'options' => $indexAnnot->options,
                'flags'   => $indexAnnot->flags,
            ]);
        }

        foreach ($tableAnnot->uniqueConstraints as $uniqueConstraintAnnot) {
            $table->addUniqueConstraint([
                'name'    => $uniqueConstraintAnnot->name,
                'columns' => $uniqueConstraintAnnot->columns,
                'options' => $uniqueConstraintAnnot->options,
                'flags'   => $uniqueConstraintAnnot->flags,
            ]);
        }

        return $table;
    }

    /**
     * Parse the given JoinTable as JoinTableMetadata
     *
     * @param Annotation\JoinTable $joinTableAnnot
     *
     * @return Mapping\JoinTableMetadata
     */
    private function convertJoinTableAnnotationToJoinTableMetadata(
        Annotation\JoinTable $joinTableAnnot
    ) : Mapping\JoinTableMetadata
    {
        $joinTable = new Mapping\JoinTableMetadata();

        if (! empty($joinTableAnnot->name)) {
            $joinTable->setName($joinTableAnnot->name);
        }

        if (! empty($joinTableAnnot->schema)) {
            $joinTable->setSchema($joinTableAnnot->schema);
        }

        foreach ($joinTableAnnot->joinColumns as $joinColumnAnnot) {
            $joinColumn = $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot);

            $joinTable->addJoinColumn($joinColumn);
        }

        foreach ($joinTableAnnot->inverseJoinColumns as $joinColumnAnnot) {
            $joinColumn = $this->convertJoinColumnAnnotationToJoinColumnMetadata($joinColumnAnnot);

            $joinTable->addInverseJoinColumn($joinColumn);
        }

        return $joinTable;
    }

    /**
     * Parse the given JoinColumn as JoinColumnMetadata
     *
     * @param Annotation\JoinColumn $joinColumnAnnot
     *
     * @return Mapping\JoinColumnMetadata
     */
    private function convertJoinColumnAnnotationToJoinColumnMetadata(
        Annotation\JoinColumn $joinColumnAnnot
    ) : Mapping\JoinColumnMetadata
    {
        $joinColumn = new Mapping\JoinColumnMetadata();

        // @todo Remove conditionals for name and referencedColumnName once naming strategy is brought into drivers
        if (! empty($joinColumnAnnot->name)) {
            $joinColumn->setColumnName($joinColumnAnnot->name);
        }

        if (! empty($joinColumnAnnot->referencedColumnName)) {
            $joinColumn->setReferencedColumnName($joinColumnAnnot->referencedColumnName);
        }

        $joinColumn->setNullable($joinColumnAnnot->nullable);
        $joinColumn->setUnique($joinColumnAnnot->unique);

        if (! empty($joinColumnAnnot->fieldName)) {
            $joinColumn->setAliasedName($joinColumnAnnot->fieldName);
        }

        if (! empty($joinColumnAnnot->columnDefinition)) {
            $joinColumn->setColumnDefinition($joinColumnAnnot->columnDefinition);
        }

        if ($joinColumnAnnot->onDelete) {
            $joinColumn->setOnDelete(strtoupper($joinColumnAnnot->onDelete));
        }

        return $joinColumn;
    }

    /**
     * Parse the given Cache as CacheMetadata
     *
     * @param Annotation\Cache      $cacheAnnot
     * @param Mapping\ClassMetadata $metadata
     * @param null|string           $fieldName
     *
     * @return Mapping\CacheMetadata
     */
    private function convertCacheAnnotationToCacheMetadata(
        Annotation\Cache $cacheAnnot,
        Mapping\ClassMetadata $metadata,
        $fieldName = null
    ) : Mapping\CacheMetadata
    {
        $baseRegion    = strtolower(str_replace('\\', '_', $metadata->getRootClassName()));
        $defaultRegion = $baseRegion . ($fieldName ? '__' . $fieldName : '');

        $usage = constant(sprintf('%s::%s', Mapping\CacheUsage::class, $cacheAnnot->usage));
        $region = $cacheAnnot->region ?: $defaultRegion;

        return new Mapping\CacheMetadata($usage, $region);
    }

    /**
     * Attempts to resolve the cascade modes.
     *
     * @param string $className        The class name.
     * @param string $fieldName        The field name.
     * @param array  $originalCascades The original unprocessed field cascades.
     *
     * @return array The processed field cascades.
     *
     * @throws Mapping\MappingException If a cascade option is not valid.
     */
    private function getCascade(string $className, string $fieldName, array $originalCascades)
    {
        $cascadeTypes = ['remove', 'persist', 'refresh', 'merge', 'detach'];
        $cascades     = array_map('strtolower', $originalCascades);

        if (in_array('all', $cascades)) {
            $cascades = $cascadeTypes;
        }

        if (count($cascades) !== count(array_intersect($cascades, $cascadeTypes))) {
            $diffCascades = array_diff($cascades, array_intersect($cascades, $cascadeTypes));

            throw Mapping\MappingException::invalidCascadeOption($diffCascades, $className, $fieldName);
        }

        return $cascades;
    }

    /**
     * Attempts to resolve the fetch mode.
     *
     * @param string $className The class name.
     * @param string $fetchMode The fetch mode.
     *
     * @return string The fetch mode as defined in ClassMetadata.
     *
     * @throws Mapping\MappingException If the fetch mode is not valid.
     */
    private function getFetchMode($className, $fetchMode) : string
    {
        $fetchModeConstant = sprintf('%s::%s', Mapping\FetchMode::class, $fetchMode);

        if ( ! defined($fetchModeConstant)) {
            throw Mapping\MappingException::invalidFetchMode($className, $fetchMode);
        }

        return constant($fetchModeConstant);
    }

    /**
     * Parses the given method.
     *
     * @param \ReflectionMethod $method
     *
     * @return array
     */
    private function getMethodCallbacks(\ReflectionMethod $method) : array
    {
        $annotations = $this->getMethodAnnotations($method);
        $events      = [
            Events::prePersist  => Annotation\PrePersist::class,
            Events::postPersist => Annotation\PostPersist::class,
            Events::preUpdate   => Annotation\PreUpdate::class,
            Events::postUpdate  => Annotation\PostUpdate::class,
            Events::preRemove   => Annotation\PreRemove::class,
            Events::postRemove  => Annotation\PostRemove::class,
            Events::postLoad    => Annotation\PostLoad::class,
            Events::preFlush    => Annotation\PreFlush::class,
        ];

        // Check for callbacks
        $callbacks = [];

        foreach ($events as $eventName => $annotationClassName) {
            if (isset($annotations[$annotationClassName]) || $method->getName() === $eventName) {

                $callbacks[] = $eventName;
            }
        }

        return $callbacks;
    }

    /**
     * @param \ReflectionClass $reflectionClass
     *
     * @return array
     */
    private function getClassAnnotations(\ReflectionClass $reflectionClass) : array
    {
        $classAnnotations = $this->reader->getClassAnnotations($reflectionClass);

        foreach ($classAnnotations as $key => $annot) {
            if (! is_numeric($key)) {
                continue;
            }

            $classAnnotations[get_class($annot)] = $annot;
        }

        return $classAnnotations;
    }

    /**
     * @param \ReflectionProperty $reflectionProperty
     *
     * @return array
     */
    private function getPropertyAnnotations(\ReflectionProperty $reflectionProperty) : array
    {
        $propertyAnnotations = $this->reader->getPropertyAnnotations($reflectionProperty);

        foreach ($propertyAnnotations as $key => $annot) {
            if (! is_numeric($key)) {
                continue;
            }

            $propertyAnnotations[get_class($annot)] = $annot;
        }

        return $propertyAnnotations;
    }

    /**
     * @param \ReflectionMethod $reflectionMethod
     *
     * @return array
     */
    private function getMethodAnnotations(\ReflectionMethod $reflectionMethod) : array
    {
        $methodAnnotations = $this->reader->getMethodAnnotations($reflectionMethod);

        foreach ($methodAnnotations as $key => $annot) {
            if (! is_numeric($key)) {
                continue;
            }

            $methodAnnotations[get_class($annot)] = $annot;
        }

        return $methodAnnotations;
    }

    /**
     * Factory method for the Annotation Driver.
     *
     * @param array|string          $paths
     * @param AnnotationReader|null $reader
     *
     * @return AnnotationDriver
     */
    static public function create($paths = [], AnnotationReader $reader = null)

    {
        if ($reader == null) {
            $reader = new AnnotationReader();
        }

        return new self($reader, $paths);
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ORM\Mapping\Driver;
6
7			use Doctrine\Common\Annotations\AnnotationReader;
8			use Doctrine\DBAL\Types\Type;
9			use Doctrine\ORM\Annotation;
10			use Doctrine\ORM\Events;
11			use Doctrine\ORM\Mapping;
12
13			/**
14			* The AnnotationDriver reads the mapping metadata from docblock annotations.
15			*
16			* @since 2.0
17			* @author Benjamin Eberlei <[email protected]>
18			* @author Guilherme Blanco <[email protected]>
19			* @author Jonathan H. Wage <[email protected]>
20			* @author Roman Borschel <[email protected]>
21			*/
22			class AnnotationDriver implements MappingDriver
23			{
24			/**
25			* {@inheritDoc}
26			*/
27			protected $entityAnnotationClasses = [
28			Annotation\Entity::class => 1,
29			Annotation\MappedSuperclass::class => 2,
30			];
31
32			/**
33			* The AnnotationReader.
34			*
35			* @var AnnotationReader
36			*/
37			protected $reader;
38
39			/**
40			* The paths where to look for mapping files.
doctrine / orm

Push — develop ( 01a8a8...14ce66 )

AnnotationDriver::getClassAnnotations() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
