MiddlewareCollection::destroyMiddleware() - Code Metrics - Inspection of "Improvements" - nicollassilva/minasrouter - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 249964...c93993 )

by Nícollas

created 2021-08-10 00:24 UTC

MiddlewareCollection::destroyMiddleware() A

↳ Parent: MiddlewareCollection

Complexity

Conditions	3
Paths	3

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	8
c	0
b	0
f	0
nc	3
nop	1
dl	0
loc	15
rs	10

<?php

namespace MinasRouter\Router\Middlewares;

use MinasRouter\Http\Request;
use MinasRouter\Router\Middlewares\MiddlewareRoute;

class MiddlewareCollection
{
    /** @var array */
    protected $queue;

    /** @var array|string */
    protected $middlewares;

    /** @var object */
    protected $currentRequest;

    /** @var int = 0 */
    protected $currentQueueNumber = 0;

    public function __construct($middlewares)
    {
        $this->middlewares = $middlewares;
    }

    /**
     * Return all middlewares of this route.
     * 
     * @param string $middleware = null
     * 
     * @return string|array
     */
    public function get(String $middleware = null)
    {
        if ($middleware && is_array($this->middlewares) && isset($this->middlewares[$middleware])) {
            return $this->middlewares[$middleware];
        }

        return $this->middlewares;
    }

    /**
     * Method responsible for setting the Route's Request
     * 
     * @param \MinasRouter\Http\Request $request
     * 
     * @return void
     */
    public function setRequest(Request $request)
    {
        $this->currentRequest = $request;
    }

    /**
     * Method responsible for setting the
     * middlewares of the route.
     * 
     * @var array $middlewares
     * 
     * @return void
     */
    public function setMiddlewares(array $middlewares)
    {
        $this->middlewares = $middlewares;
    }

    /**
     * Store a new middleware and return
     * all middlewares of route.
     * 
     * @param string|array $middleware
     * 
     * @return string|array
     */
    public function storeMiddleware($middleware)
    {
        if (is_string($middleware)) {
            $middleware = explode(",", $middleware);
        }

        return $this->resolveLaterMiddleware($middleware);
    }

    /**
     * Remove a middleware of the middleware queue.
     * 
     * @param string|array $middleware
     * 
     * @return string|array
     */
    public function removeMiddleware($middleware)
    {
        if (is_string($middleware)) {
            $middleware = explode(",", $middleware);
        }

        return $this->destroyMiddleware($middleware);
    }

    /**
     * Destroy the middlewares of individual route.
     * 
     * @param array $middleware
     * 
     * @return string|array
     */
    private function destroyMiddleware(Array $middleware)
    {
        $currentMiddleware = $this->middlewares;

        foreach ($middleware as $mid) {
            $mid = trim(rtrim($mid));
            
            if (is_string($currentMiddleware)) {
                $currentMiddleware .= ", {$mid}";
            } else {
                $currentMiddleware[] = $mid;
            }
        }

        return $currentMiddleware;
    }

    /**
     * Resolve the middlewares of individual route.
     * 
     * @param array $middleware
     * 
     * @return string|array
     */
    private function resolveLaterMiddleware(Array $middleware)
    {
        $currentMiddleware = $this->middlewares;

        foreach ($middleware as $mid) {
            $mid = trim(rtrim($mid));
            
            if (is_string($currentMiddleware)) {
                $currentMiddleware .= ", {$mid}";
            } else {
                $currentMiddleware[] = $mid;
            }
        }

        return $currentMiddleware;
    }

    /**
     * Alias for execute the middlewares.
     * 
     * @return mixed|bool
     */
    public function execute()
    {
        return $this->executeMiddleware();
    }

    /**
     * Execute the middlewares.
     * 
     * @return mixed|bool
     */
    protected function executeMiddleware()
    {
        $middlewares = $this->middlewares;

        if(is_string($middlewares)) {
            $middlewares = explode(',', $middlewares);
        }

        $this->resolveNestedMiddleware($middlewares);

        return $this->callMiddlewares();
    }

    /**
     * Method responsible for identifying
     * middlewares and instantiating them.
     * 
     * @param array $middlewares
     * 
     * @return void
     */
    protected function resolveNestedMiddleware(Array $middlewares): void
    {
        $this->queue = array_map(function ($middleware) {
            $middleware = trim(rtrim($middleware));

            return $this->instanceMiddleware($middleware);
        }, $middlewares);
    }

