Regex::getMatchRoute() - Code Metrics - Inspection of "Merge develop branch (#1)" - kambo-1st/KamboRouter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a71966...32ad63 )

by Bohuslav

created 2017-07-06 17:10 UTC

Regex::getMatchRoute() B

↳ Parent: Regex

Complexity

Conditions	5
Paths	4

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	0
cts	11
cp	0
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	11
nc	4
nop	2
crap	30

<?php
declare(strict_types=1);

namespace Kambo\Router\Matcher;

// \spl
use InvalidArgumentException;

// \Psr\Http\Message
use Psr\Http\Message\ServerRequestInterface as ServerRequest;

// \Kambo\Router
use Kambo\Router\Matcher;

// \Kambo\Router\Route
use Kambo\Router\Route\Collection;
use Kambo\Router\Route\Route\Parsed;

// \Kambo\Router\Enum
use Kambo\Router\Enum\Method;
use Kambo\Router\Enum\RouteMode;

/**
 * Match provided request object with all defined routes in route collection
 * using regular expresions. If some of routes match a data in provided request
 * An instance of matched route is returned. If nothing is matched false value
 * is returned.
 *
 * @package Kambo\Router\Matcher
 * @author  Bohuslav Simek <[email protected]>
 * @license MIT
 */
class Regex implements Matcher
{
    /**
     * Regex for getting URL variables
     *
     * @var string
     */
    const VARIABLE_REGEX =
        "~\{
            \s* ([a-zA-Z0-9_]*) \s*
            (?:
                : \s* ([^{]+(?:\{.*?\})?)
            )?
        \}\??~x";

    /**
     * Shortcuts for regex.
     *
     * @var array
     */
    private $regexShortcuts = [
        ':i}'  => ':[0-9]+}',
        ':a}'  => ':[0-9A-Za-z]+}',
        ':h}'  => ':[0-9A-Fa-f]+}',
        ':c}'  => ':[a-zA-Z0-9+_\-\.]+}'
    ];

    /**
     * Flag for enabling support of mode rewrite.
     *
     * @var string
     */
    private $urlFormat = RouteMode::PATH_FORMAT;

    /**
     * Name of GET parameter from which the route will be get
     * if url format is set to GET_FORMAT.
     *
     * @var string
     */
    private $modeRewriteParameter = 'r';

    /**
     * Instance of route collection
     *
     * @var \Kambo\Router\Route\Collection
     */
    private $routeCollection;

    /**
     * Constructor
     *
     * @param \Kambo\Router\Route\Collection $routeCollection
     *
     */
    public function __construct(
        Collection $routeCollection
    ) {
        $this->routeCollection = $routeCollection;
    }

    /**
     * Match request with provided routes.
     * Get method and url from provided request and start matching.
     *
     * @param ServerRequest $request instance of PSR 7 compatible request object
     *
     * @return mixed
     */
    public function matchRequest(ServerRequest $request)
    {
        return $this->getMatchRoute(
            $request->getMethod(),
            $this->getUrl($request)
        );
    }

    /**
     * Match url and method with provided routes.
     *
     * @param string $method http method
     * @param string $url    url
     *
     * @return mixed
     */
    public function matchPathAndMethod(string $method, string $url)
    {
        return $this->getMatchRoute($method, $url);
    }

    /**
     * Set format for URL resolving.
     * If the path mode is set to a path a web server must be properly
     * configurated, defualt value is PATH_FORMAT.
     *
     * @param string $urlFormat value from RouteMode enum
     *
     * @return self for fluent interface
     */
    public function setUrlFormat(string $urlFormat) : Matcher
    {
        if (RouteMode::inEnum($urlFormat)) {
            $this->urlFormat = $urlFormat;

            return $this;
        }

        throw new InvalidArgumentException(
            'Value of urlFormat must be from RouteMode enum.'
        );
    }

    /**
     * Get format for URL resolving.
     *
     * @return string value from RouteMode enum
     */
    public function getUrlFormat() : string
    {
        return $this->urlFormat;
    }

    // ------------ PRIVATE METHODS

