Stratadox\Hydration\Hydrator\OneOfTheseHydrators

Complexity

Total Complexity

13

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

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

<?php

declare(strict_types = 1);

namespace Stratadox\Hydration\Hydrator;

use Stratadox\Hydration\Hydrates;
use Stratadox\Hydration\UnmappableInput;

/**
 * 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 $current;

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

    public static function decideBasedOnThe(string $key, array $map) : Hydrates
    {
        return new OneOfTheseHydrators($key, $map);
    }

    /**
     * @throws UnmappableInput
     * @inheritdoc
     */
    public function fromArray(array $input)
    {
        try {
            $this->current = $this->hydratorBasedOn($this->keyFromThe($input));
            return $this->hydrateAnInstanceUsing($this->current, $input);
        } finally {
            $this->current = null;
        }
    }

    public function currentInstance()
    {
        if (!$this->current instanceof Hydrates) {
            return null;
        }
        return $this->current->currentInstance();
    }

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

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

    /** @throws UnmappableInput */
    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.

}