Go\Proxy\AbstractProxy

Complexity

Total Complexity

44

Size/Duplication

Total Lines	272
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

99.01%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
	__toString()	0	1	?
A	indent()	0	9	1
A	getParameters()	0	9	2
B	getParameterCode()	0	21	8
A	flattenAdvices()	0	13	4
C	prepareArgsLine()	0	28	8
C	getOverriddenFunction()	0	39	8
C	resolveParameterTypeName()	0	24	7
B	resolveTypeName()	0	22	5

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2012, 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\Core\AspectContainer;
use Reflection;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionParameter;
use ReflectionType;

/**
 * Abstract class for building different proxies
 */
abstract class AbstractProxy
{

    /**
     * Indent for source code
     *
     * @var int
     */
    protected $indent = 4;

    /**
     * List of advices that are used for generation of child
     *
     * @var array
     */
    protected $advices = [];

    /**
     * PHP expression string for accessing LSB information
     *
     * @var string
     */
    protected static $staticLsbExpression = 'static::class';

    /**
     * Constructs an abstract proxy class
     *
     * @param array $advices List of advices
     */
    public function __construct(array $advices = [])
    {
        $this->advices = $this->flattenAdvices($advices);
    }

    /**
     * Returns text representation of class
     *
     * @return string
     */
    abstract public function __toString();

    /**
     * Indent block of code
     *
     * @param string $text Non-indented text
     *
     * @return string Indented text
     */
    protected function indent($text)
    {
        $pad   = str_pad('', $this->indent, ' ');
        $lines = array_map(function ($line) use ($pad) {
            return $pad . $line;
        }, explode("\n", $text));

        return implode("\n", $lines);
    }

    /**
     * Returns list of string representation of parameters
     *
     * @param array|ReflectionParameter[] $parameters List of parameters
     *
     * @return array
     */
    protected function getParameters(array $parameters)
    {
        $parameterDefinitions = [];
        foreach ($parameters as $parameter) {
            $parameterDefinitions[] = $this->getParameterCode($parameter);
        }

        return $parameterDefinitions;
    }

    /**
     * Return string representation of parameter
     *
     * @param ReflectionParameter $parameter Reflection parameter
     *
     * @return string
     */
    protected function getParameterCode(ReflectionParameter $parameter)
    {
        $typeName     = $this->resolveParameterTypeName($parameter);
        $defaultValue = null;
        $isDefaultValueAvailable = $parameter->isDefaultValueAvailable();
        if ($isDefaultValueAvailable) {
            $defaultValue = var_export($parameter->getDefaultValue(), true);
        } elseif ($parameter->isOptional() && !$parameter->isVariadic()) {
            $defaultValue = 'null';
        }
        $code = (
            (empty($typeName) ? '' : "$typeName ") . // Typehint
            ($parameter->isPassedByReference() ? '&' : '') . // By reference sign
            ($parameter->isVariadic() ? '...' : '') . // Variadic symbol
            '$' . // Variable symbol
            $parameter->name . // Name of the argument
            ($defaultValue !== null ? (' = ' . $defaultValue) : '') // Default value if present
        );

        return $code;
    }

    /**
     * Replace concrete advices with list of ids
     *
     * @param array $advices
     *
     * @return array flatten list of advices
     */
    private function flattenAdvices(array $advices)
    {
        $flattenAdvices = [];
        foreach ($advices as $type => $typedAdvices) {
            foreach ($typedAdvices as $name => $concreteAdvices) {
                if (is_array($concreteAdvices)) {
                    $flattenAdvices[$type][$name] = array_keys($concreteAdvices);
                }
            }
        }

        return $flattenAdvices;
    }

    /**
     * Prepares a line with args from the method definition
     *
     * @param ReflectionFunctionAbstract $functionLike
     *
     * @return string
     */
    protected function prepareArgsLine(ReflectionFunctionAbstract $functionLike)
    {
        $argumentsPart = [];
        $arguments     = [];
        $hasOptionals  = false;

        foreach ($functionLike->getParameters() as $parameter) {
            $byReference  = ($parameter->isPassedByReference() && !$parameter->isVariadic()) ? '&' : '';
            $hasOptionals = $hasOptionals || $parameter->isOptional();

            $arguments[] = $byReference . '$' . $parameter->name;
        }

        $isVariadic = $functionLike->isVariadic();
        if ($isVariadic) {
            $argumentsPart[] = array_pop($arguments);
        }
        if (!empty($arguments)) {
            // Unshifting to keep correct order
            $argumentLine = '[' . implode(', ', $arguments) . ']';
            if ($hasOptionals) {
                $argumentLine = "\\array_slice($argumentLine, 0, \\func_num_args())";
            }
            array_unshift($argumentsPart, $argumentLine);
        }

        return implode(', ', $argumentsPart);
    }

