Innmind\Reflection\InjectionStrategy\DelegationStrategy

Complexity

Total Complexity

10

Size/Duplication

Total Lines	80
Duplicated Lines	11.25 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.22%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	9	9	2
A	supports()	0	15	2
B	inject()	0	34	5
A	generateKey()	0	4	1

<?php
declare(strict_types = 1);

namespace Innmind\Reflection\InjectionStrategy;

use Innmind\Reflection\{
    InjectionStrategyInterface,
    Exception\InvalidArgumentException,
    Exception\PropertyCannotBeInjectedException
};
use Innmind\Immutable\{
    StreamInterface,
    Map
};

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

    /**
     * @param StreamInterface<InjectionStrategyInterface> $strategies

The doc-type StreamInterface<InjectionStrategyInterface> 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() !== InjectionStrategyInterface::class) {
            throw new InvalidArgumentException;
        }

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

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

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

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

        if ($this->cache->contains($key)) {

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

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

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

                ->inject($object, $property, $value);

            return;
        }

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

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

        if (!$strategy instanceof InjectionStrategyInterface) {
            throw new PropertyCannotBeInjectedException($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\InjectionStrategyInterface>, but the function expects a object<Innmind\Immutable\S>.

        $strategy->inject($object, $property, $value);
    }

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