Bone\Mvc\Router\PlatesStrategy

Complexity

Total Complexity

14

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	9

Test Coverage

Coverage

66.67%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setI18nEnabled()	0	4	1
A	setSupportedLocales()	0	4	1
A	invokeRouteCallable()	0	25	4
A	getBody()	0	18	4
A	getResponseWithBodyAndStatus()	0	8	1
A	getNotFoundDecorator()	0	4	1
A	getMethodNotAllowedDecorator()	0	4	1

<?php

namespace Bone\Mvc\Router;

use Bone\Mvc\Router\Decorator\NotAllowedDecorator;
use Bone\Mvc\Router\Decorator\NotFoundDecorator;
use Bone\Mvc\View\PlatesEngine;
use Bone\Traits\LayoutAwareTrait;
use Exception;
use League\Route\Http\Exception\{MethodNotAllowedException, NotFoundException};
use League\Route\Route;
use League\Route\Strategy\ApplicationStrategy;
use League\Route\Strategy\StrategyInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Zend\Diactoros\Response;
use Zend\Diactoros\Response\HtmlResponse;
use Zend\Diactoros\Stream;

class PlatesStrategy extends ApplicationStrategy implements StrategyInterface
{
    use LayoutAwareTrait;

    /** @var PlatesEngine $viewEngine */
    private $viewEngine;

    /** @var NotFoundDecorator $notFoundDecorator */
    private $notFoundDecorator;

    /** @var NotAllowedDecorator $notAllowedDecorator */
    private $notAllowedDecorator;

    /** @var bool  */
    private $i18nEnabled = false;

    /** @var array  */
    private $supportedLocales = [];

    /**
     * PlatesStrategy constructor.
     * @param PlatesEngine $viewEngine
     * @param NotFoundDecorator $notFound
     * @param NotAllowedDecorator $notAllowed
     * @param string $layout
     */
    public function __construct(PlatesEngine $viewEngine, NotFoundDecorator $notFound, NotAllowedDecorator $notAllowed, string $layout)
    {
        $this->viewEngine = $viewEngine;
        $this->notFoundDecorator = $notFound;
        $this->notAllowedDecorator = $notAllowed;
        $this->setLayout($layout);
    }

    /**
     * @param bool $i18nEnabled
     */
    public function setI18nEnabled(bool $i18nEnabled): void
    {
        $this->i18nEnabled = $i18nEnabled;
    }

    /**
     * @param array $locales
     */
    public function setSupportedLocales(array $locales): void
    {
        $this->supportedLocales = $locales;
    }


    /**
     * Invoke the route callable based on the strategy.
     *
     * @param \League\Route\Route $route
     * @param \Psr\Http\Message\ServerRequestInterface $request
     *
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function invokeRouteCallable(Route $route, ServerRequestInterface $request): ResponseInterface
    {
        try {

            $response = parent::invokeRouteCallable($route, $request);
            $body = $this->getBody($response);
            $body = $this->viewEngine->render($this->layout, $body);

            return $this->getResponseWithBodyAndStatus($response, $body, $response->getStatusCode());

$response of type object<Psr\Http\Message\ResponseInterface> is not a sub-type of object<Zend\Diactoros\Response>. It seems like you assume a concrete implementation of the interface Psr\Http\Message\ResponseInterface to be always present.

        } catch (Exception $e) {
            $body = $this->viewEngine->render('error/error', [
                'message' => $e->getMessage(),
                'code' => $e->getCode(),
                'trace' => $e->getTrace(),
            ]);
            $body = $this->viewEngine->render($this->layout, [
                'content' => $body,
            ]);
            $status = ($e->getCode() >= 100 && $e->getCode() < 600) ? $e->getCode() : 500;

            return $this->getResponseWithBodyAndStatus(new HtmlResponse($body), $body, $status);
        }

    }

    /**
     * @param ResponseInterface $response
     * @return array|mixed
     */
    private function getBody(ResponseInterface $response)
    {
        switch (true) {
            case $response instanceof Response\JsonResponse:
                $contents = $response->getBody()->getContents();
                $body = json_decode($contents, true);
                $body = ($body === null) ? [] : $body;
                break;

            case $response instanceof Response:
                $body = ['content' => $response->getBody()->getContents()];
                break;
            default:

        }

        return $body;

The variable $body does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * @param ResponseInterface $response
     * @param string $body
     * @param int $status
     * @return \Psr\Http\Message\MessageInterface|Response
     */
    private function getResponseWithBodyAndStatus(Response $response, string $body, int $status = 200)
    {
        $stream = new Stream('php://memory', 'r+');
        $stream->write($body);
        $response = $response->withStatus($status)->withBody($stream);

        return $response;
    }

    /**
     * Get a middleware that will decorate a NotFoundException
     *
     * @param \League\Route\Http\Exception\NotFoundException $exception

There is no parameter named $exception. Was it maybe removed?

     *
     * @return \Psr\Http\Server\MiddlewareInterface
     */
    public function getNotFoundDecorator(NotFoundException $e): MiddlewareInterface
    {
        return $this->notFoundDecorator;
    }

    /**
     * Get a middleware that will decorate a NotAllowedException
     *
     * @param \League\Route\Http\Exception\NotFoundException $e
     *
     * @return \Psr\Http\Server\MiddlewareInterface
     */
    public function getMethodNotAllowedDecorator(MethodNotAllowedException $e): MiddlewareInterface
    {
        return $this->notAllowedDecorator;
    }
}