AnnotationDefinitionProvider::createDefinition() - Code Metrics - Inspection of "Parent class processing added to AnnotationDefinit..." - mikemirten/JsonApi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7c7fa2...d7cd6a )

by Michael

created 2017-04-26 20:57 UTC

AnnotationDefinitionProvider::createDefinition() A

↳ Parent: AnnotationDefinitionProvider

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	8
cts	8
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	1
crap	2

<?php
declare(strict_types = 1);

namespace Mikemirten\Component\JsonApi\Mapper\Definition;

use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\Reader;
use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\ResourceIdentifier as ResourceIdentifierAnnotation;
use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\Relationship as RelationshipAnnotation;
use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\Link as LinkAnnotation;

/**
 * Annotation Definition Provider based on the Doctrine-Annotation library
 *
 * @package Mikemirten\Component\JsonApi\Mapper\Definition
 */
class AnnotationDefinitionProvider implements DefinitionProviderInterface
{
    /**
     * Pattern of "resource" parameter
     */
    const RESOURCE_PATTERN = '~^(?<repository>[a-z_][a-z0-9_]*)\.(?<link>[a-z_][a-z0-9_]*)$~i';

    /**
     * Annotation classes ha been registered.
     *
     * @var bool
     */
    static private $annotationsRegistered = false;

    /**
     * Cache of created definitions
     *
     * @var array
     */
    private $definitionCache = [];

    /**
     * Register annotation classes.
     * Supports a medieval-aged way of "autoloading" for the Doctrine Annotation library.
     */
    static protected function registerAnnotations()

    {
        if (self::$annotationsRegistered === false) {
            AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Relationship.php');
            AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Link.php');

            self::$annotationsRegistered = true;
        }
    }

    /**
     * Doctrine annotation reader
     *
     * @var Reader
     */
    protected $reader;

