JMS\Serializer\Metadata\Driver\DoctrineTypeDriver

Complexity

Total Complexity

17

Size/Duplication

Total Lines	57
Duplicated Lines	0 %

Test Coverage

Coverage

95.24%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	setDiscriminator()	0	9	5
C	setPropertyType()	0	36	12

<?php

declare(strict_types=1);

namespace JMS\Serializer\Metadata\Driver;

use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Doctrine\Persistence\Mapping\ClassMetadata as DoctrineClassMetadata;
use JMS\Serializer\Metadata\ClassMetadata;
use JMS\Serializer\Metadata\PropertyMetadata;

/**
 * This class decorates any other driver. If the inner driver does not provide a
 * a property type, the decorator will guess based on Doctrine 2 metadata.
 */
class DoctrineTypeDriver extends AbstractDoctrineTypeDriver
{
    protected function setDiscriminator(DoctrineClassMetadata $doctrineMetadata, ClassMetadata $classMetadata): void
    {
        if (
            empty($classMetadata->discriminatorMap) && !$classMetadata->discriminatorDisabled
            && !empty($doctrineMetadata->discriminatorMap) && $doctrineMetadata->isRootEntity()

Accessing discriminatorMap on the interface Doctrine\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

The method isRootEntity() does not exist on Doctrine\Persistence\Mapping\ClassMetadata. It seems like you code against a sub-type of Doctrine\Persistence\Mapping\ClassMetadata such as Doctrine\ORM\Mapping\ClassMetadataInfo.

        ) {
            $classMetadata->setDiscriminator(
                $doctrineMetadata->discriminatorColumn['name'],

Accessing discriminatorColumn on the interface Doctrine\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

                $doctrineMetadata->discriminatorMap
            );
        }
    }

    /**
     * @param ClassMetadataInfo $doctrineMetadata
     * @param PropertyMetadata $propertyMetadata
     *
     * @return void
     */
    protected function setPropertyType(DoctrineClassMetadata $doctrineMetadata, PropertyMetadata $propertyMetadata): void
    {
        $propertyName = $propertyMetadata->name;
        if (
            $doctrineMetadata->hasField($propertyName)
            && ($typeOfFiled = $doctrineMetadata->getTypeOfField($propertyName))
            && ($fieldType = $this->normalizeFieldType($typeOfFiled))
        ) {
            if (PHP_VERSION_ID >= 80100 && ($fieldMapping = $doctrineMetadata->getFieldMapping($propertyName)) && isset($fieldMapping['enumType'])) {

The method getFieldMapping() does not exist on Doctrine\Persistence\Mapping\ClassMetadata. It seems like you code against a sub-type of Doctrine\Persistence\Mapping\ClassMetadata such as Doctrine\ORM\Mapping\ClassMetadataInfo or Doctrine\ODM\PHPCR\Mapping\ClassMetadata.

                $fieldType = $fieldMapping['enumType'];
            }

            $propertyMetadata->setType($this->typeParser->parse($fieldType));

            return;
        }

        if ($doctrineMetadata->hasAssociation($propertyName)) {
            $targetEntity = $doctrineMetadata->getAssociationTargetClass($propertyName);

            if (null === $targetMetadata = $this->tryLoadingDoctrineMetadata($targetEntity)) {

It seems like $targetEntity can also be of type null; however, parameter $className of JMS\Serializer\Metadata\Driver\AbstractDoctrineTypeDriver::tryLoadingDoctrineMetadata() does only seem to accept string, maybe add an additional type check?

                return;
            }

            // For inheritance schemes, we cannot add any type as we would only add the super-type of the hierarchy.
            // On serialization, this would lead to only the supertype being serialized, and properties of subtypes
            // being ignored.
            if ($targetMetadata instanceof DoctrineClassMetadata && !$targetMetadata->isInheritanceTypeNone()) {

The method isInheritanceTypeNone() does not exist on Doctrine\Persistence\Mapping\ClassMetadata. It seems like you code against a sub-type of Doctrine\Persistence\Mapping\ClassMetadata such as Doctrine\ORM\Mapping\ClassMetadataInfo.

                return;
            }

            if (!$doctrineMetadata->isSingleValuedAssociation($propertyName)) {
                $targetEntity = sprintf('ArrayCollection<%s>', $targetEntity);
            }

            $propertyMetadata->setType($this->typeParser->parse($targetEntity));

It seems like $targetEntity can also be of type null; however, parameter $type of JMS\Serializer\Type\ParserInterface::parse() does only seem to accept string, maybe add an additional type check?

        }
    }
}