Hydrator - Code Metrics - Inspection of "Turn the hydrator API async" - php-api-clients/hydrator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#14)

by Cees-Jan

created 2016-11-24 22:07 UTC

Hydrator B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	348
Duplicated Lines	19.54 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

2.54%

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	12
dl	68
loc	348
ccs	3
cts	118
cp	0.0254
rs	8.2608
c	0
b	0
f	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	3
A	setUpAnnotations()	0	10	3
B	preheat()	0	28	5
A	hydrate()	12	12	1
A	hydrateFQCN()	0	11	1
A	hydrateApplyAnnotations()	22	22	3
B	getEmptyOrResource()	0	24	4
A	extract()	12	12	1
A	extractFQCN()	0	12	2
A	extractApplyAnnotations()	22	22	3
A	getAnnotation()	0	14	3
B	recursivelyGetAnnotation()	0	27	6
A	buildAsyncFromSync()	0	12	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 React\EventLoop\LoopInterface;
use React\Promise\CancellablePromiseInterface;
use ReflectionClass;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ApiClients\Foundation\Resource\ResourceInterface;
use Zend\Hydrator\HydratorInterface;
use function React\Promise\resolve;
use function WyriHaximus\React\futurePromise;

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

    /**
     * @var LoopInterface
     */
    protected $loop;

    /**
     * @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->loop = $this->container->get(LoopInterface::class);
        $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 CancellablePromiseInterface
     */
    public function hydrate(string $class, array $json): CancellablePromiseInterface

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

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

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

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

            $req = [
                'handler' => $handler,
                'annotation' => $annotation,
                'object' => $object,
            ];

            $promiseChain = $promiseChain->then(function (array $json) use ($req) {
                return $req['handler']->hydrate($req['annotation'], $json, $req['object']);
            });
        }

        return $promiseChain;
    }

    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 CancellablePromiseInterface
     */
    public function extract(string $class, ResourceInterface $object): CancellablePromiseInterface

    {
        $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 CancellablePromiseInterface
     */
    public function extractFQCN(string $class, ResourceInterface $object): CancellablePromiseInterface
    {
        if ($object instanceof EmptyResourceInterface) {
            return [];
        }

        return futurePromise($this->loop)->then(function () use ($class, $object) {
            return $this->getHydrator($class)->extract($object);
        })->then(function (array $json) use ($object) {
            return $this->extractApplyAnnotations($object, $json);
        });
    }

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

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

            $req = [
                'handler' => $handler,
                'annotation' => $annotation,
                'object' => $object,
            ];

            $promiseChain = $promiseChain->then(function (array $json) use ($req) {
                return $req['handler']->extract($req['annotation'], $req['object'], $json);
            });
        }

        return $promiseChain;
    }

    /**
     * @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->extractFQCN(
            $this->options[Options::NAMESPACE] . '\\Sync\\' . $resource,
            $object
        )->then(function ($json) use ($resource) {
            return $this->hydrateFQCN(
                $this->options[Options::NAMESPACE] . '\\Async\\' . $resource,
                $json
            );
        });
    }

    /**
     * @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 React\EventLoop\LoopInterface;
15			use React\Promise\CancellablePromiseInterface;
16			use ReflectionClass;
17			use RecursiveDirectoryIterator;
18			use RecursiveIteratorIterator;
19			use ApiClients\Foundation\Resource\ResourceInterface;
20			use Zend\Hydrator\HydratorInterface;
21			use function React\Promise\resolve;
22			use function WyriHaximus\React\futurePromise;
23
24			class Hydrator
25			{
26			/**
27			* @var ContainerInterface
28			*/
29			protected $container;
30
31			/**
32			* @var LoopInterface
33			*/
34			protected $loop;
35
36			/**
37			* @var array
38			*/
39			protected $options;
40
41			/**
42			* @var array
43			*/
44			protected $hydrators = [];
45
46			/**
47			* @var array
48			*/
49			protected $annotations = [];
50
51			/**
52			* @var HandlerInterface[]
53			*/
54			protected $annotationHandlers = [];
55
56			/**
57			* @var Reader
58			*/
59			protected $annotationReader;
60
61			/**
62			* @param ContainerInterface $container
63			* @param array $options
64			*/
65	7		public function __construct(ContainerInterface $container, array $options)
66			{
67	7		$this->container = $container;
68	7		$this->loop = $this->container->get(LoopInterface::class);
69			$this->options = $options;
70
71			$reader = new AnnotationReader();
72			if (isset($this->options[Options::ANNOTATION_CACHE]) &&
73			$this->options[Options::ANNOTATION_CACHE] instanceof Cache
74			) {
75			$reader = new CachedReader(
76			$reader,
77			$this->options[Options::ANNOTATION_CACHE]
78			);
79			}
80			$this->annotationReader = $reader;
81
82			$this->setUpAnnotations();
83			}
84
85			protected function setUpAnnotations()
86			{
87			if (!isset($this->options[Options::ANNOTATIONS])) {
88			return;
89			}
90
91			foreach ($this->options[Options::ANNOTATIONS] as $annotationClass => $handler) {
92			$this->annotationHandlers[$annotationClass] = new $handler($this);
93			}
94			}
95
96			public function preheat(string $scanTarget, string $namespace)
97			{
98			$directory = new RecursiveDirectoryIterator($scanTarget);
99			$directory = new RecursiveIteratorIterator($directory);
100
101			foreach ($directory as $node) {
102			if (!is_file($node->getPathname())) {
103			continue;
104			}
105
106			$file = substr($node->getPathname(), strlen($scanTarget));
107			$file = ltrim($file, DIRECTORY_SEPARATOR);
108			$file = rtrim($file, '.php');
109
110			$class = $namespace . '\\' . str_replace(DIRECTORY_SEPARATOR, '\\', $file);
111
112			if (!class_exists($class)) {
113			continue;
114			}
115
116			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...
117			continue;
118			}
119
120			$this->getHydrator($class);
121			$this->annotationReader->getClassAnnotations(new ReflectionClass($class));
122			}
123			}
124
125			/**
126			* @param string $class
127			* @param array $json
128			* @return CancellablePromiseInterface
129			*/
130		View Code Duplication	public function hydrate(string $class, array $json): CancellablePromiseInterface
			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...
