AbstractProxy::prepareArgsLine() - Code Metrics - Inspection of "[Feature] Add variadic methods support for PHP>=5...." - goaop/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#253)

by Alexander

created 2016-02-20 18:17 UTC

AbstractProxy::prepareArgsLine() C

↳ Parent: AbstractProxy

Complexity

Conditions	8
Paths	54

Size

Total Lines	28
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	8.013

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	28
ccs	16
cts	17
cp	0.9412
rs	5.3846
cc	8
eloc	17
nc	54
nop	1
crap	8.013

<?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 ReflectionFunctionAbstract;
use ReflectionParameter;

/**
 * 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 join("\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)
    {
        $type = '';
        if ($parameter->isArray()) {
            $type = 'array';
        } elseif ($parameter->isCallable()) {
            $type = 'callable';
        } elseif ($parameter->getClass()) {
            $type = '\\' . $parameter->getClass()->name;
        }
        $defaultValue = null;
        $isDefaultValueAvailable = $parameter->isDefaultValueAvailable();
        if ($isDefaultValueAvailable) {
            $defaultValue = var_export($parameter->getDefaultValue(), true);
        } elseif ($parameter->isOptional()) {
            $defaultValue = 'null';
        }
        $code = (
            ($type ? "$type " : '') . // Typehint
            ($parameter->isPassedByReference() ? '&' : '') . // By reference sign
            ($parameter->isVariadic() ? '...' : '') . // Variadic symbol
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.
    }
}
            '$' . // 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 $advices
     *
     * @return array flatten list of advices
     */
    private function flattenAdvices($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()) ? '&' : '';
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.
    }
}
            $hasOptionals = $hasOptionals || $parameter->isOptional();

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

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

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


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 ReflectionFunctionAbstract;
14		use ReflectionParameter;
15
16		/**
17		* Abstract class for building different proxies
18		*/
19		abstract class AbstractProxy
20		{
21
22		/**
23		* Indent for source code
24		*
25		* @var int
26		*/
27		protected $indent = 4;
28
29		/**
30		* List of advices that are used for generation of child
31		*
32		* @var array
33		*/
34		protected $advices = [];
35
36		/**
37		* PHP expression string for accessing LSB information
38		*
39		* @var string
40		*/
41		protected static $staticLsbExpression = 'static::class';
42
43		/**
44		* Constructs an abstract proxy class
45		*
46		* @param array $advices List of advices
47		*/
48	5	public function __construct(array $advices = [])
49		{
50	5	$this->advices = $this->flattenAdvices($advices);
51	5	}
52
53		/**
54		* Returns text representation of class
55		*
56		* @return string
57		*/
58		abstract public function __toString();
59
60		/**
61		* Indent block of code
62		*
63		* @param string $text Non-indented text
64		*
65		* @return string Indented text
66		*/
67	5	protected function indent($text)
68		{
69	5	$pad = str_pad('', $this->indent, ' ');
70	5	$lines = array_map(function($line) use ($pad) {
71	5	return $pad . $line;
72	5	}, explode("\n", $text));
73
74	5	return join("\n", $lines);
75		}
76
77		/**
78		* Returns list of string representation of parameters
79		*
80		* @param array\|ReflectionParameter[] $parameters List of parameters
81		*
82		* @return array
83		*/
84	5	protected function getParameters(array $parameters)
85		{
86	5	$parameterDefinitions = [];
87	5	foreach ($parameters as $parameter) {
88	2	$parameterDefinitions[] = $this->getParameterCode($parameter);
89		}
90
91	5	return $parameterDefinitions;
92		}
93
94		/**
95		* Return string representation of parameter
96		*
97		* @param ReflectionParameter $parameter Reflection parameter
98		*
99		* @return string
100		*/
101	2	protected function getParameterCode(ReflectionParameter $parameter)
102		{
103	2	$type = '';
104	2	if ($parameter->isArray()) {
105		$type = 'array';
106	2	} elseif ($parameter->isCallable()) {
107		$type = 'callable';
108	2	} elseif ($parameter->getClass()) {
109		$type = '\\' . $parameter->getClass()->name;
110		}
111	2	$defaultValue = null;
112	2	$isDefaultValueAvailable = $parameter->isDefaultValueAvailable();
113	2	if ($isDefaultValueAvailable) {
114	2	$defaultValue = var_export($parameter->getDefaultValue(), true);
115	2	} elseif ($parameter->isOptional()) {
116		$defaultValue = 'null';
117		}
118		$code = (
119	2	($type ? "$type " : '') . // Typehint
120	2	($parameter->isPassedByReference() ? '&' : '') . // By reference sign
121	2	($parameter->isVariadic() ? '...' : '') . // Variadic symbol
		1 ignored issue – show Bug introduced 2016-02-20 18:20 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 `isVariadic()` 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...
122	2	'$' . // Variable symbol
123	2	($parameter->name) . // Name of the argument
124	2	($defaultValue !== null ? (" = " . $defaultValue) : '') // Default value if present
125		);
126
127	2	return $code;
128		}
129
130		/**
131		* Replace concrete advices with list of ids
132		*
133		* @param $advices
134		*
135		* @return array flatten list of advices
136		*/
137	5	private function flattenAdvices($advices)
138		{
139	5	$flattenAdvices = [];
140	5	foreach ($advices as $type => $typedAdvices) {
141	5	foreach ($typedAdvices as $name => $concreteAdvices) {
142	5	if (is_array($concreteAdvices)) {
143	5	$flattenAdvices[$type][$name] = array_keys($concreteAdvices);
144		}
145		}
146		}
147
148	5	return $flattenAdvices;
149		}
150
151		/**
152		* Prepares a line with args from the method definition
153		*
154		* @param ReflectionFunctionAbstract $functionLike
155		*
156		* @return string
157		*/
158	5	protected function prepareArgsLine(ReflectionFunctionAbstract $functionLike)
159		{
160	5	$argumentsPart = [];
161	5	$arguments = [];
162	5	$hasOptionals = false;
163
164	5	foreach ($functionLike->getParameters() as $parameter) {
165	2	$byReference = ($parameter->isPassedByReference() && !$parameter->isVariadic()) ? '&' : '';
		1 ignored issue – show Bug introduced 2016-02-20 18:20 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 `isVariadic()` 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...
166	2	$hasOptionals = $hasOptionals \|\| $parameter->isOptional();
167
168	2	$arguments[] = $byReference . '$' . $parameter->name;
169		}
170
171	5	$isVariadic = $functionLike->isVariadic();
		1 ignored issue – show Bug introduced 2016-02-20 18:20 UTC by Report Bug Copy Issue Report It seems like you code against a specific sub-type and not the parent class `ReflectionFunctionAbstract` as the method `isVariadic()` does only exist in the following sub-classes of `ReflectionFunctionAbstract`: `Go\ParserReflection\ReflectionFunction`, `Go\ParserReflection\ReflectionMethod`. 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...
172	5	if ($isVariadic) {
173		$argumentsPart[] = array_pop($arguments);
174		}
175	5	if (!empty($arguments)) {
176		// Unshifting to keep correct order
177	2	$argumentLine = '[' . join(', ', $arguments) . ']';
178	2	if ($hasOptionals) {
179	2	$argumentLine = "\\array_slice($argumentLine, 0, \\func_num_args())";
180		}
181	2	array_unshift($argumentsPart, $argumentLine);
182		}
183
184	5	return join(', ', $argumentsPart);
185		}
186		}
187

goaop / framework

Pull Request — master (#253)

AbstractProxy::prepareArgsLine() C

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like