Innmind\Reflection\ExtractionStrategy\DelegationStrategy

Complexity

Total Complexity

10

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Test Coverage

Coverage

97.14%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	extract()	0	31	5
A	supports()	0	12	2
A	__construct()	0	8	2
A	generateKey()	0	3	1

<?php
declare(strict_types = 1);

namespace Innmind\Reflection\ExtractionStrategy;

use Innmind\Reflection\{
    ExtractionStrategyInterface,
    Exception\InvalidArgumentException,
    Exception\PropertyCannotBeExtractedException
};
use Innmind\Immutable\{
    StreamInterface,
    Map
};

final class DelegationStrategy implements ExtractionStrategyInterface
{
    private $strategies;
    private $cache;

    /**
     * @param StreamInterface<ExtractionStrategyInterface> $strategies
     */
    public function __construct(StreamInterface $strategies)
    {
        if ((string) $strategies->type() !== ExtractionStrategyInterface::class) {
            throw new InvalidArgumentException;
        }

        $this->strategies = $strategies;
        $this->cache = new Map('string', ExtractionStrategyInterface::class);
    }

    /**
     * {@inheritdoc}
     */
    public function supports($object, string $property): bool
    {
        return $this
            ->strategies
            ->reduce(
                false,
                function(bool $supports, ExtractionStrategyInterface $strategy) use ($object, $property): bool {
                    if ($supports === true) {
                        return true;
                    }

                    return $strategy->supports($object, $property);
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function extract($object, string $property)
    {
        $key = $this->generateKey($object, $property);

        if ($this->cache->contains($key)) {
            return $this
                ->cache
                ->get($key)
                ->extract($object, $property);
        }

        $strategy = $this->strategies->reduce(
            null,
            function($target, ExtractionStrategyInterface $strategy) use ($object, $property) {
                if ($target instanceof ExtractionStrategyInterface) {
                    return $target;
                }

                if ($strategy->supports($object, $property)) {
                    return $strategy;
                }
            }
        );

        if (!$strategy instanceof ExtractionStrategyInterface) {
            throw new PropertyCannotBeExtractedException($property);
        }

        $this->cache = $this->cache->put($key, $strategy);

        return $strategy->extract($object, $property);
    }

    private function generateKey($object, string $property): string
    {
        return get_class($object).'::'.$property;
    }
}