Stratadox\Hydrator\OneOfTheseHydrators

Complexity

Total Complexity

11

Size/Duplication

Total Lines	61
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	decideBasedOnThe()	0	3	1
A	hydrateAnInstanceUsing()	0	3	1
A	mustBeAString()	0	1	1
A	mustBeAHydrator()	0	1	1
A	hydratorBasedOn()	0	6	2
A	keyFromThe()	0	6	2
A	fromArray()	0	5	1
A	__construct()	0	7	2

<?php

declare(strict_types = 1);

namespace Stratadox\Hydrator;

/**
 * Delegates hydration, selecting a hydrator based on an input value.
 *
 * @package Stratadox\Hydrate
 * @author Stratadox
 */
final class OneOfTheseHydrators implements Hydrates
{
    private $decisionKey;
    private $hydratorMap;

    private function __construct(string $decisionKey, array $hydratorMap)
    {
        $this->decisionKey = $decisionKey;
        $this->hydratorMap = $hydratorMap;
        foreach ($hydratorMap as $key => $instance) {
            $this->mustBeAString($key);
            $this->mustBeAHydrator($instance);
        }
    }

    /**
     * Creates a new selective hydrator.
     *
     * @param string $key The key in which the decision key is stored.
     * @param array  $map Map of hydrators as [string $key => Hydrates $hydrator].
     * @return self       The delegating hydrator.
     */
    public static function decideBasedOnThe(string $key, array $map) : self
    {
        return new self($key, $map);
    }

    /** @inheritdoc */
    public function fromArray(array $input)
    {
        return $this->hydrateAnInstanceUsing(
            $this->hydratorBasedOn($this->keyFromThe($input)),
            $input
        );
    }

    private function hydrateAnInstanceUsing(Hydrates $hydrator, array $input)
    {
        return $hydrator->fromArray($input);
    }

    /** @throws CouldNotHydrate */
    private function hydratorBasedOn(string $key) : Hydrates
    {
        if (!isset($this->hydratorMap[$key])) {
            throw CannotDecideOnAHydrator::withThis($key);
        }
        return $this->hydratorMap[$key];
    }

    /** @throws CouldNotHydrate */
    private function keyFromThe(array $input) : string
    {
        if (!isset($input[$this->decisionKey])) {
            throw CannotDecideOnAHydrator::without($this->decisionKey);
        }
        return $input[$this->decisionKey];
    }

    private function mustBeAString(string $key) : void {}

The parameter $key is not used and could be removed.

    private function mustBeAHydrator(Hydrates $instance) : void {}

The parameter $instance is not used and could be removed.

}