Maiorano\ObjectHydrator\Hydrator

Complexity

Total Complexity

14

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	1	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	generateStrategies()	0	6	2
A	hydrate()	0	15	4
A	locateStrategy()	0	10	3
A	loadFromDefaults()	0	4	1
A	executeStrategy()	0	11	2
A	loadFromAttributes()	0	6	2

<?php

namespace Maiorano\ObjectHydrator;

use Generator;
use Maiorano\ObjectHydrator\Attributes\HydrationStrategy;
use Maiorano\ObjectHydrator\Strategies\HydrationStrategyInterface;
use Maiorano\ObjectHydrator\Strategies\Reflection\MethodsStrategy;
use Maiorano\ObjectHydrator\Strategies\Reflection\PropertiesStrategy;
use ReflectionAttribute;
use ReflectionClass;
use ReflectionException;
use stdClass;

final class Hydrator implements HydratorInterface
{
    /**
     * @param string|object $object
     * @param array         $input
     *
     * @throws ReflectionException
     *
     * @return object
     */
    public function hydrate(string|object $object, array $input): object
    {
        $reflect = new ReflectionClass($object);
        if (is_string($object)) {
            $object = $reflect->newInstanceWithoutConstructor();
        }

        $strategies = iterator_to_array($this->generateStrategies($reflect));
        foreach ($input as $key => $value) {
            if ($strategy = $this->locateStrategy($strategies, $object, $key)) {
                $this->executeStrategy($strategy, $object, $key, $value);
            }
        }

        return $object;
    }

    /**
     * @param ReflectionClass $reflect
     *
     * @return Generator
     */
    private function generateStrategies(ReflectionClass $reflect): Generator
    {
        $attributes = $reflect->getAttributes(HydrationStrategy::class);
        yield from $attributes
            ? $this->loadFromAttributes($attributes)
            : $this->loadFromDefaults();
    }

    /**
     * @param ReflectionAttribute[] $attributes
     *
     * @return Generator
     */
    private function loadFromAttributes(array $attributes): Generator
    {
        foreach ($attributes as $attribute) {
            $key = $attribute->newInstance();
            $name = $key->getStrategy();
            yield new $name(...$key->getArgs());
        }
    }

    /**
     * @return Generator
     */
    private function loadFromDefaults(): Generator
    {
        yield new PropertiesStrategy();
        yield new MethodsStrategy();
    }

    /**
     * @param HydrationStrategyInterface[] $strategies
     * @param object                       $object
     * @param string                       $key
     *
     * @return HydrationStrategyInterface|null
     */
    private function locateStrategy(array $strategies, object $object, string $key): ?HydrationStrategyInterface
    {
        foreach ($strategies as $strategy) {
            $strategy->initialize($object);
            if ($strategy->hasMatchingKey($key)) {
                return $strategy;
            }
        }

        return null;
    }

    /**
     * @param HydrationStrategyInterface $strategy
     * @param object                     $object
     * @param string                     $key
     * @param mixed                      $value
     *
     * @throws ReflectionException
     *
     * @return void
     */
    private function executeStrategy(HydrationStrategyInterface $strategy, object $object, string $key, mixed $value): void
    {
        $mapping = $strategy->getMapping($key);
        if (!$strategy->isRecursive($key, $value)) {
            $mapping->setValue($object, $value);

            return;
        }

        $type = $mapping->getType()?->getName() ?? stdClass::class;
        $mapping->setValue($object, $this->hydrate($type, $value));
    }
}