MinasRouter\Router\Middlewares\MiddlewareCollection

Complexity

Total Complexity

29

Size/Duplication

Total Lines	215
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	storeMiddleware()	0	7	2
A	resolveLaterMiddleware()	0	15	3
A	setRequest()	0	3	1
A	next()	0	5	1
A	execute()	0	3	1
A	get()	0	7	4
A	callMiddlewares()	0	16	4
A	resolveNestedMiddleware()	0	7	1
A	getByAlias()	0	13	3
A	setMiddlewares()	0	3	1
A	executeMiddleware()	0	11	2
A	instanceMiddleware()	0	13	4
A	reset()	0	3	1

<?php

namespace MinasRouter\Router\Middlewares;

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

class MiddlewareCollection
{
    /** @var array */
    protected $middlewares = [];

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

    /** @var array */
    protected $queue;

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

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

    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

The type MinasRouter\Router\Middlewares\MinasRouter\Http\Request was not found. Did you mean MinasRouter\Http\Request? If so, make sure to prefix the type with \.

     * 
     * @return void
     */
    public function setRequest(Request $request)
    {
        $this->currentRequest = $request;

It seems like $request of type MinasRouter\Http\Request is incompatible with the declared type array of property $currentRequest.

    }

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

    public function storeMiddleware($middleware)
    {
        if (is_string($middleware)) {
            $middleware = explode(",", $middleware);
        }

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

    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)) {

The condition is_string($middlewares) is always false.

            $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()
        );
    }
}