MappingAnnotationDriver::__construct() - Code Metrics - addiks/symfony_rdm - Measure and Improve Code Quality continuously with Scrutinizer

MappingAnnotationDriver::__construct() A
last analyzed 2024-11-12 10:58 UTC

↳ Parent: MappingAnnotationDriver

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	6
ccs	3
cts	3
cp	1
crap	1
rs	10

<?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 <[email protected]>
 */

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;
use Webmozart\Assert\Assert;

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 */
        $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 */
        $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 = $annotation->nullable;
            }

            $dbalColumn = new DBALColumn(
                (string) $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 */
                $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
                );
            }

            /** @var class-string|null $objectMappingClassName */
            $objectMappingClassName = $annotation->{"class"};

            Assert::classExists($objectMappingClassName);

            $fieldMapping = new ObjectMapping(
                $objectMappingClassName,
                $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(
                (string) $annotation->name,
                Type::getType($annotation->type ?? 'string'),
                [
                    'notnull'   => !$annotation->nullable,
                    'length'    => $annotation->length,
                    'precision' => $annotation->precision ?? 0,
                    'scale'     => $annotation->scale,
                ]
            );

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

        return $fieldMapping;
    }

}


1		<?php
2		/**
3		* Copyright (C) 2018 Gerrit Addiks.
4		* This package (including this file) was released under the terms of the GPL-3.0.
5		* You should have received a copy of the GNU General Public License along with this program.
6		* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7		* @license GPL-3.0
8		* @author Gerrit Addiks <[email protected]>
9		*/
10
11		namespace Addiks\RDMBundle\Mapping\Drivers;
12
13		use Doctrine\Common\Annotations\Reader;
14		use ReflectionClass;
15		use ReflectionProperty;
16		use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface;
17		use Addiks\RDMBundle\Mapping\MappingInterface;
18		use Addiks\RDMBundle\Mapping\EntityMapping;
19		use Addiks\RDMBundle\Mapping\Annotation\Service;
20		use Addiks\RDMBundle\Mapping\ServiceMapping;
21		use Addiks\RDMBundle\Mapping\EntityMappingInterface;
22		use Addiks\RDMBundle\Mapping\Annotation\Choice;
23		use Addiks\RDMBundle\Mapping\ChoiceMapping;
24		use Addiks\RDMBundle\Exception\InvalidMappingException;
25		use Doctrine\ORM\Mapping\Column as ColumnAnnotation;
26		use Doctrine\DBAL\Schema\Column as DBALColumn;
27		use Doctrine\DBAL\Types\Type;
28		use Addiks\RDMBundle\Mapping\ObjectMapping;
29		use Addiks\RDMBundle\Mapping\CallDefinitionInterface;
30		use Addiks\RDMBundle\Mapping\FieldMapping;
31		use Addiks\RDMBundle\Mapping\ArrayMapping;
32		use Addiks\RDMBundle\Mapping\Annotation\RDMObject;
33		use Addiks\RDMBundle\Mapping\Annotation\RDMArray;
34		use Symfony\Component\DependencyInjection\ContainerInterface;
35		use Webmozart\Assert\Assert;
36
37		final class MappingAnnotationDriver implements MappingDriverInterface
38		{
39
40		/**
41		* @var ContainerInterface
42		*/
43		private $container;
44
45		/**
46		* @var Reader
47		*/
48		private $annotationReader;
49
50	8	public function __construct(
51		ContainerInterface $container,
52		Reader $annotationReader
53		) {
54	8	$this->container = $container;
55	8	$this->annotationReader = $annotationReader;
56		}
57
58	7	public function loadRDMMetadataForClass(string $className): ?EntityMappingInterface
59		{
60		/** @var ?EntityMappingInterface $mapping */
61	7	$mapping = null;
62
63		/** @var array<MappingInterface> $fieldMappings */
64	7	$fieldMappings = array();
65
66	7	$classReflection = new ReflectionClass($className);
67
68	7	foreach ($classReflection->getProperties() as $propertyReflection) {
69		/** @var ReflectionProperty $propertyReflection */
70
71		/** @var string $fieldName */
72	7	$fieldName = $propertyReflection->getName();
73
74		/** @var array<object> $annotations */
75	7	$annotations = $this->annotationReader->getPropertyAnnotations($propertyReflection);
76
77	7	foreach ($annotations as $annotation) {
78		/** @var object $annotation */
79
80	7	$fieldMapping = $this->convertAnnotationToMapping($annotation, $fieldName, $className);
81
82	7	if ($fieldMapping instanceof MappingInterface) {
83	7	$fieldMappings[$fieldName] = $fieldMapping;
84		}
85		}
86		}
87
88	7	if (!empty($fieldMappings)) {
89	7	$mapping = new EntityMapping($className, $fieldMappings);
90		}
91
92	7	return $mapping;
93		}
94
95		/**
96		* @param object $annotation
97		*/
98	7	private function convertAnnotationToMapping(
99		$annotation,
100		string $fieldName,
101		string $className,
102		bool $convertFieldsOnRootLevel = false
103		): ?MappingInterface {
104		/** @var ?MappingInterface $fieldMapping */
105	7	$fieldMapping = null;
106
107	7	if ($annotation instanceof Service) {
108	6	$fieldMapping = new ServiceMapping(
109	6	$this->container,
110	6	$annotation->id,
111	6	$annotation->lax,
112	6	sprintf(
113		"in entity '%s' on field '%s'",
114		$className,
115		$fieldName
116		)
117		);
118
119	7	} elseif ($annotation instanceof Choice) {
120		/** @var string\|null\|ColumnAnnotation $column */
121	5	$column = $annotation->column;
122
123	5	if (!$column instanceof ColumnAnnotation) {
124		/** @var string $columnName */
125	5	$columnName = $fieldName;
126
127	5	if (is_string($column)) {
128	5	$columnName = $column;
129		}
130
131	5	$column = new ColumnAnnotation();
132	5	$column->name = $columnName;
133	5	$column->type = 'string';
134	5	$column->length = 255;
135	5	$column->precision = 10;
136	5	$column->nullable = $annotation->nullable;
137		}
138
139	5	$dbalColumn = new DBALColumn(
140	5	(string) $column->name,
141	5	Type::getType($column->type),
142		[
143	5	'notnull' => !$column->nullable,
144	5	'length' => $column->length,
145	5	'precision' => $column->precision,
146	5	'scale' => $column->scale,
147		]
148		);
149
150		/** @var array<MappingInterface>*/
151	5	$choiceMappings = array();
152
153	5	foreach ($annotation->choices as $determinator => $choiceAnnotation) {
154		/** @var ?MappingInterface $choiceMapping */
155	4	$choiceMapping = $this->convertAnnotationToMapping(
156		$choiceAnnotation,
157		$fieldName,
158		$className
159		);
160
161	4	if ($choiceMapping instanceof MappingInterface) {
162	4	$choiceMappings[$determinator] = $choiceMapping;
163
164		} else {
165		throw new InvalidMappingException(sprintf(
166		"Invalid mapping on entity '%s' in field '%s' of choice-option '%s'!",
167		$className,
168		$fieldName,
169		$determinator
170		));
171		}
172		}
173
174	5	$fieldMapping = new ChoiceMapping(
175		$dbalColumn,
176		$choiceMappings,
177	5	sprintf(
178		"in entity '%s' on field '%s'",
179		$className,
180		$fieldName
181		)
182		);
183
184	7	} elseif ($annotation instanceof RDMObject) {
185		/** @var array<MappingInterface> $subFieldMappings */
186	2	$subFieldMappings = array();
187
188		/** @var null\|CallDefinitionInterface $factory */
189	2	$factory = null;
190
191		/** @var null\|CallDefinitionInterface $serializer */
192	2	$serializer = null;
193
194	2	foreach ($annotation->fields as $subFieldName => $subFieldAnnotation) {
195		/** @var object $fieldAnnotation */
196
197	2	$subFieldMappings[$subFieldName] = $this->convertAnnotationToMapping(
198		$subFieldAnnotation,
199	2	$fieldName . "->" . $subFieldName,
200		$className,
201		true
202		);
203		}
204
205		/** @var class-string\|null $objectMappingClassName */
206	2	$objectMappingClassName = $annotation->{"class"};
207
208	2	Assert::classExists($objectMappingClassName);
209
210	2	$fieldMapping = new ObjectMapping(
211		$objectMappingClassName,
212		$subFieldMappings,
213		null, # TODO: column
214	2	sprintf(
215		"in entity '%s' on field '%s'",
216		$className,
217		$fieldName
218		),
219		$factory,
220		$serializer
221		);
222
223	7	} elseif ($annotation instanceof RDMArray) {
224		/** @var array<MappingInterface> $entryMappings */
225	2	$entryMappings = array();
226
227	2	foreach ($annotation->entries as $key => $entryAnnotaton) {
228	2	$entryMappings[$key] = $this->convertAnnotationToMapping(
229		$entryAnnotaton,
230	2	$fieldName . "->" . $key,
231		$className,
232		true
233		);
234		}
235
236	2	$fieldMapping = new ArrayMapping(
237		$entryMappings,
238	2	sprintf(
239		"in entity '%s' on field '%s'",
240		$className,
241		$fieldName
242		)
243		);
244
245	7	} elseif ($annotation instanceof ColumnAnnotation && $convertFieldsOnRootLevel) {
246		/** @var DBALColumn $dbalColumn */
247	2	$dbalColumn = new DBALColumn(
248	2	(string) $annotation->name,
249	2	Type::getType($annotation->type ?? 'string'),
250		[
251	2	'notnull' => !$annotation->nullable,
252	2	'length' => $annotation->length,
253	2	'precision' => $annotation->precision ?? 0,
254	2	'scale' => $annotation->scale,
255		]
256		);
257
258	2	$fieldMapping = new FieldMapping(
259		$dbalColumn,
260	2	sprintf(
261		"in entity '%s' on field '%s'",
262		$className,
263		$fieldName
264		)
265		);
266		}
267
268	7	return $fieldMapping;
269		}
270
271		}
272

addiks / symfony_rdm

MappingAnnotationDriver::__construct() A last analyzed 2024-11-12 10:58 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

MappingAnnotationDriver::__construct() A
last analyzed 2024-11-12 10:58 UTC