Ray\Di\AssistedInterceptor

Complexity

Total Complexity

10

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

96.97%

Importance

Changes	5
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	invoke()	0	15	2
A	getName()	0	14	3
A	injectAssistedParameters()	0	14	4

<?php
/**
 * This file is part of the Ray.Di package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace Ray\Di;

use Ray\Aop\MethodInterceptor;
use Ray\Aop\MethodInvocation;
use Ray\Aop\ReflectionMethod;
use Ray\Di\Di\Assisted;

final class AssistedInterceptor implements MethodInterceptor
{
    /**
     * @var InjectorInterface
     */
    private $injector;

    public function __construct(InjectorInterface $injector)
    {
        $this->injector = $injector;
    }

    /**
     * Intercepts any method and injects instances of the missing arguments
     * when they are type hinted
     */
    public function invoke(MethodInvocation $invocation)
    {
        $method = $invocation->getMethod();
        $assisted = $method->getAnnotation('Ray\Di\Di\Assisted');
        /* @var \Ray\Di\Di\Assisted $assisted */
        $parameters = $method->getParameters();
        $arguments = $invocation->getArguments()->getArrayCopy();
        $cntArgs = count($arguments);
        if ($assisted instanceof Assisted) {
            $arguments = $this->injectAssistedParameters($method, $assisted, $parameters, $arguments, $cntArgs);
        }
        $invocation->getArguments()->exchangeArray($arguments);

        return $invocation->proceed();
    }

    private function getName(ReflectionMethod $method, \ReflectionParameter $parameter)
    {
        $named = $method->getAnnotation('Ray\Di\Di\Named');
        if (! $named) {
            return Name::ANY;
        }
        parse_str($named->value, $names);
        $paramName = $parameter->getName();
        if (isset($names[$paramName])) {
            return $names[$paramName];
        }

        return Name::ANY;
    }

    /**
     * @param \ReflectionMethod      $method
     * @param Assisted               $assisted
     * @param \ReflectionParameter[] $parameters
     * @param array                  $arguments
     * @param int                    $cntArgs
     *
     * @return array
     */
    public function injectAssistedParameters(\ReflectionMethod $method, Assisted $assisted, array $parameters, array $arguments, $cntArgs)

The parameter $cntArgs is not used and could be removed.

The method parameter $cntArgs is never used

    {
        foreach ($parameters as $pos => $parameter) {
            if (! in_array($parameter->getName(), $assisted->values)) {
                continue;
            }
            $hint = $parameter->getClass();
            $interface = $hint ? $hint->getName() : '';
            $name = $this->getName($method, $parameter);

$method of type object<ReflectionMethod> is not a sub-type of object<Ray\Aop\ReflectionMethod>. It seems like you assume a child class of the class ReflectionMethod to be always present.

            $arguments[] = $this->injector->getInstance($interface, $name);
        }

        return $arguments;
    }
}