DataTrait::hasMethod() - Code Metrics - Inspection of "Improved route match performance" - divineniiquaye/flight-routing - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Retried Inspection

Push — master ( f6c0fb...d5e0ae )

by Divine Niiquaye

created 2022-04-13 21:02 UTC

DataTrait::hasMethod() A

↳ Parent: DataTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

/*
 * This file is part of Flight Routing.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Flight\Routing\Traits;

use Flight\Routing\Exceptions\{InvalidControllerException, UriHandlerException};
use Flight\Routing\Route;
use Flight\Routing\Handlers\ResourceHandler;

trait DataTrait
{
    /** @var array<string,mixed> */
    protected array $data;

    /**
     * Sets the route path prefix.
     *
     * @return $this
     */
    public function prefix(string $path)
    {
        if (!empty($path)) {
            $uri = $this->data['path'] ?? '/';

            if (\strlen($uri) > 1 && isset(Route::URL_PREFIX_SLASHES[$uri[1]])) {
                $uri = \substr($uri, 1);
            }

            if (isset(Route::URL_PREFIX_SLASHES[$path[-1]])) {
                $uri = \substr($uri, 1);
            }

            \preg_match(Route::PRIORITY_REGEX, $this->data['path'] = ('/' . \ltrim($path, '/')) . $uri, $pM);
            $this->data['prefix'] = !empty($pM[1] ?? null) ? $pM[1] : null;
        }

        return $this;
    }

    /**
     * Sets the route path pattern.
     *
     * @return $this
     */
    public function path(string $pattern)
    {
        if (\preg_match(Route::RCA_PATTERN, $pattern, $matches, \PREG_UNMATCHED_AS_NULL)) {
            if (null !== $matches[1]) {
                $this->data['schemes'][$matches[1]] = true;
            }

            if (null !== $matches[2]) {
                $this->data['hosts'][$matches[2]] = true;
            }

            if (null !== $matches[5]) {
                $handler = $matches[4] ?? $this->data['handler'] ?? null;
                $this->data['handler'] = !empty($handler) ? [$handler, $matches[5]] : $matches[5];
            }

            if (empty($matches[3])) {
                throw new UriHandlerException(\sprintf('The route pattern "%s" is invalid as route path must be present in pattern.', $pattern));
            }

            \preg_match(Route::PRIORITY_REGEX, $this->data['path'] = '/' . \ltrim($matches[3], '/'), $pM);
            $this->data['prefix'] = !empty($pM[1] ?? null) ? $pM[1] : null;
        }

        return $this;
    }

    /**
     * Sets the requirement for the HTTP method.
     *
     * @param string $methods the HTTP method(s) name
     *
     * @return $this
     */
    public function method(string ...$methods)
    {
        foreach ($methods as $method) {
            $this->data['methods'][\strtoupper($method)] = true;
        }

        return $this;
    }

    /**
     * Sets the requirement of host on this Route.
     *
     * @param string $hosts The host for which this route should be enabled
     *
     * @return $this
     */
    public function domain(string ...$hosts)
    {
        foreach ($hosts as $host) {
            \preg_match(Route::URL_PATTERN, $host, $matches, \PREG_UNMATCHED_AS_NULL);

            if (isset($matches[1])) {
                $this->data['schemes'][$matches[1]] = true;
            }

            if (isset($matches[2])) {
                $this->data['hosts'][$matches[2]] = true;
            }
        }

        return $this;
    }

    /**
     * Sets the requirement of domain scheme on this Route.
     *
     * @param string ...$schemes
     *
     * @return $this
     */
    public function scheme(string ...$schemes)
    {
        foreach ($schemes as $scheme) {
            $this->data['schemes'][$scheme] = true;
        }

        return $this;
    }

    /**
     * Sets the route name.
     *
     * @return $this
     */
    public function bind(string $routeName)
    {
        $this->data['name'] = $routeName;

        return $this;
    }

    /**
     * Sets the parameter value for a route handler.
     *
     * @param mixed $value The parameter value
     *
     * @return $this
     */
    public function argument(string $parameter, $value)
    {
        if (\is_numeric($value)) {
            $value = (int) $value;
        } elseif (\is_string($value)) {
            $value = \rawurldecode($value);
        }

        $this->data['arguments'][$parameter] = $value;

        return $this;
    }

    /**
     * Sets the parameter values for a route handler.
     *
     * @param array<int|string> $parameters The route handler parameters
     *
     * @return $this
     */
    public function arguments(array $parameters)
    {
        foreach ($parameters as $variable => $value) {
            $this->argument($variable, $value);
        }

        return $this;
    }

    /**
     * Sets the route code that should be executed when matched.
     *
     * @param mixed $to PHP class, object or callable that returns the response when matched
     *
     * @return $this
     */
    public function run($to)
    {
        if (isset($this->data['namespace'])) {
            $to = $this->resolveNamespace($this->data['namespace'], $to);
            unset($this->data['namespace']); // No longer needed.
        }

        $this->data['handler'] = $to;

        return $this;
    }

    /**
     * Sets the missing namespace on route's handler.
     *
     * @throws InvalidControllerException if $namespace is invalid
     *
     * @return $this
     */
    public function namespace(string $namespace)
    {
        if (!empty($namespace)) {
            if ('\\' === $namespace[-1]) {
                throw new InvalidControllerException(\sprintf('Namespace "%s" provided for routes must not end with a "\\".', $namespace));
            }

            if (isset($this->data['handler'])) {
                $this->data['handler'] = $this->resolveNamespace($namespace, $this->data['handler']);
            } else {
                $this->data['namespace'] = ($this->data['namespace'] ?? '') . $namespace;
            }
        }

        return $this;
    }

    /**
     * Attach a named middleware group(s) to route.
     *
     * @return $this
     */
    public function piped(string ...$to)
    {
        foreach ($to as $namedMiddleware) {
            $this->data['middlewares'][$namedMiddleware] = true;
        }

        return $this;
    }

    /**
     * Sets the requirement for a route variable.
     *
     * @param string|string[] $regexp The regexp to apply
     *
     * @return $this
     */
    public function assert(string $variable, $regexp)
    {
        $this->data['patterns'][$variable] = $regexp;

        return $this;
    }

    /**
     * Sets the requirements for a route variable.
     *
     * @param array<string,string|string[]> $regexps The regexps to apply
     *
     * @return $this
     */
    public function asserts(array $regexps)
    {
        foreach ($regexps as $variable => $regexp) {
            $this->assert($variable, $regexp);
        }

        return $this;
    }

    /**
     * Sets the default value for a route variable.
     *
     * @param mixed $default The default value
     *
     * @return $this
     */
    public function default(string $variable, $default)
    {
        $this->data['defaults'][$variable] = $default;

        return $this;
    }

    /**
     * Sets the default values for a route variables.
     *
     * @param array<string,mixed> $values
     *
     * @return $this
     */
    public function defaults(array $values)
    {
        foreach ($values as $variable => $default) {
            $this->default($variable, $default);
        }

        return $this;
    }

    public function hasMethod(string $method): bool
    {
        return isset($this->data['methods'][$method]);
    }

    public function hasScheme(string $scheme): bool
    {
        return empty($s = $this->data['schemes'] ?? []) || isset($s[$scheme]);
    }

    public function getName(): ?string
    {
        return $this->data['name'] ?? null;
    }

    public function getPath(): string
    {
        return $this->data['path'] ?? '/';
    }

    /**
     * @return array<int,string>
     */
    public function getMethods(): array
    {
        return \array_keys($this->data['methods'] ?? []);
    }

    /**
     * @return array<int,string>
     */
    public function getSchemes(): array
    {
        return \array_keys($this->data['schemes'] ?? []);
    }

    /**
     * @return array<int,string>
     */
    public function getHosts(): array
    {
        return \array_keys($this->data['hosts'] ?? []);
    }

    /**
     * @return array<int|string,mixed>
     */
    public function getArguments(): array
    {
        return $this->data['arguments'] ?? [];
    }

    /**
     * @return mixed
     */
    public function getHandler()
    {
        return $this->data['handler'] ?? null;
    }

    /**
     * @return array<int|string,mixed>
     */
    public function getDefaults(): array
    {
        return $this->data['defaults'] ?? [];
    }

    /**
     * @return array<string,string|string[]>
     */
    public function getPatterns(): array
    {
        return $this->data['patterns'] ?? [];
    }

    /**
     * Return the list of attached grouped middlewares.
     *
     * @return array<int,string>
     */
    public function getPiped(): array
    {
        return \array_keys($this->data['middlewares'] ?? []);
    }

    /**
     * Return's the static prefixed portion of the route path else null.
     *
     * @see Flight\Routing\RouteCollection::getRoutes()
     */
    public function getStaticPrefix(): ?string
    {
        return $this->data['prefix'] ?? null;
    }

    /**
     * @internal skip throwing an exception and return existing $controller
     *
     * @param callable|object|string|string[] $controller
     *
     * @return mixed
     */
    protected function resolveNamespace(string $namespace, $controller)
    {
        if ($controller instanceof ResourceHandler) {
            return $controller->namespace($namespace);
        }

        if (\is_string($controller) && '\\' === $controller[0]) {
            $controller = $namespace . $controller;
        } elseif ((\is_array($controller) && 2 == \count($controller, \COUNT_RECURSIVE)) && \is_string($controller[0])) {
            $controller[0] = $this->resolveNamespace($namespace, $controller[0]);
        }

        return $controller;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* This file is part of Flight Routing.
7		*
8		* PHP version 7.4 and above required
9		*
10		* @author Divine Niiquaye Ibok <[email protected]>
11		* @copyright 2019 Biurad Group (https://biurad.com/)
12		* @license https://opensource.org/licenses/BSD-3-Clause License
13		*
14		* For the full copyright and license information, please view the LICENSE
15		* file that was distributed with this source code.
16		*/
17
18		namespace Flight\Routing\Traits;
19
20		use Flight\Routing\Exceptions\{InvalidControllerException, UriHandlerException};
21		use Flight\Routing\Route;
22		use Flight\Routing\Handlers\ResourceHandler;
23
24		trait DataTrait
25		{
26		/** @var array<string,mixed> */
27		protected array $data;
28
29		/**
30		* Sets the route path prefix.
31		*
32		* @return $this
33		*/
34	26	public function prefix(string $path)
35		{
36	26	if (!empty($path)) {
37	23	$uri = $this->data['path'] ?? '/';
38
39	23	if (\strlen($uri) > 1 && isset(Route::URL_PREFIX_SLASHES[$uri[1]])) {
40	2	$uri = \substr($uri, 1);
41		}
42
43	23	if (isset(Route::URL_PREFIX_SLASHES[$path[-1]])) {
44	3	$uri = \substr($uri, 1);
45		}
46
47	23	\preg_match(Route::PRIORITY_REGEX, $this->data['path'] = ('/' . \ltrim($path, '/')) . $uri, $pM);
48	23	$this->data['prefix'] = !empty($pM[1] ?? null) ? $pM[1] : null;
49		}
50
51	26	return $this;
52		}
53
54		/**
55		* Sets the route path pattern.
56		*
57		* @return $this
58		*/
59	212	public function path(string $pattern)
60		{
61	212	if (\preg_match(Route::RCA_PATTERN, $pattern, $matches, \PREG_UNMATCHED_AS_NULL)) {
62	212	if (null !== $matches[1]) {
63	6	$this->data['schemes'][$matches[1]] = true;
64		}
65
66	212	if (null !== $matches[2]) {
67	13	$this->data['hosts'][$matches[2]] = true;
68		}
69
70	212	if (null !== $matches[5]) {
71	6	$handler = $matches[4] ?? $this->data['handler'] ?? null;
72	6	$this->data['handler'] = !empty($handler) ? [$handler, $matches[5]] : $matches[5];
73		}
74
75	212	if (empty($matches[3])) {
76	3	throw new UriHandlerException(\sprintf('The route pattern "%s" is invalid as route path must be present in pattern.', $pattern));
77		}
78
79	209	\preg_match(Route::PRIORITY_REGEX, $this->data['path'] = '/' . \ltrim($matches[3], '/'), $pM);
80	209	$this->data['prefix'] = !empty($pM[1] ?? null) ? $pM[1] : null;
81		}
82
83	209	return $this;
84		}
85
86		/**
87		* Sets the requirement for the HTTP method.
88		*
89		* @param string $methods the HTTP method(s) name
90		*
91		* @return $this
92		*/
93	12	public function method(string ...$methods)
94		{
95	12	foreach ($methods as $method) {
96	11	$this->data['methods'][\strtoupper($method)] = true;
97		}
98
99	12	return $this;
100		}
101
102		/**
103		* Sets the requirement of host on this Route.
104		*
105		* @param string $hosts The host for which this route should be enabled
106		*
107		* @return $this
108		*/
109	21	public function domain(string ...$hosts)
110		{
111	21	foreach ($hosts as $host) {
112	20	\preg_match(Route::URL_PATTERN, $host, $matches, \PREG_UNMATCHED_AS_NULL);
113
114	20	if (isset($matches[1])) {
115	13	$this->data['schemes'][$matches[1]] = true;
116		}
117
118	20	if (isset($matches[2])) {
119	20	$this->data['hosts'][$matches[2]] = true;
120		}
121		}
122
123	21	return $this;
124		}
125
126		/**
127		* Sets the requirement of domain scheme on this Route.
128		*
129		* @param string ...$schemes
130		*
131		* @return $this
132		*/
133	16	public function scheme(string ...$schemes)
134		{
135	16	foreach ($schemes as $scheme) {
136	15	$this->data['schemes'][$scheme] = true;
137		}
138
139	16	return $this;
140		}
141
142		/**
143		* Sets the route name.
144		*
145		* @return $this
146		*/
147	37	public function bind(string $routeName)
148		{
149	37	$this->data['name'] = $routeName;
150
151	37	return $this;
152		}
153
154		/**
155		* Sets the parameter value for a route handler.
156		*
157		* @param mixed $value The parameter value
158		*
159		* @return $this
160		*/
161	32	public function argument(string $parameter, $value)
162		{
163	32	if (\is_numeric($value)) {
164	10	$value = (int) $value;
165	27	} elseif (\is_string($value)) {
166	17	$value = \rawurldecode($value);
167		}
168
169	32	$this->data['arguments'][$parameter] = $value;
170
171	32	return $this;
172		}
173
174		/**
175		* Sets the parameter values for a route handler.
176		*
177		* @param array<int\|string> $parameters The route handler parameters
178		*
179		* @return $this
180		*/
181	8	public function arguments(array $parameters)
182		{
183	8	foreach ($parameters as $variable => $value) {
184	2	$this->argument($variable, $value);
185		}
186
187	8	return $this;
188		}
189
190		/**
191		* Sets the route code that should be executed when matched.
192		*
193		* @param mixed $to PHP class, object or callable that returns the response when matched
194		*
195		* @return $this
196		*/
197	4	public function run($to)
198		{
199	4	if (isset($this->data['namespace'])) {
200	2	$to = $this->resolveNamespace($this->data['namespace'], $to);
201	2	unset($this->data['namespace']); // No longer needed.
202		}
203
204	4	$this->data['handler'] = $to;
205
206	4	return $this;
207		}
208
209		/**
210		* Sets the missing namespace on route's handler.
211		*
212		* @throws InvalidControllerException if $namespace is invalid
213		*
214		* @return $this
215		*/
216	6	public function namespace(string $namespace)
217		{
218	6	if (!empty($namespace)) {
219	6	if ('\\' === $namespace[-1]) {
220	1	throw new InvalidControllerException(\sprintf('Namespace "%s" provided for routes must not end with a "\\".', $namespace));
221		}
222
223	6	if (isset($this->data['handler'])) {
224	5	$this->data['handler'] = $this->resolveNamespace($namespace, $this->data['handler']);
225		} else {
226	2	$this->data['namespace'] = ($this->data['namespace'] ?? '') . $namespace;
227		}
228		}
229
230	6	return $this;
231		}
232
233		/**
234		* Attach a named middleware group(s) to route.
235		*
236		* @return $this
237		*/
238	6	public function piped(string ...$to)
239		{
240	6	foreach ($to as $namedMiddleware) {
241	6	$this->data['middlewares'][$namedMiddleware] = true;
242		}
243
244	6	return $this;
245		}
246
247		/**
248		* Sets the requirement for a route variable.
249		*
250		* @param string\|string[] $regexp The regexp to apply
251		*
252		* @return $this
253		*/
254	16	public function assert(string $variable, $regexp)
255		{
256	16	$this->data['patterns'][$variable] = $regexp;
257
258	16	return $this;
259		}
260
261		/**
262		* Sets the requirements for a route variable.
263		*
264		* @param array<string,string\|string[]> $regexps The regexps to apply
265		*
266		* @return $this
267		*/
268	7	public function asserts(array $regexps)
269		{
270	7	foreach ($regexps as $variable => $regexp) {
271	3	$this->assert($variable, $regexp);
272		}
273
274	7	return $this;
275		}
276
277		/**
278		* Sets the default value for a route variable.
279		*
280		* @param mixed $default The default value
281		*
282		* @return $this
283		*/
284	8	public function default(string $variable, $default)
285		{
286	8	$this->data['defaults'][$variable] = $default;
287
288	8	return $this;
289		}
290
291		/**
292		* Sets the default values for a route variables.
293		*
294		* @param array<string,mixed> $values
295		*
296		* @return $this
297		*/
298	7	public function defaults(array $values)
299		{
300	7	foreach ($values as $variable => $default) {
301	3	$this->default($variable, $default);
302		}
303
304	7	return $this;
305		}
306
307	43	public function hasMethod(string $method): bool
308		{
309	43	return isset($this->data['methods'][$method]);
310		}
311
312	181	public function hasScheme(string $scheme): bool
313		{
314	181	return empty($s = $this->data['schemes'] ?? []) \|\| isset($s[$scheme]);
315		}
316
317		public function getName(): ?string
318		{
319		return $this->data['name'] ?? null;
320	103	}
321
322	103	public function getPath(): string
323		{
324		return $this->data['path'] ?? '/';
325		}
326
327		/**
328	100	* @return array<int,string>
329		*/
330	100	public function getMethods(): array
331		{
332		return \array_keys($this->data['methods'] ?? []);
333		}
334
335		/**
336	142	* @return array<int,string>
337		*/
338	142	public function getSchemes(): array
339		{
340		return \array_keys($this->data['schemes'] ?? []);
341		}
342
343		/**
344	78	* @return array<int,string>
345		*/
346	78	public function getHosts(): array
347		{
348		return \array_keys($this->data['hosts'] ?? []);
349		}
350
351		/**
352	77	* @return array<int\|string,mixed>
353		*/
354	77	public function getArguments(): array
355		{
356		return $this->data['arguments'] ?? [];
357		}
358
359		/**
360	53	* @return mixed
361		*/
362	53	public function getHandler()
363		{
364		return $this->data['handler'] ?? null;
365		}
366
367		/**
368	140	* @return array<int\|string,mixed>
369		*/
370	140	public function getDefaults(): array
371		{
372		return $this->data['defaults'] ?? [];
373		}
374
375		/**
376		* @return array<string,string\|string[]>
377		*/
378	52	public function getPatterns(): array
379		{
380	52	return $this->data['patterns'] ?? [];
381		}
382
383		/**
384		* Return the list of attached grouped middlewares.
385		*
386		* @return array<int,string>
387		*/
388	119	public function getPiped(): array
389		{
390	119	return \array_keys($this->data['middlewares'] ?? []);
391		}
392
393		/**
394		* Return's the static prefixed portion of the route path else null.
395		*
396		* @see Flight\Routing\RouteCollection::getRoutes()
397		*/
398		public function getStaticPrefix(): ?string
399		{
400	6	return $this->data['prefix'] ?? null;
401		}
402	6
403	1	/**
404		* @internal skip throwing an exception and return existing $controller
405		*
406	6	* @param callable\|object\|string\|string[] $controller
407	6	*
408	2	* @return mixed
409	1	*/
410		protected function resolveNamespace(string $namespace, $controller)
411		{
412	6	if ($controller instanceof ResourceHandler) {
413		return $controller->namespace($namespace);
414		}
415
416		if (\is_string($controller) && '\\' === $controller[0]) {
417		$controller = $namespace . $controller;
418		} elseif ((\is_array($controller) && 2 == \count($controller, \COUNT_RECURSIVE)) && \is_string($controller[0])) {
419		$controller[0] = $this->resolveNamespace($namespace, $controller[0]);
420		}
421
422		return $controller;
423		}
424		}
425

divineniiquaye / flight-routing

Push — master ( f6c0fb...d5e0ae )

DataTrait::hasMethod() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like