Regex::transformRoute() - Code Metrics - Inspection of "Add master branch of php for the testing" - kambo-1st/KamboRouter - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Branch — develop (ab83c3)

by Bohuslav

created 2017-05-28 10:44 UTC

Regex::transformRoute() B

↳ Parent: Regex

Complexity

Conditions	4
Paths	2

Size

Total Lines	26
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	26
c	0
b	0
f	0
rs	8.5806
cc	4
eloc	17
nc	2
nop	1

<?php

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($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($method, $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($urlFormat)
    {
        if (RouteMode::inEnum($urlFormat)) {
            $this->urlFormat = $urlFormat;
        } else {
            throw new InvalidArgumentException(
                'Value of urlFormat must be from RouteMode enum.'
            );
        }

        return $this;
    }

    /**
     * Get format for URL resolving.
     *
     * @return string value from RouteMode enum
     */
    public function getUrlFormat()
    {
        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($method, $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($routeRegex, $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)
    {
        $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)
    {
        if ($this->urlFormat === RouteMode::PATH_FORMAT) {
            $path = $request->getUri()->getPath();
        } else {
            $queryParams = $request->getQueryParams();
            $route       = null;
            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($route)
    {
        $parameters = $this->extractVariableRouteParts($route);
        if (isset($parameters)) {
            foreach ($parameters as $variables) {
                list($valueToReplace, , $parametersVariables) = array_pad(
                    $variables,
                    3,
                    null
                );
                if (isset($parametersVariables)) {
                    $route = str_replace(
                        $valueToReplace,
                        '('.reset($parametersVariables).')',
                        $route
                    );
                } else {
                    $route = str_replace($valueToReplace, '([^/]+)', $route);
                }
            }
        }

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

        return [$route, $parameters];
    }

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

        return $matches;
    }
}


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

kambo-1st / KamboRouter

Branch — develop (ab83c3)

Regex::transformRoute() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like