BEAR\Middleware\Handler\ResourceHandler

Complexity

Total Complexity

5

Size/Duplication

Total Lines	84
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	__invoke()	0	6	1
A	handle()	0	15	1
A	toPsr7Response()	0	13	2

<?php
/**
 * This file is part of the BEAR.Middleware package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace BEAR\Middleware\Handler;

use BEAR\Middleware\Module\StreamRenderer;
use BEAR\Resource\RenderInterface;
use BEAR\Resource\ResourceInterface;
use BEAR\Resource\ResourceObject;
use BEAR\Sunday\Extension\Router\RouterInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Stream;

final class ResourceHandler
{
    /**
     * @var ResourceInterface
     */
    private $resource;

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

    /**
     * @var StreamRenderer
     */
    private $render;

    /**
     * @param ResourceInterface $resource
     * @param RouterInterface   $router
     * @param RenderInterface   $render
     */
    public function __construct(
        ResourceInterface $resource,
        RouterInterface $router,
        RenderInterface $render
    ) {
        $this->resource = $resource;
        $this->router = $router;
        $this->render = $render;

$render is of type object<BEAR\Resource\RenderInterface>, but the property $render was declared to be of type object<BEAR\Middleware\Module\StreamRenderer>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    /**
     * {@inheritdoc}
     */
    public function __invoke(RequestInterface $request, Response $response, callable $next = null)
    {
        $response = $this->handle($request, $response);

$request of type object<Psr\Http\Message\RequestInterface> is not a sub-type of object<Psr\Http\Message\ServerRequestInterface>. It seems like you assume a child interface of the interface Psr\Http\Message\RequestInterface to be always present.

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

    /**
     * @param RequestInterface $request
     * @param Response         $response
     *
     * @return Response
     */
    public function handle(ServerRequestInterface $request, Response $response)
    {
        $server = $request->getServerParams();
        $server['REQUEST_METHOD'] = $request->getMethod();
        $server['REQUEST_URI'] = $request->getUri()->getPath();
        $globals = [
            '_GET' => $request->getQueryParams(),
            '_POST' => $request->getParsedBody()
        ];
        $req = $this->router->match($globals, $server);
        $resourceObject = $this->resource->{$req->method}->uri($req->path)->withQuery($req->query)->eager->request();
        $response = $this->toPsr7Response($response, $resourceObject);

        return $response;
    }

    /**
     * @param Response       $response
     * @param ResourceObject $resourceObject
     *
     * @return Response
     */
    private function toPsr7Response(Response $response, ResourceObject $resourceObject)
    {
        $bodyString = (string) $resourceObject;
        /** @var $response Response */
        $response = $response->withStatus($resourceObject->code);
        foreach ($resourceObject->headers as $name => $value) {
            $response = $response->withHeader($name, $value);
        }
        $stream = $this->render->toStream($bodyString);
        $response = $response->withBody(new Stream($stream));

        return $response;
    }
}