Route::parseCallablePlaceholders() - Code Metrics - Inspection of "push all v2 stuffs :)" - codeburnerframework/routing - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — dev (8b2306)

by Alex

created 2016-02-09 02:01 UTC

Route::parseCallablePlaceholders() A

↳ Parent: Route

Complexity

Conditions	4
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	8.7414

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
ccs	3
cts	9
cp	0.3333
rs	9.2
cc	4
eloc	6
nc	2
nop	1
crap	8.7414

<?php

/**
 * Codeburner Framework.
 *
 * @author Alex Rohleder <[email protected]>
 * @copyright 2016 Alex Rohleder
 * @license http://opensource.org/licenses/MIT
 */

namespace Codeburner\Router;

use Codeburner\Router\Exceptions\BadRouteException;
use Codeburner\Router\Strategies\MatcherAwareInterface;
use Codeburner\Router\Strategies\StrategyInterface;

/**
 * Route representation, a route must be able to chang and execute itself.
 *
 * @author Alex Rohleder <[email protected]>
 */

class Route
{

    /**
     * @var Collector
     */

    protected $collector;
    
    /**
     * @var string
     */

    protected $method;
    
    /**
     * @var string
     */

    protected $pattern;
    
    /**
     * @var string|array|\Closure
     */

    protected $action;
    
    /**
     * @var string
     */

    protected $namespace = "";

    /**
     * @var string[]
     */

    protected $params = [];

    /**
     * Defaults are parameters set by the user, and don't
     * appear on the pattern.
     *
     * @var array
     */

    protected $defaults = [];

    /**
     * Metadata can be set to be used on filters, dispatch strategies
     * or anywhere the route object is used.
     *
     * @var array
     */

    protected $metadata = [];

    /**
     * @var null|string|StrategyInterface
     */

    protected $strategy;

    /**
     * Blocked routes are dynamic routes selected to pass by the matcher.
     *
     * @var boolean
     */

    protected $blocked = false;

    /**
     * The matcher that dispatched this route.
     *
     * @var Matcher $matcher
     */

    protected $matcher;

    /**
     * The function used to create controllers from name.
     *
     * @var null|string|array|\Closure
     */

    protected $controllerCreationFunction;

    /**
     * @param Collector $collector
     * @param string $method
     * @param string $pattern
     * @param string|array|\Closure $action
     */

    public function __construct(Collector $collector, $method, $pattern, $action)
    {
        $this->collector = $collector;
        $this->method    = $method;
        $this->pattern   = $pattern;
        $this->action    = $action;
    }

    /**
     * Clone this route and set it into the collector.
     *
     * @return Route
     */

    public function reset()
    {
        return $this->collector->set($this->method, $this->pattern, $this->action)->nth(0)
                               ->setStrategy($this->strategy)->setParams($this->params)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                               ->setDefaults($this->defaults)->setMetadataArray($this->metadata);
    }

    /**
     * Remove this route from the collector.
     *
     * @return self
     */

    public function forget()
    {
        $this->collector->forget($this->method, $this->pattern);
        return $this;
    }

    /**
     * Blocking a route indicate that that route have been selected and
     * parsed, now it will be given to the matcher.
     *
     * @return self
     */

    public function block()
    {
        $this->blocked = true;
        return $this;
    }

    /**
     * Verify if a Route have already been blocked.
     *
     * @return boolean
     */

    public function blocked()
    {
        return $this->blocked;
    }

    /**
     * Execute the route action, if no strategy was provided the action
     * will be executed by the call_user_func PHP function.
     *
     * @throws BadRouteException
     * @return mixed
     */

    public function call()
    {
        $this->action = $this->parseCallable($this->action);

        if ($this->strategy === null) {
            return call_user_func_array($this->action, array_merge($this->defaults, $this->params));
        }

        if (!is_object($this->strategy)) {
            $this->strategy = new $this->strategy;
        }

        return $this->callWithStrategy();
    }

