Group::assertRoutes() - Code Metrics - Inspection of "New syntax" - yiisoft/router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#225)

by Rustam

created 2023-11-09 12:35 UTC

Group::assertRoutes() A

↳ Parent: Group

Complexity

Conditions	5
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	5

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Yiisoft\Router;

use Yiisoft\Router\Internal\MiddlewareFilter;

final class Group
{
    /**
     * @var Group[]|RoutableInterface[]|Route[]
     */
    private array $routes = [];

    /**
     * @var array[]|callable[]|string[]
     * @psalm-var list<array|callable|string>
     */
    private array $middlewares = [];

    /**
     * @var string[]
     */
    private array $hosts = [];

    /**
     * @psalm-var list<array|callable|string>|null
     */
    private ?array $enabledMiddlewaresCache = null;

    /**
     * @var array|callable|string|null Middleware definition for CORS requests.
     */
    private $corsMiddleware = null;

    /**
     * @param array $disabledMiddlewares Excludes middleware from being invoked when action is handled.
     * It is useful to avoid invoking one of the parent group middleware for
     * a certain route.
     */
    public function __construct(
        private ?string $prefix = null,
        private ?string $namePrefix = null,
        array $routes = [],
        array $middlewares = [],
        array $hosts = [],
        private array $disabledMiddlewares = [],
        array|callable|string|null $corsMiddleware = null
    ) {
        $this->setRoutes($routes);
        $this->setMiddlewares($middlewares);
        $this->setHosts($hosts);
        $this->corsMiddleware = $corsMiddleware;
    }

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

    public function getMiddlewares(): array
    {
        return $this->middlewares;
    }

    public function getHosts(): array
    {
        return $this->hosts;
    }

    public function getCorsMiddleware(): callable|array|string|null
    {
        return $this->corsMiddleware;
    }

    public function getPrefix(): ?string
    {
        return $this->prefix;
    }

    public function getNamePrefix(): ?string
    {
        return $this->namePrefix;
    }

    public function getDisabledMiddlewares(): array
    {
        return $this->disabledMiddlewares;
    }

    public function setRoutes(array $routes): self
    {
        $this->assertRoutes($routes);
        $this->routes = $routes;
        return $this;
    }

    public function setMiddlewares(array $middlewares): self
    {
        $this->assertMiddlewares($middlewares);
        $this->middlewares = $middlewares;
        $this->enabledMiddlewaresCache = null;
        return $this;
    }

    public function setHosts(array $hosts): self
    {
        foreach ($hosts as $host) {
            if (!is_string($host)) {
                throw new \InvalidArgumentException('Invalid $hosts provided, list of string expected.');
            }
            $host = rtrim($host, '/');

            if ($host !== '' && !in_array($host, $this->hosts, true)) {
                $this->hosts[] = $host;
            }
        }

        return $this;
    }

    public function setCorsMiddleware(callable|array|string|null $corsMiddleware): self
    {
        $this->corsMiddleware = $corsMiddleware;
        return $this;
    }

    public function setPrefix(?string $prefix): self
    {
        $this->prefix = $prefix;
        return $this;
    }

    public function setNamePrefix(?string $namePrefix): self
    {
        $this->namePrefix = $namePrefix;
        return $this;
    }

    public function setDisabledMiddlewares(array $disabledMiddlewares): self
    {
        $this->disabledMiddlewares = $disabledMiddlewares;
        $this->enabledMiddlewaresCache = null;
        return $this;
    }

    /**
     * @return array[]|callable[]|string[]
     * @psalm-return list<array|callable|string>
     */
    public function getEnabledMiddlewares(): array
    {
        if ($this->enabledMiddlewaresCache !== null) {
            return $this->enabledMiddlewaresCache;
        }

        return $this->enabledMiddlewaresCache = MiddlewareFilter::filter($this->middlewares, $this->disabledMiddlewares);
    }

    /**
     * @psalm-assert list<array|callable|string> $middlewares
     */
    private function assertMiddlewares(array $middlewares): void
    {
        /** @var mixed $middleware */
        foreach ($middlewares as $middleware) {
            if (is_string($middleware) || is_callable($middleware) || is_array($middleware)) {
                continue;
            }

            throw new \InvalidArgumentException(
                'Invalid $middlewares provided, list of string or array or callable expected.'
            );
        }
    }

