Router::__construct() - Code Metrics - Inspection of "Merge pull request #210 from shadowhand/feature/ad..." - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b3457c...c694d9 )

by Phil

created 2018-10-10 14:30 UTC

Router::__construct() A

↳ Parent: Router

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	5
cts	5
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	1

<?php declare(strict_types=1);

namespace League\Route;

use InvalidArgumentException;
use FastRoute\{DataGenerator, RouteCollector, RouteParser};
use League\Route\Strategy\{ApplicationStrategy, StrategyAwareInterface, StrategyAwareTrait};
use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};

class Router extends RouteCollector implements
    MiddlewareAwareInterface,
    RouteCollectionInterface,
    StrategyAwareInterface
{
    use MiddlewareAwareTrait;
    use RouteCollectionTrait;
    use StrategyAwareTrait;

    /**
     * @var \League\Route\Route[]
     */
    protected $routes = [];

    /**
     * @var \League\Route\Route[]
     */
    protected $namedRoutes = [];

    /**
     * @var \League\Route\RouteGroup[]
     */
    protected $groups = [];

    /**
     * @var array
     */
    protected $patternMatchers = [
        '/{(.+?):number}/'        => '{$1:[0-9]+}',
        '/{(.+?):word}/'          => '{$1:[a-zA-Z]+}',
        '/{(.+?):alphanum_dash}/' => '{$1:[a-zA-Z0-9-_]+}',
        '/{(.+?):slug}/'          => '{$1:[a-z0-9-]+}',
        '/{(.+?):uuid}/'          => '{$1:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}+}'
    ];

    /**
     * Constructor
     *
     * @param \FastRoute\RouteParser   $parser
     * @param \FastRoute\DataGenerator $generator
     */
    public function __construct(?RouteParser $parser = null, ?DataGenerator $generator = null)
    {
        // build parent route collector
        $parser    = ($parser) ?? new RouteParser\Std;
        $generator = ($generator) ?? new DataGenerator\GroupCountBased;
        parent::__construct($parser, $generator);
    }

    /**
     * {@inheritdoc}
     */
    public function map(string $method, string $path, $handler) : Route
    {
        $path  = sprintf('/%s', ltrim($path, '/'));
        $route = new Route($method, $path, $handler);

        $this->routes[] = $route;

        return $route;
    }

    /**
     * Add a group of routes to the collection
     *
     * @param string   $prefix
     * @param callable $group
     *
     * @return \League\Route\RouteGroup
     */
    public function group(string $prefix, callable $group) : RouteGroup
    {
        $group          = new RouteGroup($prefix, $group, $this);
        $this->groups[] = $group;

        return $group;
    }

    /**
     * {@inheritdoc}
     */
    public function dispatch(ServerRequestInterface $request) : ResponseInterface
    {
        if (is_null($this->getStrategy())) {
            $this->setStrategy(new ApplicationStrategy);
        }

        $this->prepRoutes($request);

        return (new Dispatcher($this->getData()))
            ->middlewares($this->getMiddlewareStack())
            ->setStrategy($this->getStrategy())
            ->dispatchRequest($request)
        ;
    }

    /**
     * Prepare all routes, build name index and filter out none matching
     * routes before being passed off to the parser.
     *
     * @param \Psr\Http\Message\ServerRequestInterface $request
     *
     * @return void
     */
    protected function prepRoutes(ServerRequestInterface $request) : void
    {
        $this->processGroups($request);
        $this->buildNameIndex();

        $routes = array_merge(array_values($this->routes), array_values($this->namedRoutes));

        foreach ($routes as $key => $route) {
            // check for scheme condition
            if (! is_null($route->getScheme()) && $route->getScheme() !== $request->getUri()->getScheme()) {
                continue;
            }

            // check for domain condition
            if (! is_null($route->getHost()) && $route->getHost() !== $request->getUri()->getHost()) {
                continue;
            }

            // check for port condition
            if (! is_null($route->getPort()) && $route->getPort() !== $request->getUri()->getPort()) {
                continue;
            }

            if (is_null($route->getStrategy())) {
                $route->setStrategy($this->getStrategy());
            }

            $this->addRoute($route->getMethod(), $this->parseRoutePath($route->getPath()), $route);
        }
    }

    /**
     * Build an index of named routes.
     *
     * @return void
     */
    protected function buildNameIndex() : void
    {
        foreach ($this->routes as $key => $route) {
            if (! is_null($route->getName())) {

                unset($this->routes[$key]);
                $this->namedRoutes[$route->getName()] = $route;

            }
        }
    }

    /**
     * Process all groups
     *
     * Adds all of the group routes to the collection and determines if the group
     * strategy should be be used.
     *
     * @param \Psr\Http\Message\ServerRequestInterface $request
     *
     * @return void
     */
    protected function processGroups(ServerRequestInterface $request) : void
    {
        $activePath = $request->getUri()->getPath();

        foreach ($this->groups as $key => $group) {
            // we want to determine if we are technically in a group even if the
            // route is not matched so exceptions are handled correctly
            if (strncmp($activePath, $group->getPrefix(), strlen($group->getPrefix())) === 0
                && ! is_null($group->getStrategy())
            ) {
                $this->setStrategy($group->getStrategy());
            }

            unset($this->groups[$key]);
            $group();
        }
    }

    /**
     * Get a named route
     *
     * @param string $name
     *
     * @throws \InvalidArgumentException when no route of the provided name exists.
     *
     * @return \League\Route\Route
     */
    public function getNamedRoute(string $name) : Route
    {
        $this->buildNameIndex();

        if (isset($this->namedRoutes[$name])) {
            return $this->namedRoutes[$name];
        }

        throw new InvalidArgumentException(sprintf('No route of the name (%s) exists', $name));
    }

    /**
     * Add a convenient pattern matcher to the internal array for use with all routes
     *
     * @param string $alias
     * @param string $regex
     *
     * @return self
     */
    public function addPatternMatcher(string $alias, string $regex) : self
    {
        $pattern = '/{(.+?):' . $alias . '}/';
        $regex   = '{$1:' . $regex . '}';

        $this->patternMatchers[$pattern] = $regex;

        return $this;
    }

    /**
     * Replace word patterns with regex in route path
     *
     * @param string $path
     *
     * @return string
     */
    protected function parseRoutePath(string $path) : string
    {
        return preg_replace(array_keys($this->patternMatchers), array_values($this->patternMatchers), $path);
    }
}