    /**
     * Creates a function code from Reflection
     *
     * @param ReflectionFunctionAbstract $functionLike Reflection for method
     * @param string $body Body of method
     *
     * @return string
     */
    protected function getOverriddenFunction(ReflectionFunctionAbstract $functionLike, $body)
    {
        $returnType    = '';
        $modifiersLine = '';
        if (PHP_VERSION_ID >= 70000 && $functionLike->hasReturnType()) {
            $reflectionType = $functionLike->getReturnType();
            $typeName       = (string) $reflectionType;
            $returnType     = $this->resolveTypeName($typeName, $reflectionType);
        }
        if ($functionLike instanceof ReflectionMethod) {
            $modifiersLine  = implode(' ', Reflection::getModifierNames($functionLike->getModifiers()));
            $declaringClass = $functionLike->getDeclaringClass();
            // Normalization of special `self` and `parent` type hints for methods
            if ($returnType === 'self') {
                $returnType = '\\' . $declaringClass->getName() . AspectContainer::AOP_PROXIED_SUFFIX;
            }
            if ($returnType === 'parent') {
                $returnType = '\\' . $parentClass = $declaringClass->getParentClass()->getName();
            }
        }

        $code = (
            preg_replace('/ {4}|\t/', '', $functionLike->getDocComment()) . "\n" . // Original Doc-block
            $modifiersLine . // List of modifiers (for methods)
            ' function ' . // 'function' keyword
            ($functionLike->returnsReference() ? '&' : '') . // By reference symbol
            $functionLike->name . // Name of the function
            '(' . // Start of parameters list
            implode(', ', $this->getParameters($functionLike->getParameters())) . // List of parameters
            ')' . // End of parameters list
            ($returnType ? " : $returnType" : '') . // Return type, if present
            "\n" .
            "{\n" . // Start of method body
            $this->indent($body) . "\n" . // Method body
            "}\n" // End of method body
        );

        return $code;
    }

    /**
     * Resolves parameter typehint
     *
     * @param ReflectionParameter $parameter Instance of reflection parameter
     *
     * @return string Resolved type name (FQN for classes)
     */
    protected function resolveParameterTypeName(ReflectionParameter $parameter)
    {
        $typeName       = '';
        $reflectionType = (PHP_VERSION_ID >= 70000 && $parameter->hasType()) ? $parameter->getType() : null;

It seems like you code against a specific sub-type and not the parent class ReflectionParameter as the method hasType() does only exist in the following sub-classes of ReflectionParameter: Go\ParserReflection\ReflectionParameter. Maybe you want to instanceof check for one of these explicitly?

        // This method for keeping short-time support for `self`, `parent`, etc for PHP>=5.6
        if (preg_match('/\<(?:optional|required)\> ([\w\\\]+)/i', (string) $parameter, $matches)) {
            $typeName = $matches[1];
        }
        if ($typeName === '') {
            return $typeName;
        }

        $typeName       = $this->resolveTypeName($typeName, $reflectionType);
        $declaringClass = $parameter->getDeclaringClass();
        // Normalization of special `self` and `parent` type hints for methods
        if ($typeName === 'self') {
            $typeName = '\\' . $declaringClass->getName() . AspectContainer::AOP_PROXIED_SUFFIX;
        }
        if ($typeName === 'parent') {
            $typeName = '\\' . $parentClass = $declaringClass->getParentClass()->getName();
        }

        return $typeName;
    }

    /**
     * Resolves type name from
     *
     * @param string $typeName Raw name of the type
     * @param ReflectionType|null $reflectionType Type (if present for PHP7)
     *
     * @return string
     */
    private function resolveTypeName($typeName, $reflectionType = null)
    {
        // see \PhpParser\BuilderAbstract::normalizeType source code, plus `self` and `parent`
        static $builtInTypes = [
            'string'   => 1,
            'float'    => 1,
            'boolean'  => 1,
            'integer'  => 1,
            'callable' => 1,
            'iterable' => 1,
            'void'     => 1,
            'object'   => 1,
            'self'     => 1,
            'parent'   => 1
        ];

        $isNullable = $reflectionType !== null && PHP_VERSION_ID >= 70100 && $reflectionType->allowsNull();
        $isBuiltin  = isset($builtInTypes[$typeName]);
        $typeName   = ($isNullable ? '?' : '') . ($isBuiltin ? '' : '\\') . $typeName;

        return $typeName;
    }
}