131			{
132			$fullClassName = implode(
133			'\\',
134			[
135			$this->options[Options::NAMESPACE],
136			$this->options[Options::NAMESPACE_SUFFIX],
137			$class,
138			]
139			);
140			return $this->hydrateFQCN($fullClassName, $json);
141			}
142
143			/**
144			* @param string $class
145			* @param array $json
146			* @return CancellablePromiseInterface
147			*/
148			public function hydrateFQCN(string $class, array $json): CancellablePromiseInterface
149			{
150			$class = $this->getEmptyOrResource($class, $json);
151			$hydrator = $this->getHydrator($class);
152			$object = new $class($this->container->get(CommandBus::class));
153			return $this->hydrateApplyAnnotations($json, $object)->then(function ($json) {
154			return futurePromise($this->loop, $json);
155			})->then(function (array $json) use ($hydrator, $object) {
156			return $hydrator->hydrate($json, $object);
157			});
158			}
159
160			/**
161			* @param array $json
162			* @param ResourceInterface $object
163			* @return CancellablePromiseInterface
164			*/
165		View Code Duplication	protected function hydrateApplyAnnotations(array $json, ResourceInterface $object): CancellablePromiseInterface
			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...
166			{
167			$promiseChain = resolve($json);
168			foreach ($this->annotationHandlers as $annotationClass => $handler) {
169			$annotation = $this->getAnnotation($object, $annotationClass);
170			if ($annotation === null) {
171			continue;
172			}
173
174			$req = [
175			'handler' => $handler,
176			'annotation' => $annotation,
177			'object' => $object,
178			];
179
180			$promiseChain = $promiseChain->then(function (array $json) use ($req) {
181			return $req['handler']->hydrate($req['annotation'], $json, $req['object']);
182			});
183			}
184
185			return $promiseChain;
186			}
187
188			protected function getEmptyOrResource(string $class, array $json): string
189			{
190			if (count($json) > 0) {
191			return $class;
192			}
193
194			$annotation = $this->getAnnotation(new $class($this->container->get(CommandBus::class)), EmptyResource::class);
195
196			if (!($annotation instanceof EmptyResource)) {
197			return $class;
198			}
199
200			$emptyClass = $this->options[Options::NAMESPACE] .
201			'\\' .
202			$this->options[Options::NAMESPACE_SUFFIX] .
203			'\\' .
204			$annotation->getEmptyReplacement();
205
206			if (!class_exists($emptyClass)) {
207			return $class;
208			}
209
210			return $emptyClass;
211			}
212
213			/**
214			* @param string $class
215			* @param ResourceInterface $object
216			* @return CancellablePromiseInterface
217			*/
218		View Code Duplication	public function extract(string $class, ResourceInterface $object): CancellablePromiseInterface
			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...