    /**
     * Match method and route with provided routes.
     * If route and method match a route is dispatch using provided dispatcher.
     *
     * @param string $method http method
     * @param string $url    url
     *
     * @return mixed
     */
    private function getMatchRoute(string $method, string $url)
    {
        $parsedRoutes = $this->parseRoutes($this->routeCollection);
        foreach ($parsedRoutes as $singleParsedRoute) {
            list($routeRegex, $route) = $singleParsedRoute;
            $matchedParameters        = $this->routeMatch($routeRegex, $url);

            if ($matchedParameters !== false) {
                $routeMethod = $route->getMethod();
                if ($routeMethod === $method || $routeMethod === Method::ANY) {
                    $route->setParameters($matchedParameters);

                    return $route;
                }
            }
        }

        return false;
    }

    /**
     * Match route by provided regex.
     *
     * @param string $routeRegex
     * @param string $route
     *
     * @return mixed
     */
    private function routeMatch(string $routeRegex, string $route)
    {
        $matches = [];
        if (preg_match($routeRegex, $route, $matches)) {
            unset($matches[0]);

            return array_values($matches);
        }

        return false;
    }

    /**
     * Prepare regex and parameters for each of routes.
     *
     * @param array $routes array with instances of route object
     *
     * @return array transformed routes
     */
    private function parseRoutes(Collection $routes) : array
    {
        $parsedRoutes = [];
        foreach ($routes as $route) {
            $routeUrl = strtr($route->getUrl(), $this->regexShortcuts);

            list($routeRegex, $parameters) = $this->transformRoute($routeUrl);

            $parsedRoute = new Parsed($route);
            $parsedRoute->setPlaceholders($parameters);

            $parsedRoutes[] = [$routeRegex, $parsedRoute];
        }

        return $parsedRoutes;
    }

    /**
     * Get route from request object.
     * Method expect an instance of PSR 7 compatible request object.
     *
     * @param object $request
     *
     * @return string
     */
    private function getUrl($request) : string
    {
        if ($this->urlFormat === RouteMode::PATH_FORMAT) {
            return $request->getUri()->getPath();
        }

        $queryParams = $request->getQueryParams();
        $route       = '';

        if (isset($queryParams[$this->modeRewriteParameter])) {
            $route = $queryParams[$this->modeRewriteParameter];
        }

        $path = '/'.$route;

        return $path;
    }

    /**
     * Prepare regex for resolving route a extract variables from route.
     *
     * @param string $route
     *
     * @return array regex and parameters
     */
    private function transformRoute(string $route) : array
    {
        $parameters = $this->extractVariableRouteParts($route);
        foreach ($parameters as $variables) {
            $route = $this->transformRouteVariables($route, $variables);
        }

        $route = '~^'.$route.'$~';

        return [$route, $parameters];
    }

    /**
     * Prepare regex for resolving route a extract variables from route.
     *
     * @param string $route     Route
     * @param array  $variables Variables
     *
     * @return string Transformed route
     */
    private function transformRouteVariables(string $route, array $variables) : string
    {
        list($valueToReplace, , $parametersVariables) = array_pad(
            $variables,
            3,
            null
        );

        if (isset($parametersVariables)) {
            return str_replace(
                $valueToReplace,
                '('.reset($parametersVariables).')',
                $route
            );
        }

        return str_replace($valueToReplace, '([^/]+)', $route);
    }

