Addiks\RDMBundle\Mapping\Drivers\MappingAnnotationDriver

Complexity

Total Complexity

19

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

96.58%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
B	loadRDMMetadataForClass()	0	36	5
D	convertAnnotationToMapping()	0	167	13

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\RDMBundle\Mapping\Drivers;

use Doctrine\Common\Annotations\Reader;
use ReflectionClass;
use ReflectionProperty;
use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface;
use Addiks\RDMBundle\Mapping\MappingInterface;
use Addiks\RDMBundle\Mapping\EntityMapping;
use Addiks\RDMBundle\Mapping\Annotation\Service;
use Addiks\RDMBundle\Mapping\ServiceMapping;
use Addiks\RDMBundle\Mapping\EntityMappingInterface;
use Addiks\RDMBundle\Mapping\Annotation\Choice;
use Addiks\RDMBundle\Mapping\ChoiceMapping;
use Addiks\RDMBundle\Exception\InvalidMappingException;
use Doctrine\ORM\Mapping\Column as ColumnAnnotation;
use Doctrine\DBAL\Schema\Column as DBALColumn;
use Doctrine\DBAL\Types\Type;
use Addiks\RDMBundle\Mapping\ObjectMapping;
use Addiks\RDMBundle\Mapping\CallDefinitionInterface;
use Addiks\RDMBundle\Mapping\FieldMapping;
use Addiks\RDMBundle\Mapping\ArrayMapping;
use Addiks\RDMBundle\Mapping\Annotation\RDMObject;
use Addiks\RDMBundle\Mapping\Annotation\RDMArray;
use Symfony\Component\DependencyInjection\ContainerInterface;

final class MappingAnnotationDriver implements MappingDriverInterface
{

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var Reader
     */
    private $annotationReader;

    public function __construct(
        ContainerInterface $container,
        Reader $annotationReader
    ) {
        $this->container = $container;
        $this->annotationReader = $annotationReader;
    }

    public function loadRDMMetadataForClass(string $className): ?EntityMappingInterface
    {
        /** @var ?EntityMappingInterface $mapping */

The doc-type ?EntityMappingInterface could not be parsed: Unknown type name "?EntityMappingInterface" at position 0. (view supported doc-types)

        $mapping = null;

        /** @var array<MappingInterface> $fieldMappings */
        $fieldMappings = array();

        $classReflection = new ReflectionClass($className);

        foreach ($classReflection->getProperties() as $propertyReflection) {
            /** @var ReflectionProperty $propertyReflection */

            /** @var string $fieldName */
            $fieldName = $propertyReflection->getName();

            /** @var array<object> $annotations */
            $annotations = $this->annotationReader->getPropertyAnnotations($propertyReflection);

            foreach ($annotations as $annotation) {
                /** @var object $annotation */

                $fieldMapping = $this->convertAnnotationToMapping($annotation, $fieldName, $className);

                if ($fieldMapping instanceof MappingInterface) {
                    $fieldMappings[$fieldName] = $fieldMapping;
                }
            }
        }

        if (!empty($fieldMappings)) {
            $mapping = new EntityMapping($className, $fieldMappings);
        }

        return $mapping;
    }

    /**
     * @param object $annotation
     */
    private function convertAnnotationToMapping(
        $annotation,
        string $fieldName,
        string $className,
        bool $convertFieldsOnRootLevel = false
    ): ?MappingInterface {
        /** @var ?MappingInterface $fieldMapping */

The doc-type ?MappingInterface could not be parsed: Unknown type name "?MappingInterface" at position 0. (view supported doc-types)

        $fieldMapping = null;

        if ($annotation instanceof Service) {
            $fieldMapping = new ServiceMapping(
                $this->container,
                $annotation->id,
                $annotation->lax,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof Choice) {
            /** @var string|null|ColumnAnnotation $column */
            $column = $annotation->column;

            if (!$column instanceof ColumnAnnotation) {
                /** @var string $columnName */
                $columnName = $fieldName;

                if (is_string($column)) {
                    $columnName = $column;
                }

                $column = new ColumnAnnotation();
                $column->name = $columnName;
                $column->type = 'string';
                $column->length = 255;
                $column->precision = 10;
                $column->nullable = (bool)$annotation->nullable;
            }

            $dbalColumn = new DBALColumn(
                $column->name,
                Type::getType($column->type),
                [
                    'notnull'   => !$column->nullable,
                    'length'    => $column->length,
                    'precision' => $column->precision,
                    'scale'     => $column->scale,
                ]
            );

            /** @var array<MappingInterface>*/
            $choiceMappings = array();

            foreach ($annotation->choices as $determinator => $choiceAnnotation) {
                /** @var ?MappingInterface $choiceMapping */

The doc-type ?MappingInterface could not be parsed: Unknown type name "?MappingInterface" at position 0. (view supported doc-types)

                $choiceMapping = $this->convertAnnotationToMapping(
                    $choiceAnnotation,
                    $fieldName,
                    $className
                );

                if ($choiceMapping instanceof MappingInterface) {
                    $choiceMappings[$determinator] = $choiceMapping;

                } else {
                    throw new InvalidMappingException(sprintf(
                        "Invalid mapping on entity '%s' in field '%s' of choice-option '%s'!",
                        $className,
                        $fieldName,
                        $determinator
                    ));
                }
            }

            $fieldMapping = new ChoiceMapping(
                $dbalColumn,
                $choiceMappings,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof RDMObject) {
            /** @var array<MappingInterface> $subFieldMappings */
            $subFieldMappings = array();

            /** @var null|CallDefinitionInterface $factory */
            $factory = null;

            /** @var null|CallDefinitionInterface $serializer */
            $serializer = null;

            foreach ($annotation->fields as $subFieldName => $subFieldAnnotation) {
                /** @var object $fieldAnnotation */

                $subFieldMappings[$subFieldName] = $this->convertAnnotationToMapping(
                    $subFieldAnnotation,
                    $fieldName . "->" . $subFieldName,
                    $className,
                    true
                );
            }

            $fieldMapping = new ObjectMapping(
                $annotation->{"class"},
                $subFieldMappings,
                null, # TODO: column
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                ),
                $factory,
                $serializer
            );

        } elseif ($annotation instanceof RDMArray) {
            /** @var array<MappingInterface> $entryMappings */
            $entryMappings = array();

            foreach ($annotation->entries as $key => $entryAnnotaton) {
                $entryMappings[$key] = $this->convertAnnotationToMapping(
                    $entryAnnotaton,
                    $fieldName . "->" . $key,
                    $className,
                    true
                );
            }

            $fieldMapping = new ArrayMapping(
                $entryMappings,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );

        } elseif ($annotation instanceof ColumnAnnotation && $convertFieldsOnRootLevel) {
            /** @var DBALColumn $dbalColumn */
            $dbalColumn = new DBALColumn(
                $annotation->name,
                Type::getType($annotation->type),
                [
                    'notnull'   => !$annotation->nullable,
                    'length'    => $annotation->length,
                    'precision' => $annotation->precision,
                    'scale'     => $annotation->scale,
                ]
            );

            $fieldMapping = new FieldMapping(
                $dbalColumn,
                sprintf(
                    "in entity '%s' on field '%s'",
                    $className,
                    $fieldName
                )
            );
        }

        return $fieldMapping;
    }

}