    /**
     * @psalm-assert array<Route|Group|RoutableInterface> $routes
     */
    private function assertRoutes(array $routes): void
    {
        /** @var Group|RoutableInterface|Route $route */
        foreach ($routes as $route) {
            if ($route instanceof Route || $route instanceof self || $route instanceof RoutableInterface) {
                continue;
            }

            throw new \InvalidArgumentException(
                'Invalid $routes provided, array of `Route` or `Group` or `RoutableInterface` instance expected.'
            );
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Router;
6
7		use Yiisoft\Router\Internal\MiddlewareFilter;
8
9		final class Group
10		{
11		/**
12		* @var Group[]\|RoutableInterface[]\|Route[]
13		*/
14		private array $routes = [];
15
16		/**
17		* @var array[]\|callable[]\|string[]
18		* @psalm-var list<array\|callable\|string>
19		*/
20		private array $middlewares = [];
21
22		/**
23		* @var string[]
24		*/
25		private array $hosts = [];
26
27		/**
28		* @psalm-var list<array\|callable\|string>\|null
29		*/
30		private ?array $enabledMiddlewaresCache = null;
31
32		/**
33		* @var array\|callable\|string\|null Middleware definition for CORS requests.
34		*/
35		private $corsMiddleware = null;
36
37		/**
38		* @param array $disabledMiddlewares Excludes middleware from being invoked when action is handled.
39		* It is useful to avoid invoking one of the parent group middleware for
40		* a certain route.
41		*/
42	42	public function __construct(
43		private ?string $prefix = null,
44		private ?string $namePrefix = null,
45		array $routes = [],
46		array $middlewares = [],
47		array $hosts = [],
48		private array $disabledMiddlewares = [],
49		array\|callable\|string\|null $corsMiddleware = null
50		) {
51	42	$this->setRoutes($routes);
52	42	$this->setMiddlewares($middlewares);
53	41	$this->setHosts($hosts);
54	40	$this->corsMiddleware = $corsMiddleware;
55		}
56
57		/**
58		* @return Group[]\|RoutableInterface[]\|Route[]
59		*/
60	24	public function getRoutes(): array
61		{
62	24	return $this->routes;
63		}
64
65	23	public function getMiddlewares(): array
66		{
67	23	return $this->middlewares;
68		}
69
70	26	public function getHosts(): array
71		{
72	26	return $this->hosts;
73		}
74
75	23	public function getCorsMiddleware(): callable\|array\|string\|null
76		{
77	23	return $this->corsMiddleware;
78		}
79
80	24	public function getPrefix(): ?string
81		{
82	24	return $this->prefix;
83		}
84
85	24	public function getNamePrefix(): ?string
86		{
87	24	return $this->namePrefix;
88		}
89
90	1	public function getDisabledMiddlewares(): array
91		{
92	1	return $this->disabledMiddlewares;
93		}
94
95	42	public function setRoutes(array $routes): self
96		{
97	42	$this->assertRoutes($routes);
98	42	$this->routes = $routes;
99	42	return $this;
100		}
101
102	42	public function setMiddlewares(array $middlewares): self
103		{
104	42	$this->assertMiddlewares($middlewares);
105	41	$this->middlewares = $middlewares;
106	41	$this->enabledMiddlewaresCache = null;
107	41	return $this;
108		}
109
110	41	public function setHosts(array $hosts): self
111		{
112	41	foreach ($hosts as $host) {
113	6	if (!is_string($host)) {
114	1	throw new \InvalidArgumentException('Invalid $hosts provided, list of string expected.');
115		}
116	6	$host = rtrim($host, '/');
117
118	6	if ($host !== '' && !in_array($host, $this->hosts, true)) {
119	6	$this->hosts[] = $host;
120		}
121		}
122
123	40	return $this;
124		}
125
126	3	public function setCorsMiddleware(callable\|array\|string\|null $corsMiddleware): self
127		{
128	3	$this->corsMiddleware = $corsMiddleware;
129	3	return $this;
130		}
131
132	1	public function setPrefix(?string $prefix): self
133		{
134	1	$this->prefix = $prefix;
135	1	return $this;
136		}
137
138	1	public function setNamePrefix(?string $namePrefix): self
139		{
140	1	$this->namePrefix = $namePrefix;
141	1	return $this;
142		}
143
144	4	public function setDisabledMiddlewares(array $disabledMiddlewares): self
145		{
146	4	$this->disabledMiddlewares = $disabledMiddlewares;
147	4	$this->enabledMiddlewaresCache = null;
148	4	return $this;
149		}
150
151		/**
152		* @return array[]\|callable[]\|string[]
153		* @psalm-return list<array\|callable\|string>
154		*/
155	24	public function getEnabledMiddlewares(): array
156		{
157	24	if ($this->enabledMiddlewaresCache !== null) {
158	13	return $this->enabledMiddlewaresCache;
159		}
160
161	24	return $this->enabledMiddlewaresCache = MiddlewareFilter::filter($this->middlewares, $this->disabledMiddlewares);
162		}
163
164		/**
165		* @psalm-assert list<array\|callable\|string> $middlewares
166		*/
167	42	private function assertMiddlewares(array $middlewares): void
168		{
169		/** @var mixed $middleware */
170	42	foreach ($middlewares as $middleware) {
171	15	if (is_string($middleware) \|\| is_callable($middleware) \|\| is_array($middleware)) {
172	15	continue;
173		}
174
175	1	throw new \InvalidArgumentException(
176	1	'Invalid $middlewares provided, list of string or array or callable expected.'
177	1	);
178		}
179		}
180
181		/**
182		* @psalm-assert array<Route\|Group\|RoutableInterface> $routes
183		*/
184	42	private function assertRoutes(array $routes): void
185		{
186		/** @var Group\|RoutableInterface\|Route $route */
187	42	foreach ($routes as $route) {
188	25	if ($route instanceof Route \|\| $route instanceof self \|\| $route instanceof RoutableInterface) {
189	25	continue;
190		}
191
192	1	throw new \InvalidArgumentException(
193	1	'Invalid $routes provided, array of `Route` or `Group` or `RoutableInterface` instance expected.'
194	1	);
195		}
196		}
197		}
198

yiisoft / router

Pull Request — master (#225)

Group::assertRoutes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like