Hydrator - Code Metrics - Inspection of "Merge pull request #12 from php-api-clients/improv..." - php-api-clients/hydrator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 932e75...60e699 )

by Cees-Jan

created 2016-11-11 16:18 UTC

Hydrator B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	318
Duplicated Lines	15.72 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

95%

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	9
dl	50
loc	318
ccs	114
cts	120
cp	0.95
rs	8.2608
c	0
b	0
f	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	3
A	setUpAnnotations()	0	10	3
B	preheat()	0	28	5
A	hydrate()	12	12	1
A	hydrateFQCN()	0	9	1
A	hydrateApplyAnnotations()	13	13	3
B	getEmptyOrResource()	0	24	4
A	extract()	12	12	1
A	extractFQCN()	0	10	2
A	extractApplyAnnotations()	13	13	3
A	getAnnotation()	0	14	3
B	recursivelyGetAnnotation()	0	27	6
A	buildAsyncFromSync()	0	10	1
A	getHydrator()	0	18	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Hydrator often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Hydrator, and based on these observations, apply Extract Interface, too.

<?php declare(strict_types=1);

namespace ApiClients\Foundation\Hydrator;

use ApiClients\Foundation\Hydrator\Annotations\EmptyResource;
use ApiClients\Foundation\Resource\EmptyResourceInterface;
use ApiClients\Tools\CommandBus\CommandBus;
use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Cache\Cache;
use GeneratedHydrator\Configuration;
use Interop\Container\ContainerInterface;
use ReflectionClass;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ApiClients\Foundation\Resource\ResourceInterface;
use Zend\Hydrator\HydratorInterface;

class Hydrator
{
    /**
     * @var ContainerInterface
     */
    protected $container;

    /**
     * @var array
     */
    protected $options;

    /**
     * @var array
     */
    protected $hydrators = [];

    /**
     * @var array
     */
    protected $annotations = [];

    /**
     * @var HandlerInterface[]
     */
    protected $annotationHandlers = [];

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

    /**
     * @param ContainerInterface $container
     * @param array $options
     */
    public function __construct(ContainerInterface $container, array $options)
    {
        $this->container = $container;
        $this->options = $options;

        $reader = new AnnotationReader();
        if (isset($this->options[Options::ANNOTATION_CACHE]) &&
            $this->options[Options::ANNOTATION_CACHE] instanceof Cache
        ) {
            $reader = new CachedReader(
                $reader,
                $this->options[Options::ANNOTATION_CACHE]
            );
        }
        $this->annotationReader = $reader;

        $this->setUpAnnotations();
    }

    protected function setUpAnnotations()
    {
        if (!isset($this->options[Options::ANNOTATIONS])) {
            return;
        }

        foreach ($this->options[Options::ANNOTATIONS] as $annotationClass => $handler) {
            $this->annotationHandlers[$annotationClass] = new $handler($this);
        }
    }

    public function preheat(string $scanTarget, string $namespace)
    {
        $directory = new RecursiveDirectoryIterator($scanTarget);
        $directory = new RecursiveIteratorIterator($directory);

        foreach ($directory as $node) {
            if (!is_file($node->getPathname())) {
                continue;
            }

            $file = substr($node->getPathname(), strlen($scanTarget));
            $file = ltrim($file, DIRECTORY_SEPARATOR);
            $file = rtrim($file, '.php');

            $class = $namespace . '\\' . str_replace(DIRECTORY_SEPARATOR, '\\', $file);

            if (!class_exists($class)) {
                continue;
            }

            if (!is_subclass_of($class, ResourceInterface::class)) {

                continue;
            }

            $this->getHydrator($class);
            $this->annotationReader->getClassAnnotations(new ReflectionClass($class));
        }
    }

    /**
     * @param string $class
     * @param array $json
     * @return ResourceInterface
     */
    public function hydrate(string $class, array $json): ResourceInterface

    {
        $fullClassName = implode(
            '\\',
            [
                $this->options[Options::NAMESPACE],
                $this->options[Options::NAMESPACE_SUFFIX],
                $class,
            ]
        );
        return $this->hydrateFQCN($fullClassName, $json);
    }

