Ray\Aop\ReflectiveMethodInvocation

Complexity

Total Complexity

12

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getMethod()	0	15	3
A	getArguments()	0	6	1
A	getNamedArguments()	0	11	2
A	proceed()	0	12	3
A	getThis()	0	4	1
A	getCallable()	0	4	1

<?php

declare(strict_types=1);

namespace Ray\Aop;

final class ReflectiveMethodInvocation implements MethodInvocation
{
    /**
     * @var object
     */
    private $object;

    /**
     * @var array|\ArrayObject
     */
    private $arguments;

    /**
     * @var string
     */
    private $method;

    /**
     * @var MethodInterceptor[]
     */
    private $interceptors;

    /**
     * @var callable
     */
    private $callable;

    /**
     * @param object              $object
     * @param MethodInterceptor[] $interceptors
     */
    public function __construct(
        $object,
        string $method,
        array $arguments,
        array $interceptors = []
    ) {
        $this->object = $object;
        $this->method = $method;
        $this->callable = $this->getCallable($object, $method);
        $this->arguments = $arguments;
        $this->interceptors = $interceptors;
    }

    /**
     * {@inheritdoc}
     *
     * @throws \ReflectionException
     */
    public function getMethod() : ReflectionMethod
    {
        if ($this->object instanceof WeavedInterface) {
            $class = (new \ReflectionObject($this->object))->getParentClass();
            if (! $class instanceof \ReflectionClass) {
                throw new \LogicException; // @codeCoverageIgnore
            }
            $method = new ReflectionMethod($class->name, $this->method);
            $method->setObject($this->object, $method);

            return $method;
        }

        return new ReflectionMethod($this->object, $this->method);
    }

    /**
     * {@inheritdoc}
     */
    public function getArguments() : \ArrayObject
    {
        $this->arguments = new \ArrayObject($this->arguments);

        return $this->arguments;
    }

    /**
     * {@inheritdoc}
     *
     * @throws \ReflectionException
     */
    public function getNamedArguments() : \ArrayObject
    {
        $args = $this->getArguments();
        $paramas = $this->getMethod()->getParameters();
        $namedParams = new \ArrayObject;
        foreach ($paramas as $param) {
            $namedParams[$param->getName()] = $args[$param->getPosition()];

Consider using $param->name. There is an issue with getName() and APC-enabled PHP versions.

        }

        return $namedParams;
    }

    /**
     * {@inheritdoc}
     */
    public function proceed()
    {
        if ($this->interceptors === []) {
            return call_user_func_array($this->callable, (array) $this->arguments);
        }
        $interceptor = array_shift($this->interceptors);
        if ($interceptor instanceof MethodInterceptor) {
            return $interceptor->invoke($this);
        }

        throw new \LogicException;
    }

    /**
     * {@inheritdoc}
     */
    public function getThis()
    {
        return $this->object;
    }

    private function getCallable($object, string $method) : callable
    {
        return [$object, $method];
    }
}