Innmind / Reflection

src/ExtractionStrategy/DelegationStrategy.php

<?php
declare(strict_types = 1);

namespace Innmind\Reflection\ExtractionStrategy;

use Innmind\Reflection\{
    ExtractionStrategy,
    Exception\InvalidArgumentException,
    Exception\PropertyCannotBeExtracted,
};
use Innmind\Immutable\{
    Sequence,
    Map,
};

final class DelegationStrategy implements ExtractionStrategy
{
    /** @var Sequence<ExtractionStrategy> */
    private Sequence $strategies;
    /** @var Map<string, ExtractionStrategy> */
    private Map $cache;

    public function __construct(ExtractionStrategy ...$strategies)
    {
        /** @var Sequence<ExtractionStrategy> */
        $this->strategies = Sequence::of(ExtractionStrategy::class, ...$strategies);

The property strategies does not seem to exist on Innmind\Immutable\Sequence.

        /** @var Map<string, ExtractionStrategy> */
        $this->cache = Map::of('string', ExtractionStrategy::class);

The property cache does not seem to exist on Innmind\Immutable\Map.

    }

    /**
     * {@inheritdoc}
     */
    public function supports(object $object, string $property): bool
    {
        return $this

The expression return $this->strategies->reduce(false, function(...) { /* ... */ }) returns the type Innmind\Immutable\R which is incompatible with the type-hinted return boolean.

            ->strategies
            ->reduce(
                false,

false of type false is incompatible with the type Innmind\Immutable\R expected by parameter $carry of Innmind\Immutable\Sequence::reduce().

                static function(bool $supports, ExtractionStrategy $strategy) use ($object, $property): bool {
                    return $supports || $strategy->supports($object, $property);
                },
            );
    }

    /**
     * {@inheritdoc}
     */
    public function extract(object $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,
            static function(?ExtractionStrategy $target, ExtractionStrategy $strategy) use ($object, $property): ?ExtractionStrategy {
                return $target ?? ($strategy->supports($object, $property) ? $strategy : null);
            },
        );

        if (!$strategy instanceof ExtractionStrategy) {
            throw new PropertyCannotBeExtracted($property);
        }

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

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

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