    /**
     * @param string $class
     * @param array $json
     * @return ResourceInterface
     */
    public function hydrateFQCN(string $class, array $json): ResourceInterface
    {
        $class = $this->getEmptyOrResource($class, $json);
        $hydrator = $this->getHydrator($class);
        $object = new $class($this->container->get(CommandBus::class));
        $json = $this->hydrateApplyAnnotations($json, $object);
        $resource = $hydrator->hydrate($json, $object);
        return $resource;
    }

    /**
     * @param array $json
     * @param ResourceInterface $object
     * @return array
     */
    protected function hydrateApplyAnnotations(array $json, ResourceInterface $object): array

    {
        foreach ($this->annotationHandlers as $annotationClass => $handler) {
            $annotation = $this->getAnnotation($object, $annotationClass);
            if ($annotation === null) {
                continue;
            }

            $json = $handler->hydrate($annotation, $json, $object);
        }

        return $json;
    }

    protected function getEmptyOrResource(string $class, array $json): string
    {
        if (count($json) > 0) {
            return $class;
        }

        $annotation = $this->getAnnotation(new $class($this->container->get(CommandBus::class)), EmptyResource::class);

        if (!($annotation instanceof EmptyResource)) {
            return $class;
        }

        $emptyClass = $this->options[Options::NAMESPACE] .
            '\\' .
            $this->options[Options::NAMESPACE_SUFFIX] .
            '\\' .
            $annotation->getEmptyReplacement();

        if (!class_exists($emptyClass)) {
            return $class;
        }

        return $emptyClass;
    }

    /**
     * @param string $class
     * @param ResourceInterface $object
     * @return array
     */
    public function extract(string $class, ResourceInterface $object): array

    {
        $fullClassName = implode(
            '\\',
            [
                $this->options[Options::NAMESPACE],
                $this->options[Options::NAMESPACE_SUFFIX],
                $class,
            ]
        );
        return $this->extractFQCN($fullClassName, $object);
    }

    /**
     * Takes a fully qualified class name and extracts the data for that class from the given $object
     * @param string $class
     * @param ResourceInterface $object
     * @return array
     */
    public function extractFQCN(string $class, ResourceInterface $object): array
    {
        if ($object instanceof EmptyResourceInterface) {
            return [];
        }

        $json = $this->getHydrator($class)->extract($object);
        $json = $this->extractApplyAnnotations($object, $json);
        return $json;
    }

    /**
     * @param array $json
     * @param ResourceInterface $object
     * @return array
     */
    protected function extractApplyAnnotations(ResourceInterface $object, array $json): array

    {
        foreach ($this->annotationHandlers as $annotationClass => $handler) {
            $annotation = $this->getAnnotation($object, $annotationClass);
            if ($annotation === null) {
                continue;
            }

            $json = $handler->extract($annotation, $object, $json);
        }

        return $json;
    }

    /**
     * @param ResourceInterface $object
     * @param string $annotationClass
     * @return null|AnnotationInterface
     */
    protected function getAnnotation(ResourceInterface $object, string $annotationClass)
    {
        $class = get_class($object);
        if (isset($this->annotations[$class][$annotationClass])) {
            return $this->annotations[$class][$annotationClass];
        }

        if (!isset($this->annotations[$class])) {
            $this->annotations[$class] = [];
        }

        $this->annotations[$class][$annotationClass] = $this->recursivelyGetAnnotation($class, $annotationClass);
        return $this->annotations[$class][$annotationClass];
    }

    /**
     * @param string $class
     * @param string $annotationClass
     * @return null|AnnotationInterface
     */
    protected function recursivelyGetAnnotation(string $class, string $annotationClass)
    {
        if (!class_exists($class)) {
            return null;
        }

        $annotation = $this->annotationReader
            ->getClassAnnotation(
                new ReflectionClass($class),
                $annotationClass
            )
        ;

        if ($annotation !== null &&
            get_class($annotation) === $annotationClass
        ) {
            return $annotation;
        }

        $parentClass = get_parent_class($class);

        if ($parentClass === false || !class_exists($parentClass)) {
            return null;
        }

        return $this->recursivelyGetAnnotation($parentClass, $annotationClass);
    }