1		<?php declare(strict_types=1);
2
3		namespace League\Route;
4
5		use InvalidArgumentException;
6		use FastRoute\{DataGenerator, RouteCollector, RouteParser};
7		use League\Route\Strategy\{ApplicationStrategy, StrategyAwareInterface, StrategyAwareTrait};
8		use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
9		use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
10
11		class Router extends RouteCollector implements
12		MiddlewareAwareInterface,
13		RouteCollectionInterface,
14		StrategyAwareInterface
15		{
16		use MiddlewareAwareTrait;
17		use RouteCollectionTrait;
18		use StrategyAwareTrait;
19
20		/**
21		* @var \League\Route\Route[]
22		*/
23		protected $routes = [];
24
25		/**
26		* @var \League\Route\Route[]
27		*/
28		protected $namedRoutes = [];
29
30		/**
31		* @var \League\Route\RouteGroup[]
32		*/
33		protected $groups = [];
34
35		/**
36		* @var array
37		*/
38		protected $patternMatchers = [
39		'/{(.+?):number}/' => '{$1:[0-9]+}',
40		'/{(.+?):word}/' => '{$1:[a-zA-Z]+}',
41		'/{(.+?):alphanum_dash}/' => '{$1:[a-zA-Z0-9-_]+}',
42		'/{(.+?):slug}/' => '{$1:[a-z0-9-]+}',
43		'/{(.+?):uuid}/' => '{$1:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}+}'
44		];
45
46		/**
47		* Constructor
48		*
49		* @param \FastRoute\RouteParser $parser
50		* @param \FastRoute\DataGenerator $generator
51		*/
52	40	public function __construct(?RouteParser $parser = null, ?DataGenerator $generator = null)
53		{
54		// build parent route collector
55	40	$parser = ($parser) ?? new RouteParser\Std;
56	40	$generator = ($generator) ?? new DataGenerator\GroupCountBased;
57	40	parent::__construct($parser, $generator);
58	40	}
59
60		/**
61		* {@inheritdoc}
62		*/
63	30	public function map(string $method, string $path, $handler) : Route
64		{
65	30	$path = sprintf('/%s', ltrim($path, '/'));
66	30	$route = new Route($method, $path, $handler);
67
68	30	$this->routes[] = $route;
69
70	30	return $route;
71		}
72
73		/**
74		* Add a group of routes to the collection
75		*
76		* @param string $prefix
77		* @param callable $group
78		*
79		* @return \League\Route\RouteGroup
80		*/
81	8	public function group(string $prefix, callable $group) : RouteGroup
82		{
83	8	$group = new RouteGroup($prefix, $group, $this);
84	8	$this->groups[] = $group;
85
86	8	return $group;
87		}
88
89		/**
90		* {@inheritdoc}
91		*/
92	30	public function dispatch(ServerRequestInterface $request) : ResponseInterface
93		{
94	30	if (is_null($this->getStrategy())) {
95	18	$this->setStrategy(new ApplicationStrategy);
96		}
97
98	30	$this->prepRoutes($request);
99
100	30	return (new Dispatcher($this->getData()))
101	30	->middlewares($this->getMiddlewareStack())
102	30	->setStrategy($this->getStrategy())
103	30	->dispatchRequest($request)
104		;
105		}
106
107		/**
108		* Prepare all routes, build name index and filter out none matching
109		* routes before being passed off to the parser.
110		*
111		* @param \Psr\Http\Message\ServerRequestInterface $request
112		*
113		* @return void
114		*/
115	30	protected function prepRoutes(ServerRequestInterface $request) : void
116		{
117	30	$this->processGroups($request);
118	30	$this->buildNameIndex();
119
120	30	$routes = array_merge(array_values($this->routes), array_values($this->namedRoutes));
121
122	30	foreach ($routes as $key => $route) {
123		// check for scheme condition
124	26	if (! is_null($route->getScheme()) && $route->getScheme() !== $request->getUri()->getScheme()) {
125	2	continue;
126		}
127
128		// check for domain condition
129	24	if (! is_null($route->getHost()) && $route->getHost() !== $request->getUri()->getHost()) {
130	2	continue;
131		}
132
133		// check for port condition
134	22	if (! is_null($route->getPort()) && $route->getPort() !== $request->getUri()->getPort()) {
135	2	continue;
136		}
137
138	20	if (is_null($route->getStrategy())) {
139	14	$route->setStrategy($this->getStrategy());
140		}
141
142	20	$this->addRoute($route->getMethod(), $this->parseRoutePath($route->getPath()), $route);
143		}
144	30	}
145
146		/**
147		* Build an index of named routes.
148		*
149		* @return void
150		*/
151	34	protected function buildNameIndex() : void
152		{
153	34	foreach ($this->routes as $key => $route) {
154	28	if (! is_null($route->getName())) {
		1 ignored issue – show Bug introduced 2018-10-10 14:33 UTC by Report Bug Copy Issue Report Consider using `$route->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
155	2	unset($this->routes[$key]);
156	28	$this->namedRoutes[$route->getName()] = $route;
		1 ignored issue – show Bug introduced 2018-10-10 14:33 UTC by Report Bug Copy Issue Report Consider using `$route->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
157		}
158		}
159	34	}
160
161		/**
162		* Process all groups
163		*
164		* Adds all of the group routes to the collection and determines if the group
165		* strategy should be be used.
166		*
167		* @param \Psr\Http\Message\ServerRequestInterface $request
168		*
169		* @return void
170		*/
171	30	protected function processGroups(ServerRequestInterface $request) : void
172		{
173	30	$activePath = $request->getUri()->getPath();
174
175	30	foreach ($this->groups as $key => $group) {
176		// we want to determine if we are technically in a group even if the
177		// route is not matched so exceptions are handled correctly
178	6	if (strncmp($activePath, $group->getPrefix(), strlen($group->getPrefix())) === 0
179	6	&& ! is_null($group->getStrategy())
180		) {
181	4	$this->setStrategy($group->getStrategy());
182		}
183
184	6	unset($this->groups[$key]);
185	6	$group();
186		}
187	30	}
188
189		/**
190		* Get a named route
191		*
192		* @param string $name
193		*
194		* @throws \InvalidArgumentException when no route of the provided name exists.
195		*
196		* @return \League\Route\Route
197		*/
198	4	public function getNamedRoute(string $name) : Route
199		{
200	4	$this->buildNameIndex();
201
202	4	if (isset($this->namedRoutes[$name])) {
203	2	return $this->namedRoutes[$name];
204		}
205
206	2	throw new InvalidArgumentException(sprintf('No route of the name (%s) exists', $name));
207		}
208
209		/**
210		* Add a convenient pattern matcher to the internal array for use with all routes
211		*
212		* @param string $alias
213		* @param string $regex
214		*
215		* @return self
216		*/
217	2	public function addPatternMatcher(string $alias, string $regex) : self
218		{
219	2	$pattern = '/{(.+?):' . $alias . '}/';
220	2	$regex = '{$1:' . $regex . '}';
221
222	2	$this->patternMatchers[$pattern] = $regex;
223
224	2	return $this;
225		}
226
227		/**
228		* Replace word patterns with regex in route path
229		*
230		* @param string $path
231		*
232		* @return string
233		*/
234	20	protected function parseRoutePath(string $path) : string
235		{
236	20	return preg_replace(array_keys($this->patternMatchers), array_values($this->patternMatchers), $path);
237		}
238		}
239

thephpleague / route

Push — master ( b3457c...c694d9 )

Router::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like