Go\Aop\Framework\AbstractMethodInvocation

Complexity

Total Complexity

10

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Test Coverage

Coverage

85.19%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	__invoke()	0	36	5
A	getMethod()	0	4	1
A	__toString()	0	9	2

<?php
declare(strict_types = 1);
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2011, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Aop\Framework;

use Go\Aop\Intercept\MethodInvocation;
use Go\Aop\Support\AnnotatedReflectionMethod;
use ReflectionMethod;
use function array_merge;
use function array_pop;
use function count;
use function is_string;

/**
 * Abstract method invocation implementation
 */
abstract class AbstractMethodInvocation extends AbstractInvocation implements MethodInvocation
{

    /**
     * Instance of object for invoking
     *
     * @var object|null
     */
    protected $instance;

    /**
     * Instance of reflection method for class
     *
     * @var ReflectionMethod
     */
    protected $reflectionMethod;

    /**
     * Class name scope for static invocation
     *
     * @var string
     */
    protected $scope;

    /**
     * Constructor for method invocation
     *
     * @param array $advices List of advices for this invocation
     */
    public function __construct(string $className, string $methodName, array $advices)
    {
        parent::__construct($advices);
        $this->reflectionMethod = $method = new AnnotatedReflectionMethod($className, $methodName);

        // Give an access to call protected method
        if ($method->isProtected()) {
            $method->setAccessible(true);
        }
    }

    /**
     * Invokes current method invocation with all interceptors
     *
     * @param null|object|string $instance Invocation instance (class name for static methods)
     * @param array $arguments List of arguments for method invocation
     * @param array $variadicArguments Additional list of variadic arguments
     *
     * @return mixed Result of invocation
     */
    final public function __invoke($instance = null, array $arguments = [], array $variadicArguments = [])
    {
        if ($this->level > 0) {
            $this->stackFrames[] = [$this->arguments, $this->scope, $this->instance, $this->current];
        }

        if (count($variadicArguments) > 0) {
            $arguments = array_merge($arguments, $variadicArguments);
        }

        try {
            ++$this->level;

            $this->current   = 0;
            $this->arguments = $arguments;

            if (is_string($instance)) {
                $this->scope = $instance;
            } else {
                // If it's not a string, then it should be object or null
                // We do not fill the $this->scope variable here to avoid performance lost
                $this->instance = $instance;
            }

            return $this->proceed();
        } finally {
            --$this->level;

            if ($this->level > 0) {
                [$this->arguments, $this->scope, $this->instance, $this->current] = array_pop($this->stackFrames);
            } else {
                $this->instance  = null;
                $this->arguments = [];
            }
        }
    }

    /**
     * Gets the method being called.
     *
     * @return ReflectionMethod|AnnotatedReflectionMethod the method being called.
     */
    public function getMethod(): ReflectionMethod
    {
        return $this->reflectionMethod;
    }

    /**
     * Returns friendly description of this joinpoint
     */
    final public function __toString(): string
    {
        return sprintf(
            'execution(%s%s%s())',
            $this->getScope(),
            $this->reflectionMethod->isStatic() ? '::' : '->',
            $this->reflectionMethod->name
        );
    }
}