Route - Code Metrics - Inspection of "prepare to tag" - canax/router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1d6a03...c7eb4e )

by Mikael

created 2017-09-28 19:45 UTC

Route B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	332
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

73.95%

Importance

Changes	5
Bugs	0	Features	1

Metric	Value
wmc	49
lcom	1
cbo	1
dl	0
loc	332
c	5
b	0
f	1
ccs	88
cts	119
cp	0.7395
rs	8.5454

12 Methods

Rating	Name	Size	Complexity
A	set()	16	3
B	checkPartAsArgument()	19	5
B	checkPartMatchingType()	23	5
A	typeConvertArgument()	11	2
A	matchPart()	19	4
B	matchRequestMethod()	9	6
D	match()	35	9
D	handle()	34	10
A	setName()	5	1
A	getInfo()	4	1
A	getRule()	4	1
A	getRequestMethod()	8	2

How to fix Complexity

<?php

namespace Anax\Route;

use \Anax\Route\Exception\ConfigurationException;

/**
 * A container for routes.
 *
 */
class Route
{
    /**
     * @var string       $name      a name for this route.
     * @var string       $info      description of route.
     * @var string|array $method    the method(s) to support
     * @var string       $rule      the path rule for this route
     * @var callable     $action    the callback to handle this route
     * @var null|array   $arguments arguments for the callback, extracted
     *                              from path
     */
    private $name;
    private $info;
    private $method;
    private $rule;
    private $action;
    private $arguments = [];



    /**
     * Set values for route.
     *
     * @param null|string       $rule   for this route
     * @param callable          $action callable to implement a controller for
     *                                  the route
     * @param null|string|array $method as request method to support
     * @param null|string       $info   description of the route
     *
     * @return $this
     */
    public function set($rule, $action = null, $method = null, $info = null)
    {
        $this->rule = $rule;
        $this->action = $action;
        $this->info = $info;

        $this->method = $method;
        if (is_string($method)) {
            $this->method = array_map("trim", explode("|", $method));
        }
        if (is_array($this->method)) {
            $this->method = array_map("strtoupper", $this->method);
        }

        return $this;
    }



    /**
     * Check if part of route is a argument and optionally match type
     * as a requirement {argument:type}.
     *
     * @param string $rulePart   the rule part to check.
     * @param string $queryPart  the query part to check.
     * @param array  &$args      add argument to args array if matched
     *
     * @return boolean
     */
    private function checkPartAsArgument($rulePart, $queryPart, &$args)
    {
        if (substr($rulePart, -1) == "}"
            && !is_null($queryPart)
        ) {
            $part = substr($rulePart, 1, -1);
            $pos = strpos($part, ":");
            $type = null;
            if ($pos !== false) {
                $type = substr($part, $pos + 1);
                if (! $this->checkPartMatchingType($queryPart, $type)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    return false;
                }
            }
            $args[] = $this->typeConvertArgument($queryPart, $type);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return true;
        }
        return false;
    }



