Slick\WebStack\Http\Server\DispatcherMiddleware

Complexity

Total Complexity

8

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	process()	0	16	2
A	route()	0	12	2
A	merge()	0	5	1
A	responseFrom()	0	13	2

<?php

/**
 * This file is part of slick/web_stack package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\WebStack\Http\Server;

use Aura\Router\Route;
use Interop\Http\Server\MiddlewareInterface;
use Interop\Http\Server\RequestHandlerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Slick\WebStack\Controller\ContextCreator;
use Slick\WebStack\Controller\ControllerContextInterface;
use Slick\WebStack\Dispatcher\ControllerDispatchInflectorInterface;
use Slick\WebStack\Dispatcher\ControllerInvokerInterface;
use Slick\WebStack\Exception\BadHttpStackConfigurationException;
use Slick\WebStack\Exception\MissingResponseException;

/**
 * DispatcherMiddleware
 *
 * @package Slick\WebStack\Http\Server
 */
class DispatcherMiddleware implements MiddlewareInterface
{
    /**
     * @var ControllerDispatchInflectorInterface
     */
    private $inflector;

    /**
     * @var ControllerInvokerInterface
     */
    private $invoker;

    /**
     * @var ContextCreator
     */
    private $contextCreator;

    /**
     * DispatcherMiddleware constructor.
     * @param ControllerDispatchInflectorInterface $inflector
     * @param ControllerInvokerInterface $invoker
     * @param ContextCreator $contextCreator
     */
    public function __construct(
        ControllerDispatchInflectorInterface $inflector,
        ControllerInvokerInterface $invoker,
        ContextCreator $contextCreator
    ) {
        $this->inflector = $inflector;
        $this->invoker = $invoker;
        $this->contextCreator = $contextCreator;
    }

    /**
     * Process an incoming server request and return a response, optionally delegating
     * response creation to a handler.
     *
     * @param ServerRequestInterface $request
     * @param RequestHandlerInterface $handler
     *
     * @return ResponseInterface
     *
     * @throws BadHttpStackConfigurationException When the need route is missing from the request
     * @throws MissingResponseException When context has disabled the rendering and has no response object to return
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler)
    {
        $route = $this->route($request);
        $controllerDispatch = $this->inflector->inflect($route);
        $context = $this->contextCreator->create($request, $route);

        $data = $this->invoker->invoke($context, $controllerDispatch);

        if ($context->handlesResponse()) {
            return $this->responseFrom($context);
        }

        $request = $request->withAttribute('viewData', $this->merge($request, $data));

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

    /**
     * Get route attribute from request
     *
     * @param ServerRequestInterface $request
     *
     * @return Route
     *
     * @throws BadHttpStackConfigurationException When the need route is missing from the request
     */
    private function route(ServerRequestInterface $request)
    {
        $route = $request->getAttribute('route', false);
        if (! $route instanceof Route) {
            throw new BadHttpStackConfigurationException(
                "Dispatcher works with router middleware in order to process incoming requests. " .
                "Please check that the HTTP stack has the router middleware placed before the dispatcher. ".
                "Missing route in the request."
            );
        }
        return $route;
    }

    /**
     * Merges any existing view data in the request with the provided one
     *
     * @param ServerRequestInterface $request
     * @param array                  $data
     *
     * @return array
     */
    private function merge(ServerRequestInterface $request, array $data)
    {
        $existing = $request->getAttribute('viewData', []);
        return array_merge($existing, $data);
    }

    /**
     * Verify and return the response from the context
     *
     * @param ControllerContextInterface $context
     *
     * @return ResponseInterface
     *
     * @throws MissingResponseException When context has no response object to return
     */
    private function responseFrom(ControllerContextInterface $context)
    {
        $response = $context->response();
        if (! $response instanceof ResponseInterface) {
            throw new MissingResponseException(
                "Missing response object after handle the request. If you disabled rendering you need to ".
                "provide an HTTP response object to be returned to the client. Use Context::setResponse() ".
                "to provide a response to be returned."
            );
        }

        return $response;
    }
}