Router::parseRoutePath() - Code Metrics - Inspection of "get and remove route methods" - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#272)

by Derek Stephen

created 2020-02-16 17:53 UTC

Router::parseRoutePath() A

↳ Parent: Router

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php declare(strict_types=1);

namespace League\Route;

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

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

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

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

    /**
     * @var 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 RouteParser $parser
     * @param 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 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 ($this->getStrategy() === null) {
            $this->setStrategy(new ApplicationStrategy);
        }

        $this->prepRoutes($request);

        /** @var Dispatcher $dispatcher */
        $dispatcher = (new Dispatcher($this->getData()))->setStrategy($this->getStrategy());

        foreach ($this->getMiddlewareStack() as $middleware) {
            if (is_string($middleware)) {
                $dispatcher->lazyMiddleware($middleware);
                continue;
            }

            $dispatcher->middleware($middleware);
        }

        return $dispatcher->dispatchRequest($request);
    }

    /**
     * Prepare all routes, build name index and filter out none matching
     * routes before being passed off to the parser.
     *
     * @param 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));

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

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

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

            if ($route->getStrategy() === null) {
                $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 ($route->getName() !== null) {
                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 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 ($group->getStrategy() !== null
                && strncmp($activePath, $group->getPrefix(), strlen($group->getPrefix())) === 0
            ) {
                $this->setStrategy($group->getStrategy());
            }

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

    /**
     * Get a named route
     *
     * @param string $name
     *
     * @return Route
     *
     * @throws InvalidArgumentException when no route of the provided name exists
     */
    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);
    }

    /**
     * @return Route[]
     */
    public function getRoutes(): array
    {
        return $this->routes;
    }

    /**
     * @param Route $route
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function removeRoute(Route $routeToRemove): void
    {
        foreach ($this->routes as $index => $route) {
            if ($route === $routeToRemove) {
                unset($this->routes[$index]);
            }
        }
    }
}


1		<?php declare(strict_types=1);
2
3		namespace League\Route;
4
5		use FastRoute\{DataGenerator, RouteCollector, RouteParser};
6		use InvalidArgumentException;
7		use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
8		use League\Route\Strategy\{ApplicationStrategy, StrategyAwareInterface, StrategyAwareTrait};
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 Route[]
22		*/
23		protected $routes = [];
24
25		/**
26		* @var Route[]
27		*/
28		protected $namedRoutes = [];
29
30		/**
31		* @var 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 RouteParser $parser
50		* @param DataGenerator $generator
51		*/
52	66	public function __construct(?RouteParser $parser = null, ?DataGenerator $generator = null)
53		{
54		// build parent route collector
55	66	$parser = $parser ?? new RouteParser\Std;
56	66	$generator = $generator ?? new DataGenerator\GroupCountBased;
57	66	parent::__construct($parser, $generator);
58	66	}
59
60		/**
61		* {@inheritdoc}
62		*/
63	48	public function map(string $method, string $path, $handler): Route
64		{
65	48	$path = sprintf('/%s', ltrim($path, '/'));
66	48	$route = new Route($method, $path, $handler);
67
68	48	$this->routes[] = $route;
69
70	48	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 RouteGroup
80		*/
81	12	public function group(string $prefix, callable $group): RouteGroup
82		{
83	12	$group = new RouteGroup($prefix, $group, $this);
84	12	$this->groups[] = $group;
85
86	12	return $group;
87		}
88
89		/**
90		* {@inheritdoc}
91		*/
92	48	public function dispatch(ServerRequestInterface $request): ResponseInterface
93		{
94	48	if ($this->getStrategy() === null) {
95	30	$this->setStrategy(new ApplicationStrategy);
96		}
97
98	48	$this->prepRoutes($request);
99
100		/** @var Dispatcher $dispatcher */
101	48	$dispatcher = (new Dispatcher($this->getData()))->setStrategy($this->getStrategy());
102
103	48	foreach ($this->getMiddlewareStack() as $middleware) {
104	3	if (is_string($middleware)) {
105	3	$dispatcher->lazyMiddleware($middleware);
106	3	continue;
107		}
108
109	3	$dispatcher->middleware($middleware);
110		}
111
112	48	return $dispatcher->dispatchRequest($request);
113		}
114
115		/**
116		* Prepare all routes, build name index and filter out none matching
117		* routes before being passed off to the parser.
118		*
119		* @param ServerRequestInterface $request
120		*
121		* @return void
122		*/
123	48	protected function prepRoutes(ServerRequestInterface $request): void
124		{
125	48	$this->processGroups($request);
126	48	$this->buildNameIndex();
127
128	48	$routes = array_merge(array_values($this->routes), array_values($this->namedRoutes));
129
130		/** @var Route $route */
131	48	foreach ($routes as $key => $route) {
132		// check for scheme condition
133	39	$scheme = $route->getScheme();
134	39	if ($scheme !== null && $scheme !== $request->getUri()->getScheme()) {
135	3	continue;
136		}
137
138		// check for domain condition
139	36	$host = $route->getHost();
140	36	if ($host !== null && $host !== $request->getUri()->getHost()) {
141	3	continue;
142		}
143
144		// check for port condition
145	33	$port = $route->getPort();
146	33	if ($port !== null && $port !== $request->getUri()->getPort()) {
147	3	continue;
148		}
149
150	30	if ($route->getStrategy() === null) {
151	21	$route->setStrategy($this->getStrategy());
152		}
153
154	30	$this->addRoute($route->getMethod(), $this->parseRoutePath($route->getPath()), $route);
155		}
156	48	}
157
158		/**
159		* Build an index of named routes.
160		*
161		* @return void
162		*/
163	54	protected function buildNameIndex(): void
164		{
165	54	foreach ($this->routes as $key => $route) {
166	42	if ($route->getName() !== null) {
167	3	unset($this->routes[$key]);
168	16	$this->namedRoutes[$route->getName()] = $route;
169		}
170		}
171	54	}
172
173		/**
174		* Process all groups
175		*
176		* Adds all of the group routes to the collection and determines if the group
177		* strategy should be be used.
178		*
179		* @param ServerRequestInterface $request
180		*
181		* @return void
182		*/
183	48	protected function processGroups(ServerRequestInterface $request): void
184		{
185	48	$activePath = $request->getUri()->getPath();
186
187	48	foreach ($this->groups as $key => $group) {
188		// we want to determine if we are technically in a group even if the
189		// route is not matched so exceptions are handled correctly
190	9	if ($group->getStrategy() !== null
191	9	&& strncmp($activePath, $group->getPrefix(), strlen($group->getPrefix())) === 0
192		) {
193	6	$this->setStrategy($group->getStrategy());
194		}
195
196	9	unset($this->groups[$key]);
197	9	$group();
198		}
199	48	}
200
201		/**
202		* Get a named route
203		*
204		* @param string $name
205		*
206		* @return Route
207		*
208		* @throws InvalidArgumentException when no route of the provided name exists
209		*/
210	6	public function getNamedRoute(string $name): Route
211		{
212	6	$this->buildNameIndex();
213
214	6	if (isset($this->namedRoutes[$name])) {
215	3	return $this->namedRoutes[$name];
216		}
217
218	3	throw new InvalidArgumentException(sprintf('No route of the name (%s) exists', $name));
219		}
220
221		/**
222		* Add a convenient pattern matcher to the internal array for use with all routes
223		*
224		* @param string $alias
225		* @param string $regex
226		*
227		* @return self
228		*/
229	3	public function addPatternMatcher(string $alias, string $regex): self
230		{
231	3	$pattern = '/{(.+?):' . $alias . '}/';
232	3	$regex = '{$1:' . $regex . '}';
233
234	3	$this->patternMatchers[$pattern] = $regex;
235
236	3	return $this;
237		}
238
239		/**
240		* Replace word patterns with regex in route path
241		*
242		* @param string $path
243		*
244		* @return string
245		*/
246	30	protected function parseRoutePath(string $path): string
247		{
248	30	return preg_replace(array_keys($this->patternMatchers), array_values($this->patternMatchers), $path);
249		}
250
251		/**
252		* @return Route[]
253		*/
254	3	public function getRoutes(): array
255		{
256	3	return $this->routes;
257		}
258
259		/**
260		* @param Route $route
		0 ignored issues – show Bug introduced 2020-02-16 18:04 UTC by Report Bug Copy Issue Report There is no parameter named `$route`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
261		*/
262	3	public function removeRoute(Route $routeToRemove): void
263		{
264	3	foreach ($this->routes as $index => $route) {
265	3	if ($route === $routeToRemove) {
266	3	unset($this->routes[$index]);
267		}
268		}
269	3	}
270		}
271

thephpleague / route

Pull Request — master (#272)

Router::parseRoutePath() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like