Bone\Mvc\Router\PlatesStrategy

Complexity

Total Complexity

13

Size/Duplication

Total Lines	142
Duplicated Lines	5.63 %

Coupling/Cohesion

Components	3
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setI18nEnabled()	0	4	1
A	setSupportedLocales()	0	4	1
B	invokeRouteCallable()	0	31	6
A	getResponseWithBodyAndStatus()	8	8	1
A	getNotFoundDecorator()	0	4	1
A	getMethodNotAllowedDecorator()	0	4	1
A	getExceptionHandler()	0	4	1

<?php

namespace Bone\Mvc\Router;

use Bone\Mvc\Router\Decorator\ExceptionDecorator;
use Bone\Mvc\Router\Decorator\NotAllowedDecorator;
use Bone\Mvc\Router\Decorator\NotFoundDecorator;
use Bone\Mvc\View\PlatesEngine;
use Bone\Traits\HasLayoutTrait;
use Exception;
use League\Route\Http\Exception\{MethodNotAllowedException, NotFoundException};

This use statement conflicts with another class in this namespace, Bone\Mvc\Router\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 Laminas\Diactoros\Response;
use Laminas\Diactoros\Response\HtmlResponse;
use Laminas\Diactoros\Response\JsonResponse;
use Laminas\Diactoros\Stream;

class PlatesStrategy extends ApplicationStrategy implements StrategyInterface
{
    use HasLayoutTrait;

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

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

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

    /** @var ExceptionDecorator $exceptionDecorator */
    private $exceptionDecorator;

    /** @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, ExceptionDecorator $exceptionDecorator)
    {
        $this->viewEngine = $viewEngine;
        $this->notFoundDecorator = $notFound;
        $this->notAllowedDecorator = $notAllowed;
        $this->exceptionDecorator = $exceptionDecorator;
        $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);
            $contentType = $response->getHeader('Content-Type');

            if ($contentType && strstr($contentType[0], 'application/json')) {

The expression $contentType of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                return $response;
            }

            $body = ['content' => $response->getBody()->getContents()];
            $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<Laminas\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
     * @param string $body
     * @param int $status
     * @return \Psr\Http\Message\MessageInterface|Response
     */
    private function getResponseWithBodyAndStatus(Response $response, string $body, int $status = 200)

This method seems to be duplicated in your project.

    {
        $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;
    }

    /**
     * @return MiddlewareInterface
     */
    public function getExceptionHandler(): MiddlewareInterface
    {
        return $this->exceptionDecorator;
    }
}