AbstractProxy::getParameterCode() - Code Metrics - Inspection of "Fix handling of special type hints, resolves #376" - goaop/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 2.x (#381)

by Alexander

created 2018-01-02 11:07 UTC

AbstractProxy::getParameterCode() B

↳ Parent: AbstractProxy

Complexity

Conditions	8
Paths	48

Size

Total Lines	21
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	8.0189

Importance

Changes

Metric	Value
dl	0
loc	21
ccs	14
cts	15
cp	0.9333
rs	7.1428
c	0
b	0
f	0
cc	8
eloc	16
nc	48
nop	1
crap	8.0189

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2012, Lisachenko Alexander <[email protected]>
 *
 * 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;
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        // 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;
    }
}


1		<?php
2		/*
3		* Go! AOP framework
4		*
5		* @copyright Copyright 2012, Lisachenko Alexander <[email protected]>
6		*
7		* This source file is subject to the license that is bundled
8		* with this source code in the file LICENSE.
9		*/
10
11		namespace Go\Proxy;
12
13		use Go\Core\AspectContainer;
14		use Reflection;
15		use ReflectionFunctionAbstract;
16		use ReflectionMethod;
17		use ReflectionParameter;
18		use ReflectionType;
19
20		/**
21		* Abstract class for building different proxies
22		*/
23		abstract class AbstractProxy
24		{
25
26		/**
27		* Indent for source code
28		*
29		* @var int
30		*/
31		protected $indent = 4;
32
33		/**
34		* List of advices that are used for generation of child
35		*
36		* @var array
37		*/
38		protected $advices = [];
39
40		/**
41		* PHP expression string for accessing LSB information
42		*
43		* @var string
44		*/
45		protected static $staticLsbExpression = 'static::class';
46
47		/**
48		* Constructs an abstract proxy class
49		*
50		* @param array $advices List of advices
51		*/
52	4	public function __construct(array $advices = [])
53		{
54	4	$this->advices = $this->flattenAdvices($advices);
55	4	}
56
57		/**
58		* Returns text representation of class
59		*
60		* @return string
61		*/
62		abstract public function __toString();
63
64		/**
65		* Indent block of code
66		*
67		* @param string $text Non-indented text
68		*
69		* @return string Indented text
70		*/
71	4	protected function indent($text)
72		{
73	4	$pad = str_pad('', $this->indent, ' ');
74	4	$lines = array_map(function ($line) use ($pad) {
75	4	return $pad . $line;
76	4	}, explode("\n", $text));
77
78	4	return implode("\n", $lines);
79		}
80
81		/**
82		* Returns list of string representation of parameters
83		*
84		* @param array\|ReflectionParameter[] $parameters List of parameters
85		*
86		* @return array
87		*/
88	4	protected function getParameters(array $parameters)
89		{
90	4	$parameterDefinitions = [];
91	4	foreach ($parameters as $parameter) {
92	2	$parameterDefinitions[] = $this->getParameterCode($parameter);
93		}
94
95	4	return $parameterDefinitions;
96		}
97
98		/**
99		* Return string representation of parameter
100		*
101		* @param ReflectionParameter $parameter Reflection parameter
102		*
103		* @return string
104		*/
105	2	protected function getParameterCode(ReflectionParameter $parameter)
106		{
107	2	$typeName = $this->resolveParameterTypeName($parameter);
108	2	$defaultValue = null;
109	2	$isDefaultValueAvailable = $parameter->isDefaultValueAvailable();
110	2	if ($isDefaultValueAvailable) {
111	1	$defaultValue = var_export($parameter->getDefaultValue(), true);
112	2	} elseif ($parameter->isOptional() && !$parameter->isVariadic()) {
113		$defaultValue = 'null';
114		}
115		$code = (
116	2	(empty($typeName) ? '' : "$typeName ") . // Typehint
117	2	($parameter->isPassedByReference() ? '&' : '') . // By reference sign
118	2	($parameter->isVariadic() ? '...' : '') . // Variadic symbol
119	2	'$' . // Variable symbol
120	2	$parameter->name . // Name of the argument
121	2	($defaultValue !== null ? (' = ' . $defaultValue) : '') // Default value if present
122		);
123
124	2	return $code;
125		}
126
127		/**
128		* Replace concrete advices with list of ids
129		*
130		* @param array $advices
131		*
132		* @return array flatten list of advices
133		*/
134	4	private function flattenAdvices(array $advices)
135		{
136	4	$flattenAdvices = [];
137	4	foreach ($advices as $type => $typedAdvices) {
138	4	foreach ($typedAdvices as $name => $concreteAdvices) {
139	4	if (is_array($concreteAdvices)) {
140	4	$flattenAdvices[$type][$name] = array_keys($concreteAdvices);
141		}
142		}
143		}
144
145	4	return $flattenAdvices;
146		}
147
148		/**
149		* Prepares a line with args from the method definition
150		*
151		* @param ReflectionFunctionAbstract $functionLike
152		*
153		* @return string
154		*/
155	4	protected function prepareArgsLine(ReflectionFunctionAbstract $functionLike)
156		{
157	4	$argumentsPart = [];
158	4	$arguments = [];
159	4	$hasOptionals = false;
160
161	4	foreach ($functionLike->getParameters() as $parameter) {
162	2	$byReference = ($parameter->isPassedByReference() && !$parameter->isVariadic()) ? '&' : '';
163	2	$hasOptionals = $hasOptionals \|\| $parameter->isOptional();
164
165	2	$arguments[] = $byReference . '$' . $parameter->name;
166		}
167
168	4	$isVariadic = $functionLike->isVariadic();
169	4	if ($isVariadic) {
170	1	$argumentsPart[] = array_pop($arguments);
171		}
172	4	if (!empty($arguments)) {
173		// Unshifting to keep correct order
174	2	$argumentLine = '[' . implode(', ', $arguments) . ']';
175	2	if ($hasOptionals) {
176	1	$argumentLine = "\\array_slice($argumentLine, 0, \\func_num_args())";
177		}
178	2	array_unshift($argumentsPart, $argumentLine);
179		}
180
181	4	return implode(', ', $argumentsPart);
182		}
183
184		/**
185		* Creates a function code from Reflection
186		*
187		* @param ReflectionFunctionAbstract $functionLike Reflection for method
188		* @param string $body Body of method
189		*
190		* @return string
191		*/
192	4	protected function getOverriddenFunction(ReflectionFunctionAbstract $functionLike, $body)
193		{
194	4	$returnType = '';
195	4	$modifiersLine = '';
196	4	if (PHP_VERSION_ID >= 70000 && $functionLike->hasReturnType()) {
197	1	$reflectionType = $functionLike->getReturnType();
198	1	$typeName = (string) $reflectionType;
199	1	$returnType = $this->resolveTypeName($typeName, $reflectionType);
200		}
201	4	if ($functionLike instanceof ReflectionMethod) {
202	4	$modifiersLine = implode(' ', Reflection::getModifierNames($functionLike->getModifiers()));
203	4	$declaringClass = $functionLike->getDeclaringClass();
204		// Normalization of special `self` and `parent` type hints for methods
205	4	if ($returnType === 'self') {
206	1	$returnType = '\\' . $declaringClass->getName() . AspectContainer::AOP_PROXIED_SUFFIX;
207		}
208	4	if ($returnType === 'parent') {
209	1	$returnType = '\\' . $parentClass = $declaringClass->getParentClass()->getName();
210		}
211		}
212
213		$code = (
214	4	preg_replace('/ {4}\|\t/', '', $functionLike->getDocComment()) . "\n" . // Original Doc-block
215	4	$modifiersLine . // List of modifiers (for methods)
216	4	' function ' . // 'function' keyword
217	4	($functionLike->returnsReference() ? '&' : '') . // By reference symbol
218	4	$functionLike->name . // Name of the function
219	4	'(' . // Start of parameters list
220	4	implode(', ', $this->getParameters($functionLike->getParameters())) . // List of parameters
221	4	')' . // End of parameters list
222	4	($returnType ? " : $returnType" : '') . // Return type, if present
223	4	"\n" .
224	4	"{\n" . // Start of method body
225	4	$this->indent($body) . "\n" . // Method body
226	4	"}\n" // End of method body
227		);
228
229	4	return $code;
230		}
231
232		/**
233		* Resolves parameter typehint
234		*
235		* @param ReflectionParameter $parameter Instance of reflection parameter
236		*
237		* @return string Resolved type name (FQN for classes)
238		*/
239	2	protected function resolveParameterTypeName(ReflectionParameter $parameter)
240		{
241	2	$typeName = '';
242	2	$reflectionType = (PHP_VERSION_ID >= 70000 && $parameter->hasType()) ? $parameter->getType() : null;
		0 ignored issues – show Bug introduced 2018-01-02 11:09 UTC by Report Bug Copy Issue Report 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? Let’s take a look at an example: abstract class User { /** @return string / abstract public function getPassword(); } class MyUser extends User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different sub-classes of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the parent class: abstract class User { /** @return string / abstract public function getPassword(); /* @return string */ abstract public function getDisplayName(); } Loading history...
243		// This method for keeping short-time support for `self`, `parent`, etc for PHP>=5.6
244	2	if (preg_match('/\<(?:optional\|required)\> ([\w\\\]+)/i', (string) $parameter, $matches)) {
245	2	$typeName = $matches[1];
246		}
247	2	if ($typeName === '') {
248	1	return $typeName;
249		}
250
251	2	$typeName = $this->resolveTypeName($typeName, $reflectionType);
252	2	$declaringClass = $parameter->getDeclaringClass();
253		// Normalization of special `self` and `parent` type hints for methods
254	2	if ($typeName === 'self') {
255	1	$typeName = '\\' . $declaringClass->getName() . AspectContainer::AOP_PROXIED_SUFFIX;
256		}
257	2	if ($typeName === 'parent') {
258	1	$typeName = '\\' . $parentClass = $declaringClass->getParentClass()->getName();
259		}
260
261	2	return $typeName;
262		}
263
264		/**
265		* Resolves type name from
266		*
267		* @param string $typeName Raw name of the type
268		* @param ReflectionType\|null $reflectionType Type (if present for PHP7)
269		*
270		* @return string
271		*/
272	2	private function resolveTypeName($typeName, $reflectionType = null)
273		{
274		// see \PhpParser\BuilderAbstract::normalizeType source code, plus `self` and `parent`
275	2	static $builtInTypes = [
276		'string' => 1,
277		'float' => 1,
278		'boolean' => 1,
279		'integer' => 1,
280		'callable' => 1,
281		'iterable' => 1,
282		'void' => 1,
283		'object' => 1,
284		'self' => 1,
285		'parent' => 1
286		];
287
288	2	$isNullable = $reflectionType !== null && PHP_VERSION_ID >= 70100 && $reflectionType->allowsNull();
289	2	$isBuiltin = isset($builtInTypes[$typeName]);
290	2	$typeName = ($isNullable ? '?' : '') . ($isBuiltin ? '' : '\\') . $typeName;
291
292	2	return $typeName;
293		}
294		}
295

goaop / framework

Pull Request — 2.x (#381)

AbstractProxy::getParameterCode() B

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like