    /**
     * Check if value is matching a certain type of values.
     *
     * @param string $value   the value to check.
     * @param array  $type    the expected type to check against.
     *
     * @return boolean
     */
    private function checkPartMatchingType($value, $type)
    {
        switch ($type) {
            case "digit":
                return ctype_digit($value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case "hex":
                return ctype_xdigit($value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case "alpha":
                return ctype_alpha($value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case "alphanum":
                return ctype_alnum($value);
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            default:
                return false;
        }
    }



    /**
     * Check if value is matching a certain type and do type
     * conversion accordingly.
     *
     * @param string $value   the value to check.
     * @param array  $type    the expected type to check against.
     *
     * @return boolean
     */
    private function typeConvertArgument($value, $type)
    {
        switch ($type) {
            case "digit":
                return (int) $value;
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            default:
                return $value;
        }
    }



    /**
     * Match part of rule and query.
     *
     * @param string $rulePart   the rule part to check.
     * @param string $queryPart  the query part to check.
     * @param array  &$args      add argument to args array if matched
     *
     * @return boolean
     */
    private function matchPart($rulePart, $queryPart, &$args)
    {
        $match = false;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $first = isset($rulePart[0]) ? $rulePart[0] : '';
        switch ($first) {
            case '*':
                $match = true;
                break;

            case '{':
                $match = $this->checkPartAsArgument($rulePart, $queryPart, $args);
                break;

            default:
                $match = ($rulePart == $queryPart);
                break;
        }
        return $match;
    }



    /**
     * Check if the request method matches.
     *
     * @param string $method as request method
     *
     * @return boolean true if request method matches
     */
    public function matchRequestMethod($method)
    {
        if ($method && is_array($this->method) && !in_array($method, $this->method)
            || (is_null($method) && !empty($this->method))
        ) {
            return false;
        }
        return true;
    }



    /**
     * Check if the route matches a query and request method.
     *
     * @param string $query  to match against
     * @param string $method as request method
     *
     * @return boolean true if query matches the route
     */
    public function match($query, $method = null)
    {
        if (!$this->matchRequestMethod($method)) {
            return false;
        }

        // If any/default */** route, match anything
        if (is_null($this->rule)
            || in_array($this->rule, ["*", "**"])
        ) {
            return true;
        }

        // Check all parts to see if they matches
        $ruleParts  = explode('/', $this->rule);
        $queryParts = explode('/', $query);
        $ruleCount = max(count($ruleParts), count($queryParts));
        $args = [];

        for ($i = 0; $i < $ruleCount; $i++) {
            $rulePart  = isset($ruleParts[$i])  ? $ruleParts[$i]  : null;
            $queryPart = isset($queryParts[$i]) ? $queryParts[$i] : null;

            if ($rulePart === "**") {
                break;
            }

            if (!$this->matchPart($rulePart, $queryPart, $args)) {
                return false;
            }
        }

        $this->arguments = $args;
        return true;
    }



    /**
     * Handle the action for the route.
     *
     * @param string $di container with services
     *
     * @return mixed
     */
    public function handle($di = null)
    {
        if (is_callable($this->action)) {
            return call_user_func($this->action, ...$this->arguments);
        }

        // Try to load service from app/di injected container
        if ($di
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            && is_array($this->action)
            && isset($this->action[0])
            && isset($this->action[1])
            && is_string($this->action[0])
        ) {
            if (!$di->has($this->action[0])) {

                throw new ConfigurationException("Routehandler '{$this->action[0]}' not loaded in di.");
            }

            $service = $di->get($this->action[0]);

            if (!is_callable([$service, $this->action[1]])) {
                throw new ConfigurationException(
                    "Routehandler '{$this->action[0]}' does not have a callable method '{$this->action[1]}'."
                );
            }

            return call_user_func(
                [$service, $this->action[1]],
                ...$this->arguments
            );
        }

        if (!is_null($this->action)) {
            throw new ConfigurationException("Routehandler '{$this->rule}' does not have a callable action.");
        }
    }



    /**
     * Set the name of the route.
     *
     * @param string $name set a name for the route
     *
     * @return $this
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }



    /**
     * Get information of the route.
     *
     * @return null|string as route information.
     */
    public function getInfo()
    {
        return $this->info;
    }



    /**
     * Get the rule for the route.
     *
     * @return string
     */
    public function getRule()
    {
        return $this->rule;
    }



    /**
     * Get the request method for the route.
     *
     * @return string representing the request method supported
     */
    public function getRequestMethod()
    {
        if (is_array($this->method)) {
            return implode("|", $this->method);
        }

        return $this->method;
    }
}


1		<?php
2
3		namespace Anax\Route;
4
5		use \Anax\Route\Exception\ConfigurationException;
6
7		/**
8		* A container for routes.
9		*
10		*/
11		class Route
12		{
13		/**
14		* @var string $name a name for this route.
15		* @var string $info description of route.
16		* @var string\|array $method the method(s) to support
17		* @var string $rule the path rule for this route
18		* @var callable $action the callback to handle this route
19		* @var null\|array $arguments arguments for the callback, extracted
20		* from path
21		*/
22		private $name;
23		private $info;
24		private $method;
25		private $rule;
26		private $action;
27		private $arguments = [];
28
29
30
31		/**
32		* Set values for route.
33		*
34		* @param null\|string $rule for this route
35		* @param callable $action callable to implement a controller for
36		* the route
37		* @param null\|string\|array $method as request method to support
38		* @param null\|string $info description of the route
39		*
40		* @return $this
41		*/
42	43	public function set($rule, $action = null, $method = null, $info = null)
43		{
44	43	$this->rule = $rule;
45	43	$this->action = $action;
46	43	$this->info = $info;
47
48	43	$this->method = $method;
49	43	if (is_string($method)) {
50	4	$this->method = array_map("trim", explode("\|", $method));
51	4	}
52	43	if (is_array($this->method)) {
53	9	$this->method = array_map("strtoupper", $this->method);
54	9	}
55
56	43	return $this;
57		}
58
59
60
61		/**
62		* Check if part of route is a argument and optionally match type
63		* as a requirement {argument:type}.
64		*
65		* @param string $rulePart the rule part to check.
66		* @param string $queryPart the query part to check.
67		* @param array &$args add argument to args array if matched
68		*
69		* @return boolean
70		*/
71	6	private function checkPartAsArgument($rulePart, $queryPart, &$args)
72		{
73	6	if (substr($rulePart, -1) == "}"
74	6	&& !is_null($queryPart)
75	6	) {
76	6	$part = substr($rulePart, 1, -1);
77	6	$pos = strpos($part, ":");
78	6	$type = null;
79	6	if ($pos !== false) {
80	2	$type = substr($part, $pos + 1);
81	2	if (! $this->checkPartMatchingType($queryPart, $type)) {
		0 ignored issues – show Documentation introduced 2017-06-27 09:15 UTC by Report Bug Copy Issue Report `$type` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Bug Best Practice introduced 2017-03-13 17:07 UTC by Report Bug Copy Issue Report The expression `$this->checkPartMatchingType($queryPart, $type)` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
82	2	return false;
83		}
84	2	}
85	6	$args[] = $this->typeConvertArgument($queryPart, $type);
		0 ignored issues – show Documentation introduced 2017-06-27 15:04 UTC by Report Bug Copy Issue Report `$type` is of type `string\|null`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
86	6	return true;
87		}
88	2	return false;
89		}
90
91
92
93		/**
94		* Check if value is matching a certain type of values.
95		*
96		* @param string $value the value to check.
97		* @param array $type the expected type to check against.
98		*
99		* @return boolean
100		*/
101	2	private function checkPartMatchingType($value, $type)
102		{
103		switch ($type) {
104	2	case "digit":
105	2	return ctype_digit($value);
106		break;
		0 ignored issues – show Unused Code introduced 2017-03-13 17:07 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
107
108	2	case "hex":
109	1	return ctype_xdigit($value);
110		break;
		0 ignored issues – show Unused Code introduced 2017-04-24 07:31 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
111
112	2	case "alpha":
113	2	return ctype_alpha($value);
114		break;
		0 ignored issues – show Unused Code introduced 2017-04-24 07:28 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
115
116	1	case "alphanum":
117	1	return ctype_alnum($value);
118		break;
		0 ignored issues – show Unused Code introduced 2017-03-13 17:07 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
119
120		default:
121		return false;
122		}
123		}
124
125
126
127		/**
128		* Check if value is matching a certain type and do type
129		* conversion accordingly.
130		*
131		* @param string $value the value to check.
132		* @param array $type the expected type to check against.
133		*
134		* @return boolean
135		*/
136	6	private function typeConvertArgument($value, $type)
137		{
138		switch ($type) {
139	6	case "digit":
140	2	return (int) $value;
141		break;
		0 ignored issues – show Unused Code introduced 2017-06-27 09:15 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
142
143	6	default:
144	6	return $value;
145	6	}
146		}
147
148
149
150		/**
151		* Match part of rule and query.
152		*
153		* @param string $rulePart the rule part to check.
154		* @param string $queryPart the query part to check.
155		* @param array &$args add argument to args array if matched
156		*
157		* @return boolean
158		*/
159	35	private function matchPart($rulePart, $queryPart, &$args)
160		{
161	35	$match = false;
		0 ignored issues – show Unused Code introduced 2017-03-03 15:59 UTC by Report Bug Copy Issue Report `$match` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
162	35	$first = isset($rulePart[0]) ? $rulePart[0] : '';
163		switch ($first) {
164	35	case '*':
165	3	$match = true;
166	3	break;
167
168	35	case '{':
169	6	$match = $this->checkPartAsArgument($rulePart, $queryPart, $args);
170	6	break;
171
172	34	default:
173	34	$match = ($rulePart == $queryPart);
174	34	break;
175	34	}
176	35	return $match;
177		}
178
179
180
181		/**
182		* Check if the request method matches.
183		*
184		* @param string $method as request method
185		*
186		* @return boolean true if request method matches
187		*/
188	42	public function matchRequestMethod($method)
189		{
190	42	if ($method && is_array($this->method) && !in_array($method, $this->method)
191	42	\|\| (is_null($method) && !empty($this->method))
192	42	) {
193	8	return false;
194		}
195	42	return true;
196		}
197
198
199
200		/**
201		* Check if the route matches a query and request method.
202		*
203		* @param string $query to match against
204		* @param string $method as request method
205		*
206		* @return boolean true if query matches the route
207		*/
208	42	public function match($query, $method = null)
209		{
210	42	if (!$this->matchRequestMethod($method)) {
211	8	return false;
212		}
213
214		// If any/default /* route, match anything
215	42	if (is_null($this->rule)
216	38	\|\| in_array($this->rule, ["", "*"])
217	42	) {
218	7	return true;
219		}
220
221		// Check all parts to see if they matches
222	35	$ruleParts = explode('/', $this->rule);
223	35	$queryParts = explode('/', $query);
224	35	$ruleCount = max(count($ruleParts), count($queryParts));
225	35	$args = [];
226
227	35	for ($i = 0; $i < $ruleCount; $i++) {
228	35	$rulePart = isset($ruleParts[$i]) ? $ruleParts[$i] : null;
229	35	$queryPart = isset($queryParts[$i]) ? $queryParts[$i] : null;
230
231	35	if ($rulePart === "**") {
232	3	break;
233		}
234
235	35	if (!$this->matchPart($rulePart, $queryPart, $args)) {
236	17	return false;
237		}
238	34	}
239
240	34	$this->arguments = $args;
241	34	return true;
242		}
243
244
245
246		/**
247		* Handle the action for the route.
248		*
249		* @param string $di container with services
250		*
251		* @return mixed
252		*/
253	32	public function handle($di = null)
254		{
255	32	if (is_callable($this->action)) {
256	32	return call_user_func($this->action, ...$this->arguments);
257		}
258
259		// Try to load service from app/di injected container
260		if ($di
		0 ignored issues – show Bug Best Practice introduced 2017-08-10 15:36 UTC by Report Bug Copy Issue Report The expression `$di` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
261		&& is_array($this->action)
262		&& isset($this->action[0])
263		&& isset($this->action[1])
264		&& is_string($this->action[0])
265		) {
266		if (!$di->has($this->action[0])) {
		0 ignored issues – show Bug introduced 2017-09-28 19:47 UTC by Report Bug Copy Issue Report The method `has` cannot be called on `$di` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
267		throw new ConfigurationException("Routehandler '{$this->action[0]}' not loaded in di.");
268		}
269
270		$service = $di->get($this->action[0]);
		0 ignored issues – show Bug introduced 2017-08-10 15:36 UTC by Report Bug Copy Issue Report The method `get` cannot be called on `$di` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
271		if (!is_callable([$service, $this->action[1]])) {
272		throw new ConfigurationException(
273		"Routehandler '{$this->action[0]}' does not have a callable method '{$this->action[1]}'."
274		);
275		}
276
277		return call_user_func(
278		[$service, $this->action[1]],
279		...$this->arguments
280		);
281		}
282
283		if (!is_null($this->action)) {
284		throw new ConfigurationException("Routehandler '{$this->rule}' does not have a callable action.");
285		}
286		}
287
288
289
290		/**
291		* Set the name of the route.
292		*
293		* @param string $name set a name for the route
294		*
295		* @return $this
296		*/
297		public function setName($name)
298		{
299		$this->name = $name;
300		return $this;
301		}
302
303
304
305		/**
306		* Get information of the route.
307		*
308		* @return null\|string as route information.
309		*/
310		public function getInfo()
311		{
312		return $this->info;
313		}
314
315
316
317		/**
318		* Get the rule for the route.
319		*
320		* @return string
321		*/
322	30	public function getRule()
323		{
324	30	return $this->rule;
325		}
326
327
328
329		/**
330		* Get the request method for the route.
331		*
332		* @return string representing the request method supported
333		*/
334		public function getRequestMethod()
335		{
336		if (is_array($this->method)) {
337		return implode("\|", $this->method);
338		}
339
340		return $this->method;
341		}
342		}
343

canax / router

Push — master ( 1d6a03...c7eb4e )

Route B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

12 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like