Thruster\Component\HttpMiddleware\Middlewares

Complexity

Total Complexity

11

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components

1

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ __construct()	0	4	1
A	__construct()	0	8	2
A	all()	0	4	1
A	add()	0	6	1
A	has()	0	4	1
A	remove()	0	12	2
B	hp$0 ➔ __invoke()	0	51	5
B	__invoke()	0	73	5

<?php

namespace Thruster\Component\HttpMiddleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Class Middlewares
 *
 * @package Thruster\Component\HttpMiddleware
 * @author  Aurimas Niekis <aurimas@niekis.lt>
 */
class Middlewares
{
    /**
     * @var callable[]
     */
    protected $middlewares;

    public function __construct(array $middlewares = [])
    {
        $this->middlewares = [];

        foreach ($middlewares as $middleware) {
            $this->add($middleware);
        }
    }

    /**
     * @return callable[]
     */
    public function all() : array
    {
        return $this->middlewares;
    }

    /**
     * @param callable $middleware
     *
     * @return Middlewares
     */
    public function add(callable $middleware) : self
    {
        $this->middlewares[] = $middleware;

        return $this;
    }

    /**
     * @param callable $middleware
     *
     * @return bool
     */
    public function has(callable $middleware) : bool
    {
        return false !== array_search($middleware, $this->middlewares, true);
    }

    /**
     * @param callable $middleware
     *
     * @return Middlewares
     */
    public function remove(callable $middleware) : self
    {
        $key = array_search($middleware, $this->middlewares, true);

        if (false === $key) {
            return $this;
        }

        unset($this->middlewares[$key]);

        return $this;
    }

    public function __invoke(
        ServerRequestInterface $request,
        ResponseInterface $response,
        callable $next = null
    ) : ResponseInterface
    {
        $dispatcher = new class($this->middlewares)
        {
            /**
             * @var callable[]
             */
            protected $middlewares;

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

            public function __invoke(
                ServerRequestInterface $request,
                ResponseInterface $response,
                callable $next = null
            ) : ResponseInterface {
                /** @var callable $middleware */
                $middleware = array_shift($this->middlewares);

                $skip = function (ServerRequestInterface $request, ResponseInterface $response) {
                    return $response;
                };

                if (count($this->middlewares) < 1) {
                    if (null === $next) {
                        $callback = $skip;
                    } else {
                        $callback = function (
                            ServerRequestInterface $request,
                            ResponseInterface $response
                        ) use (
                            $next,
                            $skip
                        ) {
                            return $next($request, $response, $skip);
                        };

                        if (null === $middleware) {
                            return $callback($request, $response, $callback);
                        }
                    }
                } else {
                    $callback = function (
                        ServerRequestInterface $request,
                        ResponseInterface $response
                    ) use (
                        $next
                    ) {
                        return $this->__invoke($request, $response, $next);
                    };
                }

                if (null !== $middleware) {
                    $response = $middleware(
                        $request,
                        $response,
                        $callback
                    );
                }

                return $response;
            }
        };

        return $dispatcher($request, $response, $next);
    }
}