Innmind\Reflection\ReflectionObject

Complexity

Total Complexity

13

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getProperties()	0	4	1
A	__construct()	0	17	2
A	withProperty()	0	9	1
A	withProperties()	0	9	1
A	getInjectionStrategies()	0	4	1
A	getExtractionStrategies()	0	4	1
A	buildObject()	0	8	2
A	extract()	0	10	2
A	inject()	0	7	1
A	extractProperty()	0	7	1

<?php
declare(strict_types = 1);

namespace Innmind\Reflection;

use Innmind\Immutable\Collection;
use Innmind\Immutable\CollectionInterface;
use Innmind\Reflection\Exception\InvalidArgumentException;
use Innmind\Reflection\ExtractionStrategy\DefaultExtractionStrategies;
use Innmind\Reflection\ExtractionStrategy\ExtractionStrategies;
use Innmind\Reflection\InjectionStrategy\DefaultInjectionStrategies;
use Innmind\Reflection\InjectionStrategy\InjectionStrategies;

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

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

        $this->injectionStrategies = $injectionStrategies ?? new DefaultInjectionStrategies();
        $this->extractionStrategies = $extractionStrategies ?? new DefaultExtractionStrategies();

        $this->object = $object;

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

    /**
     * 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,
            $this->extractionStrategies
        );
    }

    /**
     * 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,
            $this->extractionStrategies
        );
    }

    /**
     * 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 InjectionStrategies
     */
    public function getInjectionStrategies(): InjectionStrategies
    {
        return $this->injectionStrategies;
    }

    /**
     * Return the list of extraction strategies used
     *
     * @return ExtractionStrategies
     */
    public function getExtractionStrategies(): ExtractionStrategies
    {
        return $this->extractionStrategies;
    }

    /**
     * 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;
    }

    /**
     * Extract the given list of properties
     *
     * @param array $properties
     *
     * @return CollectionInterface
     */
    public function extract(array $properties): CollectionInterface
    {
        $values = [];

        foreach ($properties as $property) {
            $values[$property] = $this->extractProperty($property);
        }

        return new Collection($values);
    }

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

    /**
     * Extract the given property out of the object
     *
     * @param string $property
     *
     * @return mixed
     */
    private function extractProperty(string $property)
    {
        return $this
            ->extractionStrategies
            ->get($this->object, $property)
            ->extract($this->object, $property);
    }
}