Philae\Application

Complexity

Total Complexity

13

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

87.5%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getMiddlewares()	0	4	1
A	setMiddlewares()	0	12	3
A	execute()	0	12	2
A	dispatch()	0	16	3
A	getRouter()	0	4	1
A	getRequest()	0	4	1
A	getUriResolver()	0	4	1
A	getResponse()	0	4	1

<?php

namespace Philae;

use FastRoute\RouteCollector;
use Interop\Http\ServerMiddleware\MiddlewareInterface;
use League\Container\Container;
use League\Container\ContainerAwareInterface;
use Philae\Exceptions\InvalidCallableServiceException;
use Philae\Utils\UriResolverInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class Application extends Container
{
    /**
     * @var MiddlewareInterface[]
     */
    protected $middlewares;

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

    /**
     * @param MiddlewareInterface[] $middlewares
     *
     * @return self|$this
     */
    public function setMiddlewares(array $middlewares): Application
    {
        foreach ($middlewares as $i => $middleware) {
            if ($middleware instanceof ContainerAwareInterface) {
                $middleware->setContainer($this);
            }
        }

        $this->middlewares = $middlewares;

        return $this;
    }

    /**
     * Dispatches the request and sends the response
     *
     * @param ServerRequestInterface|null $request
     * @return self|$this
     * @throws InvalidCallableServiceException
     */
    public function execute(ServerRequestInterface $request = null): Application
    {
        $response = $this->dispatch($request);
        $emitter  = $this->get(DefaultServiceProvider::SERVICE_RESPONSE_EMITTER);

        if (!is_callable($emitter)) {
            throw new InvalidCallableServiceException(DefaultServiceProvider::SERVICE_RESPONSE_EMITTER);
        }
        call_user_func($emitter, $response);

        return $this;
    }

    /**
     * Dispatches the request and returns the response
     *
     * @param ServerRequestInterface|null $request
     * @return ResponseInterface
     * @throws InvalidCallableServiceException
     */
    public function dispatch(ServerRequestInterface $request = null): ResponseInterface
    {
        $request = $request ?: $this->getRequest();
        $this->share(DefaultServiceProvider::SERVICE_REQUEST, $request);

        $dispatcher = $this->get(
            DefaultServiceProvider::SERVICE_MIDDLEWARE_DISPATCHER,
            [$this->getMiddlewares()]
        );

        if (!is_callable($dispatcher)) {
            throw new InvalidCallableServiceException(DefaultServiceProvider::SERVICE_MIDDLEWARE_DISPATCHER);
        }

        return call_user_func($dispatcher, $request);
    }

    /**
     * @return RouteCollector
     */
    public function getRouter(): RouteCollector
    {
        return $this->get(DefaultServiceProvider::SERVICE_ROUTE_COLLECTOR);
    }

    /**
     * @return ServerRequestInterface
     */
    public function getRequest(): ServerRequestInterface
    {
        return $this->get(DefaultServiceProvider::SERVICE_REQUEST);
    }

    /**
     * @return UriResolverInterface
     */
    public function getUriResolver(): UriResolverInterface
    {
        return $this->get(DefaultServiceProvider::SERVICE_URI_RESOLVER);
    }

    /**
     * @return ResponseInterface
     */
    public function getResponse(): ResponseInterface
    {
        return $this->get(DefaultServiceProvider::SERVICE_RESPONSE);
    }
}