Innmind\Reflection\ReflectionObject

Complexity

Total Complexity

15

Size/Duplication

Total Lines	160
Duplicated Lines	22.5 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	21	21	4
A	withProperty()	0	9	1
A	withProperties()	15	15	2
A	properties()	0	4	1
A	injectionStrategy()	0	4	1
A	extractionStrategy()	0	4	1
A	build()	0	8	1
A	extract()	0	13	2
A	inject()	0	4	1
A	extractProperty()	0	4	1

<?php
declare(strict_types = 1);

namespace Innmind\Reflection;

use Innmind\Reflection\{
    InjectionStrategyInterface,

This use statement conflicts with another class in this namespace, Innmind\Reflection\InjectionStrategyInterface.

    ExtractionStrategyInterface,

This use statement conflicts with another class in this namespace, Innmind\Reflection\ExtractionStrategyInterface.

    ExtractionStrategy\ExtractionStrategies,
    InjectionStrategy\InjectionStrategies,
    Exception\InvalidArgumentException
};
use Innmind\Immutable\{
    MapInterface,
    Map
};

class ReflectionObject
{
    private $object;
    private $properties;
    private $injectionStrategy;
    private $extractionStrategy;

    public function __construct(

This method seems to be duplicated in your project.

        $object,
        MapInterface $properties = null,
        InjectionStrategyInterface $injectionStrategy = null,
        ExtractionStrategyInterface $extractionStrategy = null
    ) {
        $properties = $properties ?? new Map('string', 'mixed');

        if (
            !is_object($object) ||
            (string) $properties->keyType() !== 'string' ||
            (string) $properties->valueType() !== 'mixed'
        ) {
            throw new InvalidArgumentException;
        }

        $this->object = $object;
        $this->properties = $properties;
        $this->injectionStrategy = $injectionStrategy ?? InjectionStrategies::default();
        $this->extractionStrategy = $extractionStrategy ?? ExtractionStrategies::default();
    }

    /**
     * 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->put($name, $value),

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

            $this->injectionStrategy,
            $this->extractionStrategy
        );
    }

    /**
     * Add a set of properties that need to be injected
     *
     * @param array<string, mixed> $properties
     *
     * @return self
     */
    public function withProperties(array $properties): self

This method seems to be duplicated in your project.

    {
        $map = $this->properties;

        foreach ($properties as $key => $value) {
            $map = $map->put($key, $value);
        }

        return new self(
            $this->object,
            $map,
            $this->injectionStrategy,
            $this->extractionStrategy
        );
    }

    /**
     * Return the collection of properties that will be injected in the object
     *
     * @return MapInterface<string, mixed>

The doc-type MapInterface<string, could not be parsed: Expected "|" or "end of type", but got "<" at position 12. (view supported doc-types)

     */
    public function properties(): MapInterface
    {
        return $this->properties;
    }

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

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

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

        return $this->object;
    }

    /**
     * Extract the given list of properties
     *
     * @param string[] $properties
     *
     * @return MapInterface<string, mixed>

The doc-type MapInterface<string, could not be parsed: Expected "|" or "end of type", but got "<" at position 12. (view supported doc-types)

     */
    public function extract(array $properties): MapInterface
    {
        $map = new Map('string', 'mixed');

        foreach ($properties as $property) {
            $map = $map->put(
                $property,

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

                $this->extractProperty($property)
            );
        }

        return $map;
    }

    /**
     * Inject the given key/value pair into the object
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return void
     */
    private function inject(string $key, $value): void
    {
        $this->injectionStrategy->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->extractionStrategy->extract($this->object, $property);
    }
}