Innmind\Reflection\ReflectionObject

Complexity

Total Complexity

13

Size/Duplication

Total Lines	135
Duplicated Lines	12.59 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

97.62%

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	withProperty()	0	8	1
A	withProperties()	0	8	1
A	getProperties()	0	4	1
A	getInjectionStrategies()	0	4	1
A	buildObject()	0	8	2
A	inject()	0	15	3
A	initInjectionStrategies()	17	17	2

<?php
declare(strict_types = 1);

namespace Innmind\Reflection;

use Innmind\Reflection\Exception\InvalidArgumentException;
use Innmind\Reflection\Exception\LogicException;
use Innmind\Reflection\InjectionStrategy\SetterStrategy;
use Innmind\Reflection\InjectionStrategy\NamedMethodStrategy;
use Innmind\Reflection\InjectionStrategy\ReflectionStrategy;
use Innmind\Immutable\Collection;
use Innmind\Immutable\CollectionInterface;
use Innmind\Immutable\TypedCollection;
use Innmind\Immutable\TypedCollectionInterface;

class ReflectionObject
{
    private $object;
    private $properties;
    private $injectionStrategies;

    public function __construct(
        $object,
        CollectionInterface $properties = null,
        TypedCollectionInterface $injectionStrategies = null
    ) {
        if (!is_object($object)) {
            throw new InvalidArgumentException;
        }

        $this->object = $object;

        $this->properties = $properties ?? new Collection([]);
        $this->initInjectionStrategies($injectionStrategies);
    }

    /**
     * Add a property that will be injected
     *
     * @param string $name
     * @param mixed $value
     *
     * @return self
     */
    public function withProperty(string $name, $value)
    {
        return new self(
            $this->object,
            $this->properties->set($name, $value),
            $this->injectionStrategies
        );
    }

    /**
     * Add a set of properties that need to be injected
     *
     * @param array $properties
     *
     * @return self
     */
    public function withProperties(array $properties): self
    {
        return new self(
            $this->object,
            $this->properties->merge(new Collection($properties)),
            $this->injectionStrategies
        );
    }

    /**
     * Return the collection of properties that will be injected in the object
     *
     * @return CollectionInterface
     */
    public function getProperties(): CollectionInterface
    {
        return $this->properties;
    }

    /**
     * Return the list of injection strategies used
     *
     * @return TypedCollectionInterface
     */
    public function getInjectionStrategies(): TypedCollectionInterface
    {
        return $this->injectionStrategies;
    }

    /**
     * Return the object with the list of properties set on it
     *
     * @return object
     */
    public function buildObject()
    {
        foreach ($this->properties as $key => $value) {
            $this->inject($key, $value);
        }

        return $this->object;
    }

    /**
     * Inject the given key/value pair into the object
     *
     * @param string $key
     * @param mixed $value
     *
     * @return void
     */
    private function inject(string $key, $value)
    {
        foreach ($this->injectionStrategies as $strategy) {
            if ($strategy->supports($this->object, $key, $value)) {
                $strategy->inject($this->object, $key, $value);

                return;
            }
        }

        throw new LogicException(sprintf(
            'Property "%s" cannot be injected',
            $key
        ));
    }

    /**
     * @param TypedCollectionInterface $strategies
     *
     * @return void
     */
    private function initInjectionStrategies(TypedCollectionInterface $strategies = null)

This method seems to be duplicated in your project.

    {
        $strategies = $strategies ?? new TypedCollection(
            InjectionStrategyInterface::class,
            [
                new SetterStrategy,
                new NamedMethodStrategy,
                new ReflectionStrategy,
            ]
        );

        if ($strategies->getType() !== InjectionStrategyInterface::class) {
            throw new InvalidArgumentException;
        }

        $this->injectionStrategies = $strategies;
    }
}