    /**
     * Method responsible for instantiating middlewares.
     * 
     * @param string
     * 
     * @return null|object
     */
    protected function instanceMiddleware($middleware)
    {
        if (!preg_match("/\\\/", $middleware)) {
            if (!$middlewareClass = $this->getByAlias($middleware)) return;

            return new $middlewareClass();
        }

        if (class_exists($middleware)) {
            return new $middleware();
        }

        return;
    }

    /**
     * Method responsible for identifying 
     * a middleware by alias.
     * 
     * @param string $alias
     * 
     * @return null|string
     */
    protected function getByAlias(String $alias)
    {
        $middlewares = MiddlewareRoute::getGlobalMiddlewares();

        if (!array_key_exists($alias, $middlewares)) {
            return;
        }

        if (class_exists($middlewares[$alias])) {
            return $middlewares[$alias];
        }

        return;
    }

    /**
     * Method responsible for 
     * calling the next middleware.
     * 
     * @return mixed|bool
     */
    protected function next()
    {
        $this->currentQueueNumber++;

        return $this->callMiddlewares();
    }

    /**
     * Method responsible for resetting 
     * the middleware queue.
     * 
     * @return void
     */
    protected function reset()
    {
        $this->currentQueueNumber = 0;
    }

    /**
     * Method responsible for calling
     * middlewares and class handle.
     * 
     * @return mixed|bool
     */
    protected function callMiddlewares()
    {
        if (!isset($this->queue[$this->currentQueueNumber])) {
            $this->reset();
            return true;
        }

        $currentMiddleware = $this->queue[$this->currentQueueNumber];

        if (is_null($currentMiddleware) || empty($currentMiddleware)) {
            return $this->next();
        }

        return $currentMiddleware->handle(
            $this->currentRequest,
            fn () => $this->next()
        );
    }
}


