Borobudur\DependencyInjection\Injector

Complexity

Total Complexity

30

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	3
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	resolveUnknownClass()	0	4	1
A	resolveParameters()	0	9	2
A	replaceArguments()	0	15	4
B	getParameterValue()	0	17	5
A	computeParameterValue()	0	15	3
B	computeParameterClass()	0	17	5
A	getNumericArguments()	0	10	3
A	getParameterName()	0	8	3
A	getParameterClass()	0	8	3

<?php
/*
 * This file is part of the Borobudur-DependencyInjection package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\DependencyInjection;

use Borobudur\DependencyInjection\ParameterBag\ParameterBagInterface;
use ReflectionParameter;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/9/15
 */
class Injector
{
    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var ParameterBagInterface
     */
    private $parameter;

    /**
     * @var bool
     */
    private $resolveUnknownClass = false;

    /**
     * Constructor.
     *
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
        $this->parameter = $container->getParameterBag();
    }

    /**
     * Set resolve unknown class.
     *
     * @param bool $resolve
     */
    public function resolveUnknownClass($resolve)
    {
        $this->resolveUnknownClass = (bool) $resolve;
    }

    /**
     * Resolve parameter arguments value.
     *
     * @param array $parameters
     *
     * @return array
     */
    public function resolveParameters(array $parameters)
    {
        $args = array();
        foreach ($parameters as $parameter) {
            $args[] = $this->computeParameterValue($parameter);
        }

        return $args;
    }

    /**
     * Replace parameters with arguments.
     *
     * @param array $serviceParameters
     * @param array $parameters
     * @param array $arguments
     *
     * @return array
     */
    public function replaceArguments(array $serviceParameters, array $parameters, array $arguments)
    {
        if (null !== $args = $this->getNumericArguments($parameters, $arguments)) {
            return $args;
        }

        foreach ($serviceParameters as $index => $parameter) {
            $name = $this->getParameterName($parameter);
            if (isset($arguments[$name])) {
                $parameters[$index] = $arguments[$name];
            }
        }

        return $parameters;
    }

    /**
     * Get parameter value.
     *
     * @param mixed $value
     *
     * @return array|mixed
     */
    public function getParameterValue($value)
    {
        $value = $this->parameter->getResolver()->resolveValue($this->parameter->getResolver()->unescapeValue($value));
        if (is_array($value)) {
            foreach ($value as $index => $val) {
                if (is_array($val)) {
                    $value[$index] = array_map(array($this, 'resolveParameters'), $val);
                } else {
                    $value[$index] = $this->getParameterValue($val);
                }
            }
        } elseif ($value instanceof Reference) {
            $value = $this->container->get((string) $value);
        }

        return $value;
    }

    /**
     * Compute parameter value.
     *
     * @param mixed $parameter
     *
     * @return array|mixed|null
     */
    protected function computeParameterValue($parameter)
    {
        $name = $this->getParameterName($parameter);
        if ($this->parameter->has($name)) {
            $value = $this->parameter->get($name);

            return $this->getParameterValue($value);
        }

        if (null !== $instance = $this->computeParameterClass($parameter)) {
            return $instance;
        }

        return null;
    }

    /**
     * Compute parameter with class value.
     *
     * @param mixed $parameter
     *
     * @return mixed|object|null
     */
    protected function computeParameterClass($parameter)
    {
        $class = $this->getParameterClass($parameter);

        if (null !== $class) {
            if ($this->container->has($class)) {
                return $this->container->get($class);
            }

            if (false !== $this->resolveUnknownClass
                && null !== $instance = $this->container->getDi()->createInstance($class)) {
                return $instance->getOriginalInstance();
            }
        }

        return null;
    }

    /**
     * Get numeric arguments.
     *
     * @param array $parameters
     * @param array $arguments
     *
     * @return array|null
     */
    private function getNumericArguments(array $parameters, array $arguments)
    {
        $keys = array_keys($arguments);

        if (count($keys) > 0 && is_int($keys[0])) {
            return array_replace($parameters, $arguments);
        }

        return null;
    }

    /**
     * Get parameter name.
     *
     * @param mixed $parameter
     *
     * @return mixed
     */
    private function getParameterName($parameter)
    {
        if (is_object($parameter) && method_exists($parameter, 'getName')) {
            return call_user_func(array($parameter, 'getName'));
        }

        return $parameter;
    }

    /**
     * Get parameter class.
     *
     * @param mixed $parameter
     *
     * @return mixed|null
     */
    private function getParameterClass($parameter)
    {
        if ($parameter instanceof ReflectionParameter && null !== $class = $parameter->getClass()) {
            return '\\' . ltrim($class->getName(), '\\');
        }

        return null;
    }
}