Bone\Firewall\RouteFirewall

Complexity

Total Complexity

14

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	process()	0	20	4
A	handleMiddleware()	0	13	3
A	addMiddleware()	0	9	4

<?php declare(strict_types=1);

namespace Bone\Firewall;

use Barnacle\Container;
use Bone\Router\Router;
use League\Route\Route;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

class RouteFirewall implements MiddlewareInterface
{
    /** @var Router $router */
    private $router;

    /** @var array $blockedRoutes */
    private $blockedRoutes;

    /** @var MiddlewareInterface[] $middlewares */
    private $middlewares;

    /** @var Container $container */
    private $container;

    /**
     * RouteFirewall constructor.
     * @param Container $container

There is no parameter named $container. Was it maybe removed?

     */
    public function __construct(Container $c)
    {
        /** @var Router $router */
        $router = $c->get(Router::class);
        $blockedRoutes = $c->has('blockedRoutes') ? $c->get('blockedRoutes') : [];
        $middlewares = $c->has('routeMiddleware') ? $c->get('routeMiddleware') : [];
        $this->container = $c;
        $this->router = $router;
        $this->blockedRoutes = $blockedRoutes;

It seems like $blockedRoutes of type * is incompatible with the declared type array of property $blockedRoutes.

        $this->middlewares = $middlewares;

It seems like $middlewares of type * is incompatible with the declared type array<integer,object<Psr\Http\Server\MiddlewareInterface>> of property $middlewares.

    }

    /**
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $handler
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $routes = $this->router->getRoutes();

        /** @var Route $route */
        foreach ($routes as $route) {
            $path = $route->getPath();

            if (in_array($path, $this->blockedRoutes)) {
                $this->router->removeRoute($route);
                break;
            }

            if (array_key_exists($path, $this->middlewares)) {
                $this->handleMiddleware($path, $route);
            }
        }

        return $handler->handle($request);
    }

    private function handleMiddleware(string $path, Route $route)
    {
        $routeMiddleware = $this->middlewares[$path];

        if (is_array($routeMiddleware)) {
            foreach ($routeMiddleware as $middleware) {
                $this->addMiddleware($route, $middleware);
            }
        } else {
            $this->addMiddleware($route, $routeMiddleware);
        }

    }

    /**
     * @param Route $route
     * @param $middleware
     */
    private function addMiddleware(Route $route, $middleware): void
    {
        if ($middleware instanceof MiddlewareInterface) {
            $route->middleware($middleware);
        } elseif (is_string($middleware) && $this->container->has($middleware)) {
            $middleware = $this->container->get($middleware);
            $route->middleware($middleware);
        }
    }
}