219			{
220			$fullClassName = implode(
221			'\\',
222			[
223			$this->options[Options::NAMESPACE],
224			$this->options[Options::NAMESPACE_SUFFIX],
225			$class,
226			]
227			);
228			return $this->extractFQCN($fullClassName, $object);
229			}
230
231			/**
232			* Takes a fully qualified class name and extracts the data for that class from the given $object
233			* @param string $class
234			* @param ResourceInterface $object
235			* @return CancellablePromiseInterface
236			*/
237			public function extractFQCN(string $class, ResourceInterface $object): CancellablePromiseInterface
238			{
239			if ($object instanceof EmptyResourceInterface) {
240			return [];
241			}
242
243			return futurePromise($this->loop)->then(function () use ($class, $object) {
244			return $this->getHydrator($class)->extract($object);
245			})->then(function (array $json) use ($object) {
246			return $this->extractApplyAnnotations($object, $json);
247			});
248			}
249
250			/**
251			* @param array $json
252			* @param ResourceInterface $object
253			* @return CancellablePromiseInterface
254			*/
255		View Code Duplication	protected function extractApplyAnnotations(ResourceInterface $object, array $json): CancellablePromiseInterface
			0 ignored issues – show Duplication introduced 2016-11-24 22:11 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...
256			{
257			$promiseChain = resolve($json);
258			foreach ($this->annotationHandlers as $annotationClass => $handler) {
259			$annotation = $this->getAnnotation($object, $annotationClass);
260			if ($annotation === null) {
261			continue;
262			}
263
264			$req = [
265			'handler' => $handler,
266			'annotation' => $annotation,
267			'object' => $object,
268			];
269
270			$promiseChain = $promiseChain->then(function (array $json) use ($req) {
271			return $req['handler']->extract($req['annotation'], $req['object'], $json);
272			});
273			}
274
275			return $promiseChain;
276			}
277
278			/**
279			* @param ResourceInterface $object
280			* @param string $annotationClass
281			* @return null\|AnnotationInterface
282			*/
283			protected function getAnnotation(ResourceInterface $object, string $annotationClass)
284			{
285			$class = get_class($object);
286			if (isset($this->annotations[$class][$annotationClass])) {
287			return $this->annotations[$class][$annotationClass];
288			}
289
290			if (!isset($this->annotations[$class])) {
291			$this->annotations[$class] = [];
292			}
293
294			$this->annotations[$class][$annotationClass] = $this->recursivelyGetAnnotation($class, $annotationClass);
295			return $this->annotations[$class][$annotationClass];
296			}
297
298			/**
299			* @param string $class
300			* @param string $annotationClass
301			* @return null\|AnnotationInterface
302			*/
303			protected function recursivelyGetAnnotation(string $class, string $annotationClass)
304			{
305			if (!class_exists($class)) {
306			return null;
307			}
308
309			$annotation = $this->annotationReader
310			->getClassAnnotation(
311			new ReflectionClass($class),
312			$annotationClass
313			)
314			;
315
316			if ($annotation !== null &&
317			get_class($annotation) === $annotationClass
318			) {
319			return $annotation;
320			}
321
322			$parentClass = get_parent_class($class);
323
324			if ($parentClass === false \|\| !class_exists($parentClass)) {
325			return null;
326			}
327
328			return $this->recursivelyGetAnnotation($parentClass, $annotationClass);
329			}
330
331			/**
332			* @param string $resource
333			* @param ResourceInterface $object
334			* @return ResourceInterface
335			*/
336			public function buildAsyncFromSync(string $resource, ResourceInterface $object): ResourceInterface
337			{
338			return $this->extractFQCN(
339			$this->options[Options::NAMESPACE] . '\\Sync\\' . $resource,
340			$object
341			)->then(function ($json) use ($resource) {
342			return $this->hydrateFQCN(
343			$this->options[Options::NAMESPACE] . '\\Async\\' . $resource,
344			$json
345			);
346			});
347			}
348
349			/**
350			* @param string $class
351			* @return HydratorInterface
352			*/
353			protected function getHydrator(string $class): HydratorInterface
354			{
355			if (isset($this->hydrators[$class])) {
356			return $this->hydrators[$class];
357			}
358
359			$config = new Configuration($class);
360			if (isset($this->options[Options::RESOURCE_CACHE_DIR])) {
361			$config->setGeneratedClassesTargetDir($this->options[Options::RESOURCE_CACHE_DIR]);
362			}
363			if (isset($this->options[Options::RESOURCE_NAMESPACE])) {
364			$config->setGeneratedClassesNamespace($this->options[Options::RESOURCE_NAMESPACE]);
365			}
366			$hydrator = $config->createFactory()->getHydratorClass();
367			$this->hydrators[$class] = new $hydrator;
368
369			return $this->hydrators[$class];
370			}
371			}
372

php-api-clients / hydrator

GitHub Access Token became invalid