Venta\Container\ObjectInflector

Complexity

Total Complexity

7

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	addInflection()	0	4	1
B	applyInflections()	0	33	5

<?php declare(strict_types = 1);

namespace Venta\Container;

use Venta\Contracts\Container\ArgumentResolver as ArgumentResolverContract;
use Venta\Contracts\Container\ObjectInflector as ObjectInflectorContract;

/**
 * Class ObjectInflector.
 *
 * @package Venta\Container
 */
final class ObjectInflector implements ObjectInflectorContract
{

    /**
     * @var ArgumentResolverContract
     */
    private $argumentResolver;

    /**
     * A list of methods with arguments which will be invoked on the subject object.
     *
     * @var string[][]
     */
    private $inflections = [];

    /**
     * ObjectInflector constructor.
     *
     * @param ArgumentResolverContract $argumentResolver
     */
    public function __construct(ArgumentResolverContract $argumentResolver)
    {
        $this->argumentResolver = $argumentResolver;
    }

    /**
     * @inheritDoc
     */
    public function addInflection(string $id, string $method, array $arguments = [])
    {
        $this->inflections[$id][$method] = $arguments;
    }

    /**
     * @inheritDoc
     */
    public function applyInflections($object)
    {
        foreach ($this->inflections as $type => $methods) {
            if (!$object instanceof $type) {
                continue;
            }

            foreach ($methods as $method => $inflection) {
                // $inflection may be array of arguments to pass to the method
                // OR prepared closure to call with the provided object context.
                if (!is_callable($inflection)) {

                    // Reflect and resolve method arguments.
                    $callback = $this->argumentResolver->resolveArguments(
                        $this->argumentResolver->reflectCallable([$type, $method])
                    );

                    // Replace method arguments with provided ones (if any).
                    $arguments = $callback($inflection);

                    // Wrap calling method with closure to avoid reflecting / resolving each time inflection applied.
                    $this->inflections[$type][$method] = $inflection = function () use ($method, $arguments) {
                        $this->$method(...$arguments);
                    };
                }

                // We have callable inflection ready, so we simply swap the context to provided object and call it.
                $inflection->call($object);
            }
        }

        return $object;
    }

}