Bdf\Serializer\Metadata\Driver\JMSAnnotationDriver

Complexity

Total Complexity

26

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	isPropertyStatic()	0	10	2
F	getMetadataForClass()	0	53	14
A	getJmsMetadata()	0	16	4
A	__construct()	0	3	1
A	isJmsMetadataEmpty()	0	21	5

<?php

namespace Bdf\Serializer\Metadata\Driver;

use Bdf\Serializer\Metadata\Builder\ClassMetadataBuilder;
use Bdf\Serializer\Metadata\ClassMetadata;
use JMS\Serializer\Metadata\ClassMetadata as JMSClassMetadata;
use JMS\Serializer\Metadata\PropertyMetadata as JMSPropertyMetadata;
use Metadata\ClassMetadata as JMSBaseClassMetadata;
use Metadata\Driver\DriverInterface as JMSDriverInterface;
use ReflectionClass;

/**
 * The annotation driver use JMS annotation
 *
 * Works only with php 7.2
 */
class JMSAnnotationDriver implements DriverInterface
{
    /**
     * @var JMSDriverInterface
     */
    private $driver;

    /**
     * AnnotationDriver constructor.
     *
     * @param JMSDriverInterface $driver
     */
    public function __construct(JMSDriverInterface $driver)
    {
        $this->driver = $driver;
    }

    /**
     * {@inheritDoc}
     */
    public function getMetadataForClass(ReflectionClass $class): ?ClassMetadata
    {
        $builder = new ClassMetadataBuilder($class);
        $jmsMetadata = $this->getJmsMetadata($class);

        if ($this->isJmsMetadataEmpty($jmsMetadata)) {
            return null;
        }

        if ($jmsMetadata instanceof JMSClassMetadata) {
            if (isset($jmsMetadata->postSerializeMethods[0])) {
                $builder->postDenormalization($jmsMetadata->postSerializeMethods[0]->name);
            }
        }

        /** @var JMSPropertyMetadata $metadata */
        foreach ($jmsMetadata->propertyMetadata as $property => $metadata) {
            if ($this->isPropertyStatic($metadata)) {
                continue;
            }

            $propertyBuilder = $builder->add($property);
            $propertyBuilder->alias($metadata->serializedName);
            $propertyBuilder->readOnly($metadata->readOnly);
            $propertyBuilder->inline($metadata->inline);

            if ($metadata->sinceVersion) {
                $propertyBuilder->since($metadata->sinceVersion);
            }
            if ($metadata->untilVersion) {
                $propertyBuilder->until($metadata->untilVersion);
            }
            if ($metadata->getter) {
                $propertyBuilder->readWith($metadata->getter);
            }
            if ($metadata->setter) {
                $propertyBuilder->writeWith($metadata->setter);
            }
            if ($metadata->groups) {
                $propertyBuilder->groups($metadata->groups);
            }
            if ($metadata->type) {
                if (JMSPropertyMetadata::isCollectionList($metadata->type)) {

The method isCollectionList() does not exist on JMS\Serializer\Metadata\PropertyMetadata.

                    $propertyBuilder->type($metadata->type['params'][0]['name'])->collection();
                } elseif (JMSPropertyMetadata::isCollectionMap($metadata->type)) {

The method isCollectionMap() does not exist on JMS\Serializer\Metadata\PropertyMetadata.

                    $propertyBuilder->type($metadata->type['params'][1]['name'])->collection();
                } else {
                    $propertyBuilder->type($metadata->type['name']);
                }
            }
        }

        return $builder->build();
    }

    /**
     * Gets all the annotations from this class
     *
     * @param ReflectionClass $reflection
     *
     * @return JMSBaseClassMetadata|null
     */
    private function getJmsMetadata(ReflectionClass $reflection): ?JMSBaseClassMetadata
    {
        $metadata = null;

        do {
            $current = $this->driver->loadMetadataForClass($reflection);

            if ($metadata && $current) {
                $current->merge($metadata);

The method merge() does not exist on Metadata\ClassMetadata. It seems like you code against a sub-type of Metadata\ClassMetadata such as Metadata\MergeableClassMetadata.

            }

            $metadata = $current;
            $reflection = $reflection->getParentClass();
        } while ($reflection);

        return $metadata;
    }

    /**
     * Checks whether the property of this metadata is static.
     *
     * @param JMSPropertyMetadata $metadata
     *
     * @return bool
     */
    private function isPropertyStatic(JMSPropertyMetadata $metadata): bool
    {
        try {
            $reflection = new \ReflectionProperty($metadata->class, $metadata->name);

            return $reflection->isStatic();
        } catch (\ReflectionException $e) {

Consider adding a comment why this CATCH block is empty.

        }

        return false;
    }

    /**
     * Check whether the jms metadata has been loaded by default
     *
     * @param JMSBaseClassMetadata|null $jmsMetadata
     *
     * @return bool
     */
    private function isJmsMetadataEmpty(?JMSBaseClassMetadata $jmsMetadata): bool
    {
        if (!$jmsMetadata) {
            return true;
        }

        foreach ($jmsMetadata->propertyMetadata as $metadata) {
            $class = get_class($metadata);
            $default = new $class($metadata->class, $metadata->name);
            $attributes = (array)$metadata;

            unset($attributes['serializedName']);

            foreach ($attributes as $attribute => $value) {
                if ($default->$attribute !== $value) {
                    return false;
                }
            }
        }

        return true;
    }
}