    /**
     * Seek for dynamic content on callables. eg. routes action controller#action
     * syntax allow to use the variables to build the string like: {controller}@{action}
     *
     * @param string|array|\Closure $callable
     * @return string|array|\Closure
     */

    private function parseCallable($callable)
    {
        if (is_string($callable) && strpos($callable, "@")) {
            $callable = explode("@", $callable);
        }

        if (is_array($callable)) {
            if (is_string($callable[0])) {
                   $callable[0] = $this->parseCallableController($callable[0]);
                   $callable[1] = $this->parseCallablePlaceholders($callable[1]);
            } else $callable[1] = $this->parseCallablePlaceholders($callable[1]);
        }

        return $callable;
    }

    /**
     * Get the controller object.
     *
     * @param string $controller
     * @return Object
     */

    private function parseCallableController($controller)
    {
        $controller  = rtrim($this->namespace, "\\") . "\\" . $this->parseCallablePlaceholders($controller);

        if ($this->controllerCreationFunction === null) {
               return new $controller;
        } else return call_user_func($this->controllerCreationFunction, $controller);
    }

    /**
     * Parse and replace dynamic content on route action.
     *
     * @param  string $fragment Part of callable
     * @return string
     */

    private function parseCallablePlaceholders($fragment)
    {
        if (strpos($fragment, "{") !== false) {
            foreach ($this->params as $placeholder => $value) {
                if (strpos($fragment, "{" . $placeholder . "}") !== false) {
                    $fragment = str_replace("{" . $placeholder . "}", ucwords(str_replace("-", " ", $value)), $fragment);
                }
            }
        }

        return $fragment;
    }

    /**
     * Execute the route action with the given strategy.
     *
     * @throws BadRouteException
     * @return mixed
     */

    private function callWithStrategy()
    {
        if ($this->strategy instanceof StrategyInterface) {
            if ($this->strategy instanceof MatcherAwareInterface) {
                $this->strategy->setMatcher($this->matcher);
            }

            return $this->strategy->call($this);
        }

        throw new BadRouteException("`$this->strategy` is not a valid route dispatch strategy, ".
            "it must implement the `Codeburner\Router\Strategies\StrategyInterface` interface.");
    }

    /**
     * @return Collector
     */

    public function getCollector()
    {
        return $this->collector;
    }

    /**
     * @return string
     */

    public function getMethod()
    {
        return $this->method;
    }

    /**
     * @return string
     */

    public function getPattern()
    {
        return $this->pattern;
    }

    /**
     * @return string[]
     */

    public function getSegments()
    {
        return explode("/", $this->pattern);
    }

    /**
     * @return string|array|\Closure
     */

    public function getAction()
    {
        return $this->action;
    }

    /**
     * @return string
     */

    public function getNamespace()
    {
        return $this->namespace;
    }

    /**
     * @return string[]
     */

    public function getParams()
    {
        return $this->params;
    }

    /**
     * @param string $key
     * @return string
     */

    public function getParam($key)
    {
        return $this->params[$key];
    }

    /**
     * @return array
     */

    public function getDefaults()
    {
        return $this->defaults;
    }

    /**
     * @param string $key
     * @return mixed
     */

    public function getDefault($key)
    {
        return $this->defaults[$key];
    }

    /**
     * @return array
     */

    public function getMetadataArray()
    {
        return $this->metadata;
    }

    /**
     * @param string $key
     * @return mixed
     */

    public function getMetadata($key)
    {
        return $this->metadata[$key];
    }

    /**
     * @return string|null
     */

    public function getStrategy()
    {
        if ($this->strategy instanceof StrategyInterface) {
            return get_class($this->strategy);
        }

        return $this->strategy;
    }

    /**
     * @inheritdoc
     */

    public function getMatcher()
    {
        return $this->matcher;
    }

    /**
     * @param string $method
     * @return Route
     */

    public function setMethod($method)
    {
        $this->forget();
        $this->method = $method;
        return $this->reset();
    }

    /**
     * @param string $pattern
     * @return Route
     */