    /**
     * @param string $resource
     * @param ResourceInterface $object
     * @return ResourceInterface
     */
    public function buildAsyncFromSync(string $resource, ResourceInterface $object): ResourceInterface
    {
        return $this->hydrateFQCN(
            $this->options[Options::NAMESPACE] . '\\Async\\' . $resource,
            $this->extractFQCN(
                $this->options[Options::NAMESPACE] . '\\Sync\\' . $resource,
                $object
            )
        );
    }

    /**
     * @param string $class
     * @return HydratorInterface
     */
    protected function getHydrator(string $class): HydratorInterface
    {
        if (isset($this->hydrators[$class])) {
            return $this->hydrators[$class];
        }

        $config = new Configuration($class);
        if (isset($this->options[Options::RESOURCE_CACHE_DIR])) {
            $config->setGeneratedClassesTargetDir($this->options[Options::RESOURCE_CACHE_DIR]);
        }
        if (isset($this->options[Options::RESOURCE_NAMESPACE])) {
            $config->setGeneratedClassesNamespace($this->options[Options::RESOURCE_NAMESPACE]);
        }
        $hydrator = $config->createFactory()->getHydratorClass();
        $this->hydrators[$class] = new $hydrator;

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


1			<?php declare(strict_types=1);
2
3			namespace ApiClients\Foundation\Hydrator;
4
5			use ApiClients\Foundation\Hydrator\Annotations\EmptyResource;
6			use ApiClients\Foundation\Resource\EmptyResourceInterface;
7			use ApiClients\Tools\CommandBus\CommandBus;
8			use Doctrine\Common\Annotations\AnnotationReader;
9			use Doctrine\Common\Annotations\CachedReader;
10			use Doctrine\Common\Annotations\Reader;
11			use Doctrine\Common\Cache\Cache;
12			use GeneratedHydrator\Configuration;
13			use Interop\Container\ContainerInterface;
14			use ReflectionClass;
15			use RecursiveDirectoryIterator;
16			use RecursiveIteratorIterator;
17			use ApiClients\Foundation\Resource\ResourceInterface;
18			use Zend\Hydrator\HydratorInterface;
19
20			class Hydrator
21			{
22			/**
23			* @var ContainerInterface
24			*/
25			protected $container;
26
27			/**
28			* @var array
29			*/
30			protected $options;
31
32			/**
33			* @var array
34			*/
35			protected $hydrators = [];
36
37			/**
38			* @var array
39			*/
40			protected $annotations = [];
41
42			/**
43			* @var HandlerInterface[]
44			*/
45			protected $annotationHandlers = [];
46
47			/**
48			* @var Reader
49			*/
50			protected $annotationReader;
51
52			/**
53			* @param ContainerInterface $container
54			* @param array $options
55			*/
56	8		public function __construct(ContainerInterface $container, array $options)
57			{
58	8		$this->container = $container;
59	8		$this->options = $options;
60
61	8		$reader = new AnnotationReader();
62	8		if (isset($this->options[Options::ANNOTATION_CACHE]) &&
63	8		$this->options[Options::ANNOTATION_CACHE] instanceof Cache
64			) {
65	1		$reader = new CachedReader(
66			$reader,
67	1		$this->options[Options::ANNOTATION_CACHE]
68			);
69			}
70	8		$this->annotationReader = $reader;
71
72	8		$this->setUpAnnotations();
73	8		}
74
75	8		protected function setUpAnnotations()
76			{
77	8		if (!isset($this->options[Options::ANNOTATIONS])) {
78			return;
79			}
80
81	8		foreach ($this->options[Options::ANNOTATIONS] as $annotationClass => $handler) {
82	8		$this->annotationHandlers[$annotationClass] = new $handler($this);
83			}
84	8		}
85
86	2		public function preheat(string $scanTarget, string $namespace)
87			{
88	2		$directory = new RecursiveDirectoryIterator($scanTarget);
89	2		$directory = new RecursiveIteratorIterator($directory);
90
91	2		foreach ($directory as $node) {
92	2		if (!is_file($node->getPathname())) {
93	2		continue;
94			}
95
96	2		$file = substr($node->getPathname(), strlen($scanTarget));
97	2		$file = ltrim($file, DIRECTORY_SEPARATOR);
98	2		$file = rtrim($file, '.php');
99
100	2		$class = $namespace . '\\' . str_replace(DIRECTORY_SEPARATOR, '\\', $file);
101
102	2		if (!class_exists($class)) {
103			continue;
104			}
105
106	2		if (!is_subclass_of($class, ResourceInterface::class)) {
			0 ignored issues – show Bug introduced 2016-09-07 16:29 UTC by Report Bug Copy Issue Report Due to PHP Bug #53727, `is_subclass_of` might return inconsistent results on some PHP versions if `\ApiClients\Foundation\R...esourceInterface::class` can be an interface. If so, you could instead use `ReflectionClass::implementsInterface`. Loading history...
107			continue;
108			}
109
110	2		$this->getHydrator($class);
111	2		$this->annotationReader->getClassAnnotations(new ReflectionClass($class));
112			}
113	2		}
114
115			/**
116			* @param string $class
117			* @param array $json
118			* @return ResourceInterface
119			*/
120	4	View Code Duplication	public function hydrate(string $class, array $json): ResourceInterface
			0 ignored issues – show Duplication introduced 2016-08-10 13:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
121			{
122	4		$fullClassName = implode(
123	4		'\\',
124			[
125			$this->options[Options::NAMESPACE],
126	4		$this->options[Options::NAMESPACE_SUFFIX],
127	4		$class,
128			]
129			);
130	4		return $this->hydrateFQCN($fullClassName, $json);
131			}
132
133			/**
134			* @param string $class
135			* @param array $json
136			* @return ResourceInterface
137			*/
138	4		public function hydrateFQCN(string $class, array $json): ResourceInterface
139			{
140	4		$class = $this->getEmptyOrResource($class, $json);
141	4		$hydrator = $this->getHydrator($class);
142	4		$object = new $class($this->container->get(CommandBus::class));
143	4		$json = $this->hydrateApplyAnnotations($json, $object);
144	4		$resource = $hydrator->hydrate($json, $object);
145	4		return $resource;
146			}
147
148			/**
149			* @param array $json
150			* @param ResourceInterface $object
151			* @return array
152			*/
153	4	View Code Duplication	protected function hydrateApplyAnnotations(array $json, ResourceInterface $object): array
			0 ignored issues – show Duplication introduced 2016-08-10 13:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
154			{
155	4		foreach ($this->annotationHandlers as $annotationClass => $handler) {
156	4		$annotation = $this->getAnnotation($object, $annotationClass);
157	4		if ($annotation === null) {
158	4		continue;
159			}
160
161	4		$json = $handler->hydrate($annotation, $json, $object);
162			}
163
164	4		return $json;
165			}
166
167	4		protected function getEmptyOrResource(string $class, array $json): string
168			{
169	4		if (count($json) > 0) {
170	4		return $class;
171			}
172
173	4		$annotation = $this->getAnnotation(new $class($this->container->get(CommandBus::class)), EmptyResource::class);
174
175	4		if (!($annotation instanceof EmptyResource)) {
176			return $class;
177			}
178
179			$emptyClass = $this->options[Options::NAMESPACE] .
180	4		'\\' .
181	4		$this->options[Options::NAMESPACE_SUFFIX] .
182	4		'\\' .
183			$annotation->getEmptyReplacement();
184
185	4		if (!class_exists($emptyClass)) {
186			return $class;
187			}
188
189	4		return $emptyClass;
190			}
191
192			/**
193			* @param string $class
194			* @param ResourceInterface $object
195			* @return array
196			*/
197	2	View Code Duplication	public function extract(string $class, ResourceInterface $object): array
			0 ignored issues – show Duplication introduced 2016-08-10 13:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
198			{
199	2		$fullClassName = implode(
200	2		'\\',
201			[
202			$this->options[Options::NAMESPACE],
203	2		$this->options[Options::NAMESPACE_SUFFIX],
204	2		$class,
205			]
206			);
207	2		return $this->extractFQCN($fullClassName, $object);
208			}
209
210			/**
211			* Takes a fully qualified class name and extracts the data for that class from the given $object
212			* @param string $class
213			* @param ResourceInterface $object
214			* @return array
215			*/
216	2		public function extractFQCN(string $class, ResourceInterface $object): array
217			{
218	2		if ($object instanceof EmptyResourceInterface) {
219	2		return [];
220			}
221
222	2		$json = $this->getHydrator($class)->extract($object);
223	2		$json = $this->extractApplyAnnotations($object, $json);
224	2		return $json;
225			}
226
227			/**
228			* @param array $json
229			* @param ResourceInterface $object
230			* @return array
231			*/
232	2	View Code Duplication	protected function extractApplyAnnotations(ResourceInterface $object, array $json): array
			0 ignored issues – show Duplication introduced 2016-08-10 13:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
233			{
234	2		foreach ($this->annotationHandlers as $annotationClass => $handler) {
235	2		$annotation = $this->getAnnotation($object, $annotationClass);
236	2		if ($annotation === null) {
237	2		continue;
238			}
239
240	2		$json = $handler->extract($annotation, $object, $json);
241			}
242
243	2		return $json;
244			}
245
246			/**
247			* @param ResourceInterface $object
248			* @param string $annotationClass
249			* @return null\|AnnotationInterface
250			*/
251	4		protected function getAnnotation(ResourceInterface $object, string $annotationClass)
252			{
253	4		$class = get_class($object);
254	4		if (isset($this->annotations[$class][$annotationClass])) {
255	3		return $this->annotations[$class][$annotationClass];
256			}
257
258	4		if (!isset($this->annotations[$class])) {
259	4		$this->annotations[$class] = [];
260			}
261
262	4		$this->annotations[$class][$annotationClass] = $this->recursivelyGetAnnotation($class, $annotationClass);
263	4		return $this->annotations[$class][$annotationClass];
264			}
265
266			/**
267			* @param string $class
268			* @param string $annotationClass
269			* @return null\|AnnotationInterface
270			*/
271	4		protected function recursivelyGetAnnotation(string $class, string $annotationClass)
272			{
273	4		if (!class_exists($class)) {
274			return null;
275			}
276
277	4		$annotation = $this->annotationReader
278	4		->getClassAnnotation(
279	4		new ReflectionClass($class),
280			$annotationClass
281			)
282			;
283
284	4		if ($annotation !== null &&
285	4		get_class($annotation) === $annotationClass
286			) {
287	4		return $annotation;
288			}
289
290	4		$parentClass = get_parent_class($class);
291
292	4		if ($parentClass === false \|\| !class_exists($parentClass)) {
293	4		return null;
294			}
295
296	4		return $this->recursivelyGetAnnotation($parentClass, $annotationClass);
297			}
298
299			/**
300			* @param string $resource
301			* @param ResourceInterface $object
302			* @return ResourceInterface
303			*/
304	1		public function buildAsyncFromSync(string $resource, ResourceInterface $object): ResourceInterface
305			{
306	1		return $this->hydrateFQCN(
307			$this->options[Options::NAMESPACE] . '\\Async\\' . $resource,
308	1		$this->extractFQCN(
309			$this->options[Options::NAMESPACE] . '\\Sync\\' . $resource,
310			$object
311			)
312			);
313			}
314
315			/**
316			* @param string $class
317			* @return HydratorInterface
318			*/
319	6		protected function getHydrator(string $class): HydratorInterface
320			{
321	6		if (isset($this->hydrators[$class])) {
322	4		return $this->hydrators[$class];
323			}
324
325	6		$config = new Configuration($class);
326	6		if (isset($this->options[Options::RESOURCE_CACHE_DIR])) {
327	6		$config->setGeneratedClassesTargetDir($this->options[Options::RESOURCE_CACHE_DIR]);
328			}
329	6		if (isset($this->options[Options::RESOURCE_NAMESPACE])) {
330	6		$config->setGeneratedClassesNamespace($this->options[Options::RESOURCE_NAMESPACE]);
331			}
332	6		$hydrator = $config->createFactory()->getHydratorClass();
333	6		$this->hydrators[$class] = new $hydrator;
334
335	6		return $this->hydrators[$class];
336			}
337			}
338

php-api-clients / hydrator

GitHub Access Token became invalid