AnnotationDriver::convertReflectionPropertyToFieldMetadata()

Complexity

Conditions	19
Paths	673

Size

Total Lines	119
Code Lines	63

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	52
CRAP Score	20.1584

Importance

Changes

0

<?php
    private function convertReflectionPropertyToFieldMetadata(
        ReflectionProperty $reflectionProperty,
        array $propertyAnnotations,
        Mapping\ClassMetadata $metadata,
        Mapping\ClassMetadataBuildingContext $metadataBuildingContext
    ) : Mapping\FieldMetadata {
        $className   = $metadata->getClassName();
        $fieldName   = $reflectionProperty->getName();
        $isVersioned = isset($propertyAnnotations[Annotation\Version::class]);
        $columnAnnot = $propertyAnnotations[Annotation\Column::class];

        if ($columnAnnot->type === null) {

Accessing type on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

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

        $fieldMetadata = new Mapping\FieldMetadata($fieldName);
        $columnName    = ! empty($columnAnnot->name)

Accessing name on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

            ? $columnAnnot->name
            : $metadataBuildingContext->getNamingStrategy()->propertyToColumnName($fieldName, $className);

        $fieldMetadata->setType(Type::getType($columnAnnot->type));
        $fieldMetadata->setVersioned($isVersioned);
        $fieldMetadata->setColumnName($columnName);

        if (! $metadata->isMappedSuperclass) {
            $fieldMetadata->setTableName($metadata->getTableName());
        }

        if (! empty($columnAnnot->columnDefinition)) {

Accessing columnDefinition on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

            $fieldMetadata->setColumnDefinition($columnAnnot->columnDefinition);
        }

        if (! empty($columnAnnot->length)) {

Accessing length on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

            $fieldMetadata->setLength($columnAnnot->length);
        }

        if ($columnAnnot->options) {

Accessing options on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

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

        $fieldMetadata->setScale($columnAnnot->scale);

Accessing scale on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

        $fieldMetadata->setPrecision($columnAnnot->precision);

Accessing precision on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

        $fieldMetadata->setNullable($columnAnnot->nullable);

Accessing nullable on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

        $fieldMetadata->setUnique($columnAnnot->unique);

Accessing unique on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

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

            if ($fieldMetadata->getType()->canRequireSQLConversion()) {
                throw Mapping\MappingException::sqlConversionNotAllowedForPrimaryKeyProperties($className, $fieldMetadata);
            }
        }

        // Prevent PK and version on same field
        if ($fieldMetadata->isPrimaryKey() && $fieldMetadata->isVersioned()) {
            throw Mapping\MappingException::cannotVersionIdField($className, $fieldName);
        }

        // Prevent column duplication
        if ($metadata->checkPropertyDuplication($columnName)) {
            throw Mapping\MappingException::duplicateColumnName($className, $columnName);
        }

        // Check for GeneratedValue strategy
        if (isset($propertyAnnotations[Annotation\GeneratedValue::class])) {
            $generatedValueAnnot = $propertyAnnotations[Annotation\GeneratedValue::class];
            $strategy            = strtoupper($generatedValueAnnot->strategy);

Accessing strategy on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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,

Accessing sequenceName on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

                            'allocationSize' => $seqGeneratorAnnot->allocationSize,

Accessing allocationSize on the interface Doctrine\ORM\Annotation\Annotation suggest that you code against a concrete implementation. How about adding an instanceof check?

                        ];

                        break;

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

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

                        if (! isset($idGeneratorDefinition['class'])) {
                            throw new Mapping\MappingException(
                                sprintf('Cannot instantiate custom generator, no class has been defined')
                            );
                        }

                        if (! class_exists($idGeneratorDefinition['class'])) {
                            throw new Mapping\MappingException(
                                sprintf('Cannot instantiate custom generator : %s', var_export($idGeneratorDefinition, true))
                            );
                        }

                        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;
    }