Go\Proxy\FunctionProxy

Complexity

Total Complexity

13

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes	6
Bugs	2	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
A	getJoinPoint()	0	18	3
A	injectJoinPoints()	0	4	1
A	override()	0	6	1
A	__toString()	0	18	1
B	getOverriddenFunction()	0	26	3
A	getJoinpointInvocationBody()	0	14	1

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2013, 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\Proxy;

use Go\Aop\Advice;
use Go\Aop\Framework\ReflectionFunctionInvocation;
use Go\Aop\Intercept\FunctionInvocation;
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
use Go\Core\LazyAdvisorAccessor;
use Go\ParserReflection\ReflectionFileNamespace;
use ReflectionFunction;

/**
 * Function proxy builder that is used to generate a proxy-function from the list of joinpoints
 */
class FunctionProxy extends AbstractProxy
{

    /**
     * List of advices for functions
     *
     * @var array
     */
    protected static $functionAdvices = [];

    /**
     * Name for the current namespace
     *
     * @var string
     */
    protected $namespace = '';

    /**
     * Source code for functions
     *
     * @var array Name of the function => source code for it
     */
    protected $functionsCode = [];

    /**
     * Constructs functions stub class from namespace Reflection
     *
     * @param ReflectionFileNamespace $namespace Reflection of namespace
     * @param array $advices List of function advices
     *
     * @throws \InvalidArgumentException for invalid classes
     */
    public function __construct(ReflectionFileNamespace $namespace, array $advices = [])
    {
        parent::__construct($advices);
        $this->namespace = $namespace;

It seems like $namespace of type object<Go\ParserReflection\ReflectionFileNamespace> is incompatible with the declared type string of property $namespace.

        if (empty($advices[AspectContainer::FUNCTION_PREFIX])) {
            return;
        }

        foreach ($advices[AspectContainer::FUNCTION_PREFIX] as $pointName => $value) {
            $function = new ReflectionFunction($pointName);
            $this->override($function, $this->getJoinpointInvocationBody($function));
        }
    }

    /**
     * Returns a joinpoint for specific function in the namespace
     *
     * @param string $joinPointName Special joinpoint name
     * @param string $namespace Name of the namespace
     *
     * @return FunctionInvocation
     */
    public static function getJoinPoint($joinPointName, $namespace)
    {
        /** @var LazyAdvisorAccessor $accessor */
        static $accessor = null;

        if (!$accessor) {
            $accessor = AspectKernel::getInstance()->getContainer()->get('aspect.advisor.accessor');
        }

        $advices = self::$functionAdvices[$namespace][AspectContainer::FUNCTION_PREFIX][$joinPointName];

        $filledAdvices = [];
        foreach ($advices as $advisorName) {
            $filledAdvices[] = $accessor->$advisorName;
        }

        return new ReflectionFunctionInvocation($joinPointName, $filledAdvices);
    }

    /**
     * Inject advices for given trait
     *
     * NB This method will be used as a callback during source code evaluation to inject joinpoints
     *
     * @param string $namespace Aop child proxy class
     * @param array|Advice[] $advices List of advices to inject into class
     *
     * @return void
     */
    public static function injectJoinPoints($namespace, array $advices = [])
    {
        self::$functionAdvices[$namespace] = $advices;
    }

    /**
     * Override function with new body
     *
     * @param ReflectionFunction $function Function reflection
     * @param string $body New body for function
     *
     * @return $this
     */
    public function override(ReflectionFunction $function, $body)
    {
        $this->functionsCode[$function->name] = $this->getOverriddenFunction($function, $body);

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function __toString()
    {
        $functionsCode = (
            "<?php\n" . // Start of file header
            $this->namespace->getDocComment() . "\n" . // Doc-comment for file

The method getDocComment cannot be called on $this->namespace (of type string).

            'namespace ' . // 'namespace' keyword
            $this->namespace->getName() . // Name

The method getName cannot be called on $this->namespace (of type string).

            ";\n" . // End of namespace name
            join("\n", $this->functionsCode) // Function definitions
        );

        return $functionsCode
            // Inject advices on call
            . PHP_EOL
            . '\\' . __CLASS__ . "::injectJoinPoints('"
                . $this->namespace->getName() . "',"

The method getName cannot be called on $this->namespace (of type string).

                . var_export($this->advices, true) . ");";
    }

    /**
     * Creates a function code from Reflection
     *
     * @param ReflectionFunction $function Reflection for function
     * @param string $body Body of function
     *
     * @return string
     */
    protected function getOverriddenFunction(ReflectionFunction $function, $body)
    {
        static $inMemoryCache = [];

        $functionName = $function->getName();
        if (isset($inMemoryCache[$functionName])) {
            return $inMemoryCache[$functionName];
        }

        $code = (
            preg_replace('/ {4}|\t/', '', $function->getDocComment()) . "\n" . // Original doc-comment
            'function ' . // 'function' keyword
            ($function->returnsReference() ? '&' : '') . // By reference symbol
            $functionName . // Function name
            '(' . // Start of parameters
            join(', ', $this->getParameters($function->getParameters())) . // List of parameters
            ")\n" . // End of parameters
            "{\n" . // Start of function body
            $this->indent($body) . "\n" . // Body of function
            "}\n" // End of function body
        );

        $inMemoryCache[$functionName] = $code;

        return $code;
    }

    /**
     * Creates definition for trait method body
     *
     * @param ReflectionFunction $function Method reflection
     *
     * @return string new method body
     */
    protected function getJoinpointInvocationBody(ReflectionFunction $function)
    {
        $class = '\\' . __CLASS__;

        $args = $this->prepareArgsLine($function);

        return <<<BODY
static \$__joinPoint = null;
if (!\$__joinPoint) {
    \$__joinPoint = {$class}::getJoinPoint('{$function->name}', __NAMESPACE__);
}
return \$__joinPoint->__invoke($args);
BODY;
    }

}