    /**
     * Extract variables from the route
     *
     * @param string $route
     *
     * @return array
     */
    private function extractVariableRouteParts(string $route) : array
    {
        $matches = [];
        preg_match_all(
            self::VARIABLE_REGEX,
            $route,
            $matches,
            PREG_OFFSET_CAPTURE | PREG_SET_ORDER
        );

        return $matches;
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Kambo\Router\Matcher;
5
6			// \spl
7			use InvalidArgumentException;
8
9			// \Psr\Http\Message
10			use Psr\Http\Message\ServerRequestInterface as ServerRequest;
11
12			// \Kambo\Router
13			use Kambo\Router\Matcher;
14
15			// \Kambo\Router\Route
16			use Kambo\Router\Route\Collection;
17			use Kambo\Router\Route\Route\Parsed;
18
19			// \Kambo\Router\Enum
20			use Kambo\Router\Enum\Method;
21			use Kambo\Router\Enum\RouteMode;
22
23			/**
24			* Match provided request object with all defined routes in route collection
25			* using regular expresions. If some of routes match a data in provided request
26			* An instance of matched route is returned. If nothing is matched false value
27			* is returned.
28			*
29			* @package Kambo\Router\Matcher
30			* @author Bohuslav Simek <[email protected]>
31			* @license MIT
32			*/
33			class Regex implements Matcher
34			{
35			/**
36			* Regex for getting URL variables
37			*
38			* @var string
39			*/
40			const VARIABLE_REGEX =
41			"~\{
42			\s* ([a-zA-Z0-9_]) \s
43			(?:
44			: \s* ([^{]+(?:\{.*?\})?)
45			)?
46			\}\??~x";
47
48			/**
49			* Shortcuts for regex.
50			*
51			* @var array
52			*/
53			private $regexShortcuts = [
54			':i}' => ':[0-9]+}',
55			':a}' => ':[0-9A-Za-z]+}',
56			':h}' => ':[0-9A-Fa-f]+}',
57			':c}' => ':[a-zA-Z0-9+_\-\.]+}'
58			];
59
60			/**
61			* Flag for enabling support of mode rewrite.
62			*
63			* @var string
64			*/
65			private $urlFormat = RouteMode::PATH_FORMAT;
66
67			/**
68			* Name of GET parameter from which the route will be get
69			* if url format is set to GET_FORMAT.
70			*
71			* @var string
72			*/
73			private $modeRewriteParameter = 'r';
74
75			/**
76			* Instance of route collection
77			*
78			* @var \Kambo\Router\Route\Collection
79			*/
80			private $routeCollection;
81
82			/**
83			* Constructor
84			*
85			* @param \Kambo\Router\Route\Collection $routeCollection
86			*
87			*/
88			public function __construct(
89			Collection $routeCollection
90			) {
91			$this->routeCollection = $routeCollection;
92			}
93
94			/**
95			* Match request with provided routes.
96			* Get method and url from provided request and start matching.
97			*
98			* @param ServerRequest $request instance of PSR 7 compatible request object
99			*
100			* @return mixed
101			*/
102			public function matchRequest(ServerRequest $request)
103			{
104			return $this->getMatchRoute(
105			$request->getMethod(),
106			$this->getUrl($request)
107			);
108			}
109
110			/**
111			* Match url and method with provided routes.
112			*
113			* @param string $method http method
114			* @param string $url url
115			*
116			* @return mixed
117			*/
118			public function matchPathAndMethod(string $method, string $url)
119			{
120			return $this->getMatchRoute($method, $url);
121			}
122
123			/**
124			* Set format for URL resolving.
125			* If the path mode is set to a path a web server must be properly
126			* configurated, defualt value is PATH_FORMAT.
127			*
128			* @param string $urlFormat value from RouteMode enum
129			*
130			* @return self for fluent interface
131			*/
132			public function setUrlFormat(string $urlFormat) : Matcher
133			{
134			if (RouteMode::inEnum($urlFormat)) {
135			$this->urlFormat = $urlFormat;
136
137			return $this;
138			}
139
140			throw new InvalidArgumentException(
141			'Value of urlFormat must be from RouteMode enum.'
142			);
143			}
144
145			/**
146			* Get format for URL resolving.
147			*
148			* @return string value from RouteMode enum
149			*/
150			public function getUrlFormat() : string
151			{
152			return $this->urlFormat;
153			}
154
155			// ------------ PRIVATE METHODS
156
157			/**
158			* Match method and route with provided routes.
159			* If route and method match a route is dispatch using provided dispatcher.
160			*
161			* @param string $method http method
162			* @param string $url url
163			*
164			* @return mixed
165			*/
166			private function getMatchRoute(string $method, string $url)
167			{
168			$parsedRoutes = $this->parseRoutes($this->routeCollection);
169			foreach ($parsedRoutes as $singleParsedRoute) {
170			list($routeRegex, $route) = $singleParsedRoute;
171			$matchedParameters = $this->routeMatch($routeRegex, $url);
172
173			if ($matchedParameters !== false) {
174			$routeMethod = $route->getMethod();
175			if ($routeMethod === $method \|\| $routeMethod === Method::ANY) {
176			$route->setParameters($matchedParameters);
177
178			return $route;
179			}
180			}
181			}
182
183			return false;
184			}
185
186			/**
187			* Match route by provided regex.
188			*
189			* @param string $routeRegex
190			* @param string $route
191			*
192			* @return mixed
193			*/
194			private function routeMatch(string $routeRegex, string $route)
195			{
196			$matches = [];
197			if (preg_match($routeRegex, $route, $matches)) {
198			unset($matches[0]);
199
200			return array_values($matches);
201			}
202
203			return false;
204			}
205
206			/**
207			* Prepare regex and parameters for each of routes.
208			*
209			* @param array $routes array with instances of route object
210			*
211			* @return array transformed routes
212			*/
213			private function parseRoutes(Collection $routes) : array
214			{
215			$parsedRoutes = [];
216			foreach ($routes as $route) {
217			$routeUrl = strtr($route->getUrl(), $this->regexShortcuts);
218
219			list($routeRegex, $parameters) = $this->transformRoute($routeUrl);
220
221			$parsedRoute = new Parsed($route);
222			$parsedRoute->setPlaceholders($parameters);
223
224			$parsedRoutes[] = [$routeRegex, $parsedRoute];
225			}
226
227			return $parsedRoutes;
228			}
229
230			/**
231			* Get route from request object.
232			* Method expect an instance of PSR 7 compatible request object.
233			*
234			* @param object $request
235			*
236			* @return string
237			*/
238			private function getUrl($request) : string
239			{
240			if ($this->urlFormat === RouteMode::PATH_FORMAT) {
241			return $request->getUri()->getPath();
242			}
243
244			$queryParams = $request->getQueryParams();
245			$route = '';
246
247			if (isset($queryParams[$this->modeRewriteParameter])) {
248			$route = $queryParams[$this->modeRewriteParameter];
249			}
250
251			$path = '/'.$route;
252
253			return $path;
254			}
255
256			/**
257			* Prepare regex for resolving route a extract variables from route.
258			*
259			* @param string $route
260			*
261			* @return array regex and parameters
262			*/
263			private function transformRoute(string $route) : array
264			{
265			$parameters = $this->extractVariableRouteParts($route);
266			foreach ($parameters as $variables) {
267			$route = $this->transformRouteVariables($route, $variables);
268			}
269
270			$route = '~^'.$route.'$~';
271
272			return [$route, $parameters];
273			}
274
275			/**
276			* Prepare regex for resolving route a extract variables from route.
277			*
278			* @param string $route Route
279			* @param array $variables Variables
280			*
281			* @return string Transformed route
282			*/
283			private function transformRouteVariables(string $route, array $variables) : string
284			{
285			list($valueToReplace, , $parametersVariables) = array_pad(
286			$variables,
287			3,
288			null
289			);
290
291			if (isset($parametersVariables)) {
292			return str_replace(
293			$valueToReplace,
294			'('.reset($parametersVariables).')',
295			$route
296			);
297			}
298
299			return str_replace($valueToReplace, '([^/]+)', $route);
300			}
301
302			/**
303			* Extract variables from the route
304			*
305			* @param string $route
306			*
307			* @return array
308			*/
309			private function extractVariableRouteParts(string $route) : array
310			{
311			$matches = [];
312			preg_match_all(
313			self::VARIABLE_REGEX,
314			$route,
315			$matches,
316			PREG_OFFSET_CAPTURE \| PREG_SET_ORDER
317			);
318
319			return $matches;
320			}
321			}
322

kambo-1st / KamboRouter

Push — master ( a71966...32ad63 )

Regex::getMatchRoute() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like