Innmind\Reflection\ExtractionStrategy\DelegationStrategy

Complexity

Total Complexity

10

Size/Duplication

Total Lines	78
Duplicated Lines	11.54 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.06%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	9	9	2
A	supports()	0	15	2
B	extract()	0	32	5
A	generateKey()	0	4	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

The doc-type StreamInterface<ExtractionStrategyInterface> could not be parsed: Expected "|" or "end of type", but got "<" at position 15. (view supported doc-types)

     */
    public function __construct(StreamInterface $strategies)

This method seems to be duplicated in your project.

    {
        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)) {

$key is of type string, but the function expects a object<Innmind\Immutable\T>.

            return $this
                ->cache
                ->get($key)

$key is of type string, but the function expects a object<Innmind\Immutable\T>.

                ->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);

$key is of type string, but the function expects a object<Innmind\Immutable\T>.

$strategy is of type object<Innmind\Reflection\ExtractionStrategyInterface>, but the function expects a object<Innmind\Immutable\S>.

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

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