Igni\Http\Application

Complexity

Total Complexity

32

Size/Duplication

Total Lines	285
Duplicated Lines	0 %

Test Coverage

Coverage

77.66%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	options()	0	3	1
A	shutdown()	0	3	1
A	put()	0	3	1
A	get()	0	3	1
C	process()	0	33	7
A	use()	0	11	3
A	handle()	0	5	1
A	__construct()	0	10	2
A	startup()	0	4	1
A	patch()	0	3	1
A	run()	0	17	3
A	delete()	0	3	1
A	post()	0	3	1
A	head()	0	3	1
A	createPipeline()	0	15	3
A	getControllerAggregate()	0	3	1
A	onRequest()	0	3	1
A	getMiddlewarePipe()	0	7	2

<?php declare(strict_types=1);

namespace Igni\Http;

use Igni\Application\Application as AbstractApplication;
use Igni\Application\Controller\ControllerAggregate as AbstractControllerAggregate;
use Igni\Application\Exception\ApplicationException;
use Igni\Http\Controller\ControllerAggregate;
use Igni\Http\Exception\HttpModuleException;
use Igni\Http\Middleware\ErrorMiddleware;
use Igni\Http\Server\OnRequest;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Throwable;
use Zend\Diactoros\Response\SapiEmitter;
use Zend\Stratigility\Middleware\CallableMiddlewareDecorator;
use Zend\Stratigility\MiddlewarePipe;

/**
 * @see \Igni\Application\Application
 *
 * @package Igni\Http
 */
class Application
    extends AbstractApplication
    implements MiddlewareAggregate, MiddlewareInterface, RequestHandlerInterface, OnRequest {

    /**
     * @var Router
     */
    private $router;

    /**
     * @var ControllerAggregate
     */
    private $controllerAggregate;

    /**
     * @var string[]|MiddlewareInterface[]
     */
    private $middleware = [];

    /**
     * @var MiddlewarePipe
     */
    private $pipeline;

    /**
     * Application constructor.
     *
     * @param ContainerInterface|null $container
     */
    public function __construct(ContainerInterface $container = null)
    {
        parent::__construct($container);

        if (!$this->getContainer()->has(Router::class)) {
            $this->getContainer()->set(Router::class, new Router());

The method set() does not exist on Psr\Container\ContainerInterface. It seems like you code against a sub-type of Psr\Container\ContainerInterface such as Igni\Container\ServiceLocator.

        }

        $this->router = $this->getContainer()->get(Router::class);
        $this->controllerAggregate = new ControllerAggregate($this->router);
    }

    /**
     * While testing call this method before handle method.
     */
    public function startup(): void
    {
        $this->initialize();
        $this->handleOnBootListeners();
    }

    /**
     * While testing, call this method after handle method.
     */
    public function shutdown(): void
    {
        $this->handleOnShutDownListeners();
    }

    /**
     * Startups and run application with/or without dedicated server.
     * Once application is run it will listen to incoming http requests,
     * and takes care of the entire request flow process.
     *
     * @param Server|null $server
     */
    public function run(Server $server = null): void
    {
        $this->startup();

        if ($server) {
            $server->addListener($this);
            $server->start();
        } else {
            $response = $this->handle(ServerRequest::fromGlobals());
            $emitter = new SapiEmitter();
            $emitter->emit($response);
            if ($response instanceof Response) {
                $response->end();
            }
        }

        $this->shutdown();
    }

    /**
     * Registers PSR-15 compatible middelware.
     * Middleware can be either callable object which accepts PSR-7 server request interface and returns
     * response interface, or just class name that implements psr-15 middleware or its instance.
     *
     * @param MiddlewareInterface|callable $middleware
     */
    public function use($middleware): void
    {
        if (!is_subclass_of($middleware, MiddlewareInterface::class)) {
            if (!is_callable($middleware)) {
                throw new ApplicationException('Middleware must be either class or object that implements ' . MiddlewareInterface::class);
            }

            $middleware = new CallableMiddlewareDecorator($middleware);

It seems like $middleware can also be of type Psr\Http\Server\MiddlewareInterface; however, parameter $middleware of Zend\Stratigility\Middleware\CallableMiddlewareDecorator::__construct() does only seem to accept callable, maybe add an additional type check?

        }

        $this->middleware[] = $middleware;
    }

    /**
     * Handles request flow process.
     *
     * @see MiddlewareInterface::process()
     *
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $next
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $next): ResponseInterface
    {
        /** @var Route $route */
        $route = $this->router->findRoute(
            $request->getMethod(),
            $request->getUri()->getPath()
        );

        $controller = $route->getDelegator();

        if ($request instanceof ServerRequest) {
            $request = $request->withAttributes($route->getAttributes());
        }

        if (is_string($controller) &&
            class_exists($controller) &&
            in_array(Controller::class, class_implements($controller))
        ) {
            /** @var Controller $instance */
            $instance = $this->resolver->resolve($controller);
            return $instance($request);
        }

        if (is_callable($controller)) {
            $response = $controller($request);
            if (!$response instanceof ResponseInterface) {
                throw HttpModuleException::controllerMustReturnValidResponse();
            }

            return $response;
        }

        throw HttpModuleException::couldNotRetrieveControllerForRoute($route->getPath());
    }

    /**
     * Runs application listeners and handles request flow process.
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $this->handleOnRunListeners();
        $response = $this->getMiddlewarePipe()->handle($request);
        return $response;
    }

    /**
     * Decorator for handle method, used by server instance.
     * @see Application::handle()
     * @see Server::addListener()
     *
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     */
    public function onRequest(ServerRequestInterface $request): ResponseInterface
    {
        return $this->handle($request);
    }

    /**
     * Registers new controller that accepts get request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function get(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::get($route));
    }

    /**
     * Registers new controller that accepts post request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function post(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::post($route));
    }

    /**
     * Registers new controller that accepts put request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function put(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::put($route));
    }

    /**
     * Registers new controller that accepts patch request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function patch(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::patch($route));
    }

    /**
     * Registers new controller that accepts delete request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function delete(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::delete($route));
    }

    /**
     * Registers new controller that accepts options request
     * when request uri matches passed route pattern.
     *
     * @param string $route
     * @param callable $controller
     */
    public function options(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::options($route));
    }

    public function head(string $route, callable $controller): void
    {
        $this->controllerAggregate->add($controller, Route::head($route));
    }

    /**
     * Returns application's controller aggregate.
     *
     * @return AbstractControllerAggregate
     */
    public function getControllerAggregate(): AbstractControllerAggregate
    {
        return $this->controllerAggregate;
    }

    protected function getMiddlewarePipe(): MiddlewarePipe
    {
        if ($this->pipeline) {
            return $this->pipeline;
        }

        return $this->pipeline = $this->createPipeline();
    }

    private function createPipeline(): MiddlewarePipe
    {
        $pipe = new MiddlewarePipe();
        $pipe->pipe(new ErrorMiddleware(function(Throwable $exception) {
            $this->handleOnErrorListeners($exception);
        }));
        foreach ($this->middleware as $middleware) {
            if (is_string($middleware)) {
                $middleware = $this->resolver->resolve($middleware);
            }
            $pipe->pipe($middleware);
        }
        $pipe->pipe($this);

        return $pipe;
    }
}