Bapao\Bapao\Application

Complexity

Total Complexity

10

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setContainer()	0	4	1
A	getContainer()	0	4	1
A	getRouter()	0	4	1
A	addMiddleware()	0	4	1
A	getMiddlewareStack()	0	4	1
A	run()	0	8	1
A	handleRequest()	0	12	2
A	send()	0	12	2

<?php

namespace Bapao\Bapao;

use Bapao\Bapao\Exception\InvalidMiddlewareDispatcherException;
use Bapao\Bapao\Exception\InvalidResponseEmitterException;
use Bapao\Bapao\Interfaces\MiddlewareDispatcherInterface;
use Bapao\Bapao\Interfaces\ResponseEmitterInterface;
use Interop\Container\ContainerInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Class Application.
 */
class Application
{
    /** @const string */
    const VERSION = '0.1.5';

    /** @var ContainerInterface */
    protected $container;

    /** @var array */
    protected $middlewareStack = [];

    /**
     * Set dependency injection container.
     *
     * @param ContainerInterface $container
     */
    public function setContainer(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * Get dependency injection container.
     *
     * @return ContainerInterface
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * Get Router.
     *
     * @return mixed
     */
    public function getRouter()
    {
        return $this->container->get('router');
    }

    /**
     * Add middleware to stack.
     *
     * @param mixed $middleware
     */
    public function addMiddleware($middleware)
    {
        $this->middlewareStack[] = $middleware;
    }

    /**
     * Get middleware stack.
     *
     * @return array
     */
    public function getMiddlewareStack()
    {
        return $this->middlewareStack;
    }

    /**
     * Run application.
     */
    public function run()
    {
        $this->addMiddleware($this->container->get('router.middleware'));

        $response = $this->handleRequest($this->container->get('request'));

        $this->send($response);
    }

    /**
     * Handle request via middleware.
     *
     * @param RequestInterface $request
     * @return ResponseInterface
     * @throws InvalidMiddlewareDispatcherException
     */
    public function handleRequest(RequestInterface $request)
    {
        $middlewareDispatcher = $this->container->get('middleware.dispatcher');

        if (!$middlewareDispatcher instanceof MiddlewareDispatcherInterface) {
            throw new InvalidMiddlewareDispatcherException(
                'Middleware dispatcher must implement '.MiddlewareDispatcherInterface::class
            );
        }

        return $middlewareDispatcher->dispatch($this->middlewareStack, $request, $this->container->get('response'));
    }

    /**
     * Send response to client.
     *
     * @param ResponseInterface $response
     * @throws InvalidResponseEmitterException
     */
    public function send(ResponseInterface $response)
    {
        $responseEmitter = $this->container->get('response.emitter');

        if (!$responseEmitter instanceof ResponseEmitterInterface) {
            throw new InvalidResponseEmitterException(
                'Response emitter must implement '.ResponseEmitterInterface::class
            );
        }

        $responseEmitter->emit($response);
    }
}