    /**
     * AnnotationDefinitionProvider constructor.
     *
     * @param Reader $reader
     */
    public function __construct(Reader $reader)
    {
        self::registerAnnotations();

        $this->reader = $reader;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefinition(string $class): Definition
    {
        if (! isset($this->definitionCache[$class])) {
            $reflection = new \ReflectionClass($class);

            $this->definitionCache[$class] = $this->createDefinition($reflection);
        }

        return $this->definitionCache[$class];
    }

    /**
     * Create definition for given class
     *
     * @param  \ReflectionClass $reflection
     * @return Definition
     */
    protected function createDefinition(\ReflectionClass $reflection): Definition
    {
        $definition = new Definition($reflection->getName());


        $this->processProperties($reflection, $definition);
        $this->processClassAnnotations($reflection, $definition);

        $parent = $reflection->getParentClass();

        if ($parent !== false) {
            $definition->merge($this->createDefinition($parent));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $definition;
    }

    /**
     * Process properties of class
     *
     * @param \ReflectionClass $reflection
     * @param Definition       $definition
     */
    protected function processProperties(\ReflectionClass $reflection, Definition $definition)
    {
        foreach ($reflection->getProperties() as $property)
        {
            $relationshipAnnotation = $this->reader->getPropertyAnnotation(
                $property,
                RelationshipAnnotation::class
            );

            if ($relationshipAnnotation !== null) {
                $relationship = $this->createRelationship($relationshipAnnotation, $property);

                $definition->addRelationship($relationship);
            }
        }
    }

    /**
     * Process annotations of class
     *
     * @param \ReflectionClass $reflection
     * @param Definition       $definition
     */
    protected function processClassAnnotations(\ReflectionClass $reflection, Definition $definition)
    {
        $annotations = $this->reader->getClassAnnotations($reflection);

        foreach ($annotations as $annotation)
        {
            if ($annotation instanceof LinkAnnotation) {
                $link = $this->createLink($annotation);

                $definition->addLink($link);
                continue;
            }

            if ($annotation instanceof ResourceIdentifierAnnotation) {
                $this->handlerResourceIdentifier($annotation, $definition);
            }
        }
    }

    /**
     * Handler resource identifier
     *
     * @param ResourceIdentifierAnnotation $annotation
     * @param Definition                   $definition
     */
    protected function handlerResourceIdentifier(ResourceIdentifierAnnotation $annotation, Definition $definition)
    {
        if ($annotation->type !== null) {
            $definition->setType($annotation->type);
        }
    }

    /**
     * Process relationship
     *
     * @param  RelationshipAnnotation $annotation
     * @param  \ReflectionProperty    $property
     * @return Relationship
     */
    protected function createRelationship(RelationshipAnnotation $annotation, \ReflectionProperty $property): Relationship
    {
        $name = ($annotation->name === null)
            ? $property->getName()
            : $annotation->name;

        $type = $this->resolveType($annotation);

        $relationship = new Relationship($name, $type);
        $relationship->setPropertyName($property->getName());

        $this->handleGetter($annotation, $relationship);
        $this->handleLinks($annotation, $relationship);
        $this->handleDataControl($annotation, $relationship);

        return $relationship;
    }

    /**
     * Handler getter of related object
     *
     * @param RelationshipAnnotation $annotation
     * @param Relationship           $relationship
     */
    protected function handleGetter(RelationshipAnnotation $annotation, Relationship $relationship)
    {
        if ($annotation->getter === null) {
            $name   = $relationship->getPropertyName();
            $getter = 'get' . ucfirst($name);

            $relationship->setGetter($getter);
            return;
        }

        $relationship->setGetter($annotation->getter);
    }

    /**
     * Handle links
     *
     * @param RelationshipAnnotation $annotation
     * @param Relationship           $relationship
     */
    protected function handleLinks(RelationshipAnnotation $annotation, Relationship $relationship)
    {
        foreach ($annotation->links as $linkAnnotation)
        {
            $link = $this->createLink($linkAnnotation);

            $relationship->addLink($link);
        }
    }

    /**
     * Create link by link's annotation
     *
     * @param  LinkAnnotation $annotation
     * @return Link
     */
    protected function createLink(LinkAnnotation $annotation): Link
    {
        if (! preg_match(self::RESOURCE_PATTERN, $annotation->resource, $matches)) {
            throw new \LogicException(sprintf('Invalid resource definition: "%s"', $annotation->resource));
        }

        $link = new Link(
            $annotation->name,
            $matches['repository'],
            $matches['link']
        );

        $link->setParameters($annotation->parameters);
        $link->setMetadata($annotation->metadata);

        return $link;
    }

    /**
     * Handle control of data-section
     *
     * @param RelationshipAnnotation $annotation
     * @param Relationship           $relationship
     */
    protected function handleDataControl(RelationshipAnnotation $annotation, Relationship $relationship)
    {
        $relationship->setIncludeData($annotation->dataAllowed);
        $relationship->setDataLimit($annotation->dataLimit);
    }

    /**
     * Resolve type of relationship
     *
     * @param  RelationshipAnnotation $annotation
     * @return int
     */
    protected function resolveType(RelationshipAnnotation $annotation): int
    {
        if ($annotation->type === RelationshipAnnotation::TYPE_ONE) {
            return Relationship::TYPE_X_TO_ONE;
        }

        if ($annotation->type === RelationshipAnnotation::TYPE_MANY) {
            return Relationship::TYPE_X_TO_MANY;
        }

        throw new \LogicException(sprintf('Invalid type of relation "%s" defined.', $annotation->type));
    }
}

1		<?php
2		declare(strict_types = 1);
3
4		namespace Mikemirten\Component\JsonApi\Mapper\Definition;
5
6		use Doctrine\Common\Annotations\AnnotationRegistry;
7		use Doctrine\Common\Annotations\Reader;
8		use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\ResourceIdentifier as ResourceIdentifierAnnotation;
9		use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\Relationship as RelationshipAnnotation;
10		use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\Link as LinkAnnotation;
11
12		/**
13		* Annotation Definition Provider based on the Doctrine-Annotation library
14		*
15		* @package Mikemirten\Component\JsonApi\Mapper\Definition
16		*/
17		class AnnotationDefinitionProvider implements DefinitionProviderInterface
18		{
19		/**
20		* Pattern of "resource" parameter
21		*/
22		const RESOURCE_PATTERN = '~^(?<repository>[a-z_][a-z0-9_])\.(?<link>[a-z_][a-z0-9_])$~i';
23
24		/**
25		* Annotation classes ha been registered.
26		*
27		* @var bool
28		*/
29		static private $annotationsRegistered = false;
30
31		/**
32		* Cache of created definitions
33		*
34		* @var array
35		*/
36		private $definitionCache = [];
37
38		/**
39		* Register annotation classes.
40		* Supports a medieval-aged way of "autoloading" for the Doctrine Annotation library.
41		*/
42	13	static protected function registerAnnotations()
		0 ignored issues – show Coding Style introduced 2017-04-05 22:46 UTC by Report Bug Copy Issue Report As per PSR2, the `static` declaration should come after the visibility declaration. Loading history...
43		{
44	13	if (self::$annotationsRegistered === false) {
45	1	AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Relationship.php');
46	1	AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Link.php');
47
48	1	self::$annotationsRegistered = true;
49		}
50	13	}
51
52		/**
53		* Doctrine annotation reader
54		*
55		* @var Reader
56		*/
57		protected $reader;
58
59		/**
60		* AnnotationDefinitionProvider constructor.
61		*
62		* @param Reader $reader
63		*/
64	13	public function __construct(Reader $reader)
65		{
66	13	self::registerAnnotations();
67
68	13	$this->reader = $reader;
69	13	}
70
71		/**
72		* {@inheritdoc}
73		*/
74	13	public function getDefinition(string $class): Definition
75		{
76	13	if (! isset($this->definitionCache[$class])) {
77	13	$reflection = new \ReflectionClass($class);
78
79	13	$this->definitionCache[$class] = $this->createDefinition($reflection);
80		}
81
82	13	return $this->definitionCache[$class];
83		}
84
85		/**
86		* Create definition for given class
87		*
88		* @param \ReflectionClass $reflection
89		* @return Definition
90		*/
91	13	protected function createDefinition(\ReflectionClass $reflection): Definition
92		{
93	13	$definition = new Definition($reflection->getName());
		0 ignored issues – show Bug introduced 2017-04-26 21:01 UTC by Report Bug Copy Issue Report Consider using `$reflection->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
94
95	13	$this->processProperties($reflection, $definition);
96	13	$this->processClassAnnotations($reflection, $definition);
97
98	13	$parent = $reflection->getParentClass();
99
100	13	if ($parent !== false) {
101	1	$definition->merge($this->createDefinition($parent));
		0 ignored issues – show Documentation introduced 2017-04-26 21:01 UTC by Report Bug Copy Issue Report `$this->createDefinition($parent)` is of type `object<Mikemirten\Compon...\Definition\Definition>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
102		}
103
104	13	return $definition;
105		}
106
107		/**
108		* Process properties of class
109		*
110		* @param \ReflectionClass $reflection
111		* @param Definition $definition
112		*/
113	13	protected function processProperties(\ReflectionClass $reflection, Definition $definition)
114		{
115	13	foreach ($reflection->getProperties() as $property)
116		{
117	13	$relationshipAnnotation = $this->reader->getPropertyAnnotation(
118		$property,
119	13	RelationshipAnnotation::class
120		);
121
122	13	if ($relationshipAnnotation !== null) {
123	9	$relationship = $this->createRelationship($relationshipAnnotation, $property);
124
125	13	$definition->addRelationship($relationship);
126		}
127		}
128	13	}
129
130		/**
131		* Process annotations of class
132		*
133		* @param \ReflectionClass $reflection
134		* @param Definition $definition
135		*/
136	13	protected function processClassAnnotations(\ReflectionClass $reflection, Definition $definition)
137		{
138	13	$annotations = $this->reader->getClassAnnotations($reflection);
139
140	13	foreach ($annotations as $annotation)
141		{
142	8	if ($annotation instanceof LinkAnnotation) {
143	7	$link = $this->createLink($annotation);
144
145	7	$definition->addLink($link);
146	7	continue;
147		}
148
149	7	if ($annotation instanceof ResourceIdentifierAnnotation) {
150	7	$this->handlerResourceIdentifier($annotation, $definition);
151		}
152		}
153	13	}
154
155		/**
156		* Handler resource identifier
157		*
158		* @param ResourceIdentifierAnnotation $annotation
159		* @param Definition $definition
160		*/
161	7	protected function handlerResourceIdentifier(ResourceIdentifierAnnotation $annotation, Definition $definition)
162		{
163	7	if ($annotation->type !== null) {
164	7	$definition->setType($annotation->type);
165		}
166	7	}
167
168		/**
169		* Process relationship
170		*
171		* @param RelationshipAnnotation $annotation
172		* @param \ReflectionProperty $property
173		* @return Relationship
174		*/
175	9	protected function createRelationship(RelationshipAnnotation $annotation, \ReflectionProperty $property): Relationship
176		{
177	9	$name = ($annotation->name === null)
178	6	? $property->getName()
179	9	: $annotation->name;
180
181	9	$type = $this->resolveType($annotation);
182
183	9	$relationship = new Relationship($name, $type);
184	9	$relationship->setPropertyName($property->getName());
185
186	9	$this->handleGetter($annotation, $relationship);
187	9	$this->handleLinks($annotation, $relationship);
188	9	$this->handleDataControl($annotation, $relationship);
189
190	9	return $relationship;
191		}
192
193		/**
194		* Handler getter of related object
195		*
196		* @param RelationshipAnnotation $annotation
197		* @param Relationship $relationship
198		*/
199	9	protected function handleGetter(RelationshipAnnotation $annotation, Relationship $relationship)
200		{
201	9	if ($annotation->getter === null) {
202	8	$name = $relationship->getPropertyName();
203	8	$getter = 'get' . ucfirst($name);
204
205	8	$relationship->setGetter($getter);
206	8	return;
207		}
208
209	1	$relationship->setGetter($annotation->getter);
210	1	}
211
212		/**
213		* Handle links
214		*
215		* @param RelationshipAnnotation $annotation
216		* @param Relationship $relationship
217		*/
218	9	protected function handleLinks(RelationshipAnnotation $annotation, Relationship $relationship)
219		{
220	9	foreach ($annotation->links as $linkAnnotation)
221		{
222	7	$link = $this->createLink($linkAnnotation);
223
224	7	$relationship->addLink($link);
225		}
226	9	}
227
228		/**
229		* Create link by link's annotation
230		*
231		* @param LinkAnnotation $annotation
232		* @return Link
233		*/
234	8	protected function createLink(LinkAnnotation $annotation): Link
235		{
236	8	if (! preg_match(self::RESOURCE_PATTERN, $annotation->resource, $matches)) {
237		throw new \LogicException(sprintf('Invalid resource definition: "%s"', $annotation->resource));
238		}
239
240	8	$link = new Link(
241	8	$annotation->name,
242	8	$matches['repository'],
243	8	$matches['link']
244		);
245
246	8	$link->setParameters($annotation->parameters);
247	8	$link->setMetadata($annotation->metadata);
248
249	8	return $link;
250		}
251
252		/**
253		* Handle control of data-section
254		*
255		* @param RelationshipAnnotation $annotation
256		* @param Relationship $relationship
257		*/
258	9	protected function handleDataControl(RelationshipAnnotation $annotation, Relationship $relationship)
259		{
260	9	$relationship->setIncludeData($annotation->dataAllowed);
261	9	$relationship->setDataLimit($annotation->dataLimit);
262	9	}
263
264		/**
265		* Resolve type of relationship
266		*
267		* @param RelationshipAnnotation $annotation
268		* @return int
269		*/
270	9	protected function resolveType(RelationshipAnnotation $annotation): int
271		{
272	9	if ($annotation->type === RelationshipAnnotation::TYPE_ONE) {
273	2	return Relationship::TYPE_X_TO_ONE;
274		}
275
276	7	if ($annotation->type === RelationshipAnnotation::TYPE_MANY) {
277	7	return Relationship::TYPE_X_TO_MANY;
278		}
279
280		throw new \LogicException(sprintf('Invalid type of relation "%s" defined.', $annotation->type));
281		}
282		}

mikemirten / JsonApi

Push — master ( 7c7fa2...d7cd6a )

AnnotationDefinitionProvider::createDefinition() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like