1			<?php
2
3			namespace MinasRouter\Router\Middlewares;
4
5			use MinasRouter\Http\Request;
6			use MinasRouter\Router\Middlewares\MiddlewareRoute;
7
8			class MiddlewareCollection
9			{
10			/** @var array */
11			protected $queue;
12
13			/** @var array\|string */
14			protected $middlewares;
15
16			/** @var object */
17			protected $currentRequest;
18
19			/** @var int = 0 */
20			protected $currentQueueNumber = 0;
21
22			public function __construct($middlewares)
23			{
24			$this->middlewares = $middlewares;
25			}
26
27			/**
28			* Return all middlewares of this route.
29			*
30			* @param string $middleware = null
31			*
32			* @return string\|array
33			*/
34			public function get(String $middleware = null)
35			{
36			if ($middleware && is_array($this->middlewares) && isset($this->middlewares[$middleware])) {
37			return $this->middlewares[$middleware];
38			}
39
40			return $this->middlewares;
41			}
42
43			/**
44			* Method responsible for setting the Route's Request
45			*
46			* @param \MinasRouter\Http\Request $request
47			*
48			* @return void
49			*/
50			public function setRequest(Request $request)
51			{
52			$this->currentRequest = $request;
53			}
54
55			/**
56			* Method responsible for setting the
57			* middlewares of the route.
58			*
59			* @var array $middlewares
60			*
61			* @return void
62			*/
63			public function setMiddlewares(array $middlewares)
64			{
65			$this->middlewares = $middlewares;
66			}
67
68			/**
69			* Store a new middleware and return
70			* all middlewares of route.
71			*
72			* @param string\|array $middleware
73			*
74			* @return string\|array
75			*/
76			public function storeMiddleware($middleware)
77			{
78			if (is_string($middleware)) {
79			$middleware = explode(",", $middleware);
80			}
81
82			return $this->resolveLaterMiddleware($middleware);
83			}
84
85			/**
86			* Remove a middleware of the middleware queue.
87			*
88			* @param string\|array $middleware
89			*
90			* @return string\|array
91			*/
92			public function removeMiddleware($middleware)
93			{
94			if (is_string($middleware)) {
95			$middleware = explode(",", $middleware);
96			}
97
98			return $this->destroyMiddleware($middleware);
99			}
100
101			/**
102			* Destroy the middlewares of individual route.
103			*
104			* @param array $middleware
105			*
106			* @return string\|array
107			*/
108			private function destroyMiddleware(Array $middleware)
109			{
110			$currentMiddleware = $this->middlewares;
111
112			foreach ($middleware as $mid) {
113			$mid = trim(rtrim($mid));
114
115			if (is_string($currentMiddleware)) {
116			$currentMiddleware .= ", {$mid}";
117			} else {
118			$currentMiddleware[] = $mid;
119			}
120			}
121
122			return $currentMiddleware;
123			}
124
125			/**
126			* Resolve the middlewares of individual route.
127			*
128			* @param array $middleware
129			*
130			* @return string\|array
131			*/
132			private function resolveLaterMiddleware(Array $middleware)
133			{
134			$currentMiddleware = $this->middlewares;
135
136			foreach ($middleware as $mid) {
137			$mid = trim(rtrim($mid));
138
139			if (is_string($currentMiddleware)) {
140			$currentMiddleware .= ", {$mid}";
141			} else {
142			$currentMiddleware[] = $mid;
143			}
144			}
145
146			return $currentMiddleware;
147			}
148
149			/**
150			* Alias for execute the middlewares.
151			*
152			* @return mixed\|bool
153			*/
154			public function execute()
155			{
156			return $this->executeMiddleware();
157			}
158
159			/**
160			* Execute the middlewares.
161			*
162			* @return mixed\|bool
163			*/
164			protected function executeMiddleware()
165			{
166			$middlewares = $this->middlewares;
167
168			if(is_string($middlewares)) {
169			$middlewares = explode(',', $middlewares);
170			}
171
172			$this->resolveNestedMiddleware($middlewares);
173
174			return $this->callMiddlewares();
175			}
176
177			/**
178			* Method responsible for identifying
179			* middlewares and instantiating them.
180			*
181			* @param array $middlewares
182			*
183			* @return void
184			*/
185			protected function resolveNestedMiddleware(Array $middlewares): void
186			{
187			$this->queue = array_map(function ($middleware) {
188			$middleware = trim(rtrim($middleware));
189
190			return $this->instanceMiddleware($middleware);
191			}, $middlewares);
192			}
193
194			/**
195			* Method responsible for instantiating middlewares.
196			*
197			* @param string
198			*
199			* @return null\|object
200			*/
201			protected function instanceMiddleware($middleware)
202			{
203			if (!preg_match("/\\\/", $middleware)) {
204			if (!$middlewareClass = $this->getByAlias($middleware)) return;
205
206			return new $middlewareClass();
207			}
208
209			if (class_exists($middleware)) {
210			return new $middleware();
211			}
212
213			return;
214			}
215
216			/**
217			* Method responsible for identifying
218			* a middleware by alias.
219			*
220			* @param string $alias
221			*
222			* @return null\|string
223			*/
224			protected function getByAlias(String $alias)
225			{
226			$middlewares = MiddlewareRoute::getGlobalMiddlewares();
227
228			if (!array_key_exists($alias, $middlewares)) {
229			return;
230			}
231
232			if (class_exists($middlewares[$alias])) {
233			return $middlewares[$alias];
234			}
235
236			return;
237			}
238
239			/**
240			* Method responsible for
241			* calling the next middleware.
242			*
243			* @return mixed\|bool
244			*/
245			protected function next()
246			{
247			$this->currentQueueNumber++;
248
249			return $this->callMiddlewares();
250			}
251
252			/**
253			* Method responsible for resetting
254			* the middleware queue.
255			*
256			* @return void
257			*/
258			protected function reset()
259			{
260			$this->currentQueueNumber = 0;
261			}
262
263			/**
264			* Method responsible for calling
265			* middlewares and class handle.
266			*
267			* @return mixed\|bool
268			*/
269			protected function callMiddlewares()
270			{
271			if (!isset($this->queue[$this->currentQueueNumber])) {
272			$this->reset();
273			return true;
274			}
275
276			$currentMiddleware = $this->queue[$this->currentQueueNumber];
277
278			if (is_null($currentMiddleware) \|\| empty($currentMiddleware)) {
279			return $this->next();
280			}
281
282			return $currentMiddleware->handle(
283			$this->currentRequest,
284			fn () => $this->next()
285			);
286			}
287			}
288

nicollassilva / minasrouter

Push — master ( 249964...c93993 )

MiddlewareCollection::destroyMiddleware() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like