    public function setPattern($pattern)
    {
        $this->forget();
        $this->pattern = $pattern;
        return $this->reset();
    }

    /**
     * @param string $pattern
     * @return self
     */

    public function setPatternWithoutReset($pattern)
    {
        $this->pattern = $pattern;
        return $this;
    }

    /**
     * @param string $action
     * @return self
     */

    public function setAction($action)
    {
        $this->action = $action;
        return $this;
    }

    /**
     * @param string $namespace
     * @return self
     */

    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
        return $this;
    }

    /**
     * @param string[] $params
     * @return self
     */

    public function setParams(array $params)
    {
        $this->params = $params;
        return $this;
    }

    /**
     * @param string $key
     * @param string $value
     *
     * @return self
     */

    public function setParam($key, $value)
    {
        $this->params[$key] = $value;
        return $this;
    }

    /**
     * @param mixed[] $defaults
     * @return self
     */

    public function setDefaults(array $defaults)
    {
        $this->defaults = $defaults;
        return $this;
    }

    /**
     * @param string $key
     * @param mixed $value
     *
     * @return self
     */

    public function setDefault($key, $value)
    {
        $this->defaults[$key] = $value;
        return $this;
    }

    /**
     * @param mixed[] $metadata
     * @return self
     */

    public function setMetadataArray(array $metadata)
    {
        $this->metadata = $metadata;
        return $this;
    }

    /**
     * @param string $key
     * @param mixed $value
     *
     * @return $this
     */

    public function setMetadata($key, $value)
    {
        $this->metadata[$key] = $value;
        return $this;
    }

    /**
     * @param string|StrategyInterface $strategy
     * @return self
     */

    public function setStrategy($strategy)
    {
        $this->strategy = $strategy;
        return $this;
    }

    /**
     * @inheritdoc
     */

    public function setMatcher(Matcher $matcher)
    {
        $this->matcher = $matcher;
    }

    /**
     * Set a function to create controllers.
     *
     * @param string|array|\Closure $callable
     * @throws BadRouteException
     * @return self
     */

    public function setControllerCreationFunction($callable)
    {
        if (!is_callable($callable)) {
            throw new BadRouteException(BadRouteException::WRONG_CONTROLLER_CREATION_FUNC);
        }

        $this->controllerCreationFunction = $this->parseCallable($callable);
        return $this;
    }

    /**
     * @param string $key
     * @return bool
     */

    public function hasParam($key)
    {
        return isset($this->params[$key]);
    }

    /**
     * @param string $key
     * @return bool
     */

    public function hasDefault($key)
    {
        return isset($this->defaults[$key]);
    }

    /**
     * @param string $key
     * @return bool
     */

    public function hasMetadata($key)
    {
        return isset($this->metadata[$key]);
    }

}


1		<?php
2
3		/**
4		* Codeburner Framework.
5		*
6		* @author Alex Rohleder <[email protected]>
7		* @copyright 2016 Alex Rohleder
8		* @license http://opensource.org/licenses/MIT
9		*/
10
11		namespace Codeburner\Router;
12
13		use Codeburner\Router\Exceptions\BadRouteException;
14		use Codeburner\Router\Strategies\MatcherAwareInterface;
15		use Codeburner\Router\Strategies\StrategyInterface;
16
17		/**
18		* Route representation, a route must be able to chang and execute itself.
19		*
20		* @author Alex Rohleder <[email protected]>
21		*/
22
23		class Route
24		{
25
26		/**
27		* @var Collector
28		*/
29
30		protected $collector;
31
32		/**
33		* @var string
34		*/
35
36		protected $method;
37
38		/**
39		* @var string
40		*/
41
42		protected $pattern;
43
44		/**
45		* @var string\|array\|\Closure
46		*/
47
48		protected $action;
49
50		/**
51		* @var string
52		*/
53
54		protected $namespace = "";
55
56		/**
57		* @var string[]
58		*/
59
60		protected $params = [];
61
62		/**
63		* Defaults are parameters set by the user, and don't
64		* appear on the pattern.
65		*
66		* @var array
67		*/
68
69		protected $defaults = [];
70
71		/**
72		* Metadata can be set to be used on filters, dispatch strategies
73		* or anywhere the route object is used.
74		*
75		* @var array
76		*/
77
78		protected $metadata = [];
79
80		/**
81		* @var null\|string\|StrategyInterface
82		*/
83
84		protected $strategy;
85
86		/**
87		* Blocked routes are dynamic routes selected to pass by the matcher.
88		*
89		* @var boolean
90		*/
91
92		protected $blocked = false;
93
94		/**
95		* The matcher that dispatched this route.
96		*
97		* @var Matcher $matcher
98		*/
99
100		protected $matcher;
101
102		/**
103		* The function used to create controllers from name.
104		*
105		* @var null\|string\|array\|\Closure
106		*/
107
108		protected $controllerCreationFunction;
109
110		/**
111		* @param Collector $collector
112		* @param string $method
113		* @param string $pattern
114		* @param string\|array\|\Closure $action
115		*/
116
117	28	public function __construct(Collector $collector, $method, $pattern, $action)
118		{
119	28	$this->collector = $collector;
120	28	$this->method = $method;
121	28	$this->pattern = $pattern;
122	28	$this->action = $action;
123	28	}
124
125		/**
126		* Clone this route and set it into the collector.
127		*
128		* @return Route
129		*/
130
131	3	public function reset()
132		{
133	3	return $this->collector->set($this->method, $this->pattern, $this->action)->nth(0)
134	3	->setStrategy($this->strategy)->setParams($this->params)
		0 ignored issues – show Bug introduced 2016-02-09 02:04 UTC by Report Bug Copy Issue Report It seems like `$this->strategy` can also be of type `null`; however, `Codeburner\Router\Route::setStrategy()` does only seem to accept `string\|object<Codeburner...gies\StrategyInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
135	3	->setDefaults($this->defaults)->setMetadataArray($this->metadata);
136		}
137
138		/**
139		* Remove this route from the collector.
140		*
141		* @return self
142		*/
143
144	5	public function forget()
145		{
146	5	$this->collector->forget($this->method, $this->pattern);
147	5	return $this;
148		}
149
150		/**
151		* Blocking a route indicate that that route have been selected and
152		* parsed, now it will be given to the matcher.
153		*
154		* @return self
155		*/
156
157	17	public function block()
158		{
159	17	$this->blocked = true;
160	17	return $this;
161		}
162
163		/**
164		* Verify if a Route have already been blocked.
165		*
166		* @return boolean
167		*/
168
169	17	public function blocked()
170		{
171	17	return $this->blocked;
172		}
173
174		/**
175		* Execute the route action, if no strategy was provided the action
176		* will be executed by the call_user_func PHP function.
177		*
178		* @throws BadRouteException
179		* @return mixed
180		*/
181
182	5	public function call()
183		{
184	5	$this->action = $this->parseCallable($this->action);
185
186	5	if ($this->strategy === null) {
187	5	return call_user_func_array($this->action, array_merge($this->defaults, $this->params));
188		}
189
190		if (!is_object($this->strategy)) {
191		$this->strategy = new $this->strategy;
192		}
193
194		return $this->callWithStrategy();
195		}
196
197		/**
198		* Seek for dynamic content on callables. eg. routes action controller#action
199		* syntax allow to use the variables to build the string like: {controller}@{action}
200		*
201		* @param string\|array\|\Closure $callable
202		* @return string\|array\|\Closure
203		*/
204
205	5	private function parseCallable($callable)
206		{
207	5	if (is_string($callable) && strpos($callable, "@")) {
208	2	$callable = explode("@", $callable);
209	2	}
210
211	5	if (is_array($callable)) {
212	2	if (is_string($callable[0])) {
213	2	$callable[0] = $this->parseCallableController($callable[0]);
214	2	$callable[1] = $this->parseCallablePlaceholders($callable[1]);
215	2	} else $callable[1] = $this->parseCallablePlaceholders($callable[1]);
216	2	}
217
218	5	return $callable;
219		}
220
221		/**
222		* Get the controller object.
223		*
224		* @param string $controller
225		* @return Object
226		*/
227
228	2	private function parseCallableController($controller)
229		{
230	2	$controller = rtrim($this->namespace, "\\") . "\\" . $this->parseCallablePlaceholders($controller);
231
232	2	if ($this->controllerCreationFunction === null) {
233	1	return new $controller;
234	1	} else return call_user_func($this->controllerCreationFunction, $controller);
235		}
236
237		/**
238		* Parse and replace dynamic content on route action.
239		*
240		* @param string $fragment Part of callable
241		* @return string
242		*/
243
244	2	private function parseCallablePlaceholders($fragment)
245		{
246	2	if (strpos($fragment, "{") !== false) {
247		foreach ($this->params as $placeholder => $value) {
248		if (strpos($fragment, "{" . $placeholder . "}") !== false) {
249		$fragment = str_replace("{" . $placeholder . "}", ucwords(str_replace("-", " ", $value)), $fragment);
250		}
251		}
252		}
253
254	2	return $fragment;
255		}
256
257		/**
258		* Execute the route action with the given strategy.
259		*
260		* @throws BadRouteException
261		* @return mixed
262		*/
263
264		private function callWithStrategy()
265		{
266		if ($this->strategy instanceof StrategyInterface) {
267		if ($this->strategy instanceof MatcherAwareInterface) {
268		$this->strategy->setMatcher($this->matcher);
269		}
270
271		return $this->strategy->call($this);
272		}
273
274		throw new BadRouteException("`$this->strategy` is not a valid route dispatch strategy, ".
275		"it must implement the `Codeburner\Router\Strategies\StrategyInterface` interface.");
276		}
277
278		/**
279		* @return Collector
280		*/
281
282		public function getCollector()
283		{
284		return $this->collector;
285		}
286
287		/**
288		* @return string
289		*/
290
291		public function getMethod()
292		{
293		return $this->method;
294		}
295
296		/**
297		* @return string
298		*/
299
300	17	public function getPattern()
301		{
302	17	return $this->pattern;
303		}
304
305		/**
306		* @return string[]
307		*/
308
309		public function getSegments()
310		{
311		return explode("/", $this->pattern);
312		}
313
314		/**
315		* @return string\|array\|\Closure
316		*/
317
318	5	public function getAction()
319		{
320	5	return $this->action;
321		}
322
323		/**
324		* @return string
325		*/
326
327		public function getNamespace()
328		{
329		return $this->namespace;
330		}
331
332		/**
333		* @return string[]
334		*/
335
336	17	public function getParams()
337		{
338	17	return $this->params;
339		}
340
341		/**
342		* @param string $key
343		* @return string
344		*/
345
346		public function getParam($key)
347		{
348		return $this->params[$key];
349		}
350
351		/**
352		* @return array
353		*/
354
355		public function getDefaults()
356		{
357		return $this->defaults;
358		}
359
360		/**
361		* @param string $key
362		* @return mixed
363		*/
364
365		public function getDefault($key)
366		{
367		return $this->defaults[$key];
368		}
369
370		/**
371		* @return array
372		*/
373
374		public function getMetadataArray()
375		{
376		return $this->metadata;
377		}
378
379		/**
380		* @param string $key
381		* @return mixed
382		*/
383
384		public function getMetadata($key)
385		{
386		return $this->metadata[$key];
387		}
388
389		/**
390		* @return string\|null
391		*/
392
393		public function getStrategy()
394		{
395		if ($this->strategy instanceof StrategyInterface) {
396		return get_class($this->strategy);
397		}
398
399		return $this->strategy;
400		}
401
402		/**
403		* @inheritdoc
404		*/
405
406		public function getMatcher()
407		{
408		return $this->matcher;
409		}
410
411		/**
412		* @param string $method
413		* @return Route
414		*/
415
416		public function setMethod($method)
417		{
418		$this->forget();
419		$this->method = $method;
420		return $this->reset();
421		}
422
423		/**
424		* @param string $pattern
425		* @return Route
426		*/
427
428	3	public function setPattern($pattern)
429		{
430	3	$this->forget();
431	3	$this->pattern = $pattern;
432	3	return $this->reset();
433		}
434
435		/**
436		* @param string $pattern
437		* @return self
438		*/
439
440	17	public function setPatternWithoutReset($pattern)
441		{
442	17	$this->pattern = $pattern;
443	17	return $this;
444		}
445
446		/**
447		* @param string $action
448		* @return self
449		*/
450
451		public function setAction($action)
452		{
453		$this->action = $action;
454		return $this;
455		}
456
457		/**
458		* @param string $namespace
459		* @return self
460		*/
461
462		public function setNamespace($namespace)
463		{
464		$this->namespace = $namespace;
465		return $this;
466		}
467
468		/**
469		* @param string[] $params
470		* @return self
471		*/
472
473	17	public function setParams(array $params)
474		{
475	17	$this->params = $params;
476	17	return $this;
477		}
478
479		/**
480		* @param string $key
481		* @param string $value
482		*
483		* @return self
484		*/
485
486		public function setParam($key, $value)
487		{
488		$this->params[$key] = $value;
489		return $this;
490		}
491
492		/**
493		* @param mixed[] $defaults
494		* @return self
495		*/
496
497	3	public function setDefaults(array $defaults)
498		{
499	3	$this->defaults = $defaults;
500	3	return $this;
501		}
502
503		/**
504		* @param string $key
505		* @param mixed $value
506		*
507		* @return self
508		*/
509
510		public function setDefault($key, $value)
511		{
512		$this->defaults[$key] = $value;
513		return $this;
514		}
515
516		/**
517		* @param mixed[] $metadata
518		* @return self
519		*/
520
521	3	public function setMetadataArray(array $metadata)
522		{
523	3	$this->metadata = $metadata;
524	3	return $this;
525		}
526
527		/**
528		* @param string $key
529		* @param mixed $value
530		*
531		* @return $this
532		*/
533
534		public function setMetadata($key, $value)
535		{
536		$this->metadata[$key] = $value;
537		return $this;
538		}
539
540		/**
541		* @param string\|StrategyInterface $strategy
542		* @return self
543		*/
544
545	10	public function setStrategy($strategy)
546		{
547	10	$this->strategy = $strategy;
548	10	return $this;
549		}
550
551		/**
552		* @inheritdoc
553		*/
554
555	15	public function setMatcher(Matcher $matcher)
556		{
557	15	$this->matcher = $matcher;
558	15	}
559
560		/**
561		* Set a function to create controllers.
562		*
563		* @param string\|array\|\Closure $callable
564		* @throws BadRouteException
565		* @return self
566		*/
567
568	1	public function setControllerCreationFunction($callable)
569		{
570	1	if (!is_callable($callable)) {
571		throw new BadRouteException(BadRouteException::WRONG_CONTROLLER_CREATION_FUNC);
572		}
573
574	1	$this->controllerCreationFunction = $this->parseCallable($callable);
575	1	return $this;
576		}
577
578		/**
579		* @param string $key
580		* @return bool
581		*/
582
583		public function hasParam($key)
584		{
585		return isset($this->params[$key]);
586		}
587
588		/**
589		* @param string $key
590		* @return bool
591		*/
592
593		public function hasDefault($key)
594		{
595		return isset($this->defaults[$key]);
596		}
597
598		/**
599		* @param string $key
600		* @return bool
601		*/
602
603		public function hasMetadata($key)
604		{
605		return isset($this->metadata[$key]);
606		}
607
608		}
609

codeburnerframework / routing

Branch — dev (8b2306)

Route::parseCallablePlaceholders() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like