Wandu\Foundation\Error\DefaultHttpErrorHandler

Complexity

Total Complexity

23

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

75%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	handle()	0	37	8
A	isAjax()	0	5	2
A	prettifyRequest()	0	13	3
A	getWhoops()	0	21	3
B	getAcceptType()	0	18	6

<?php
namespace Wandu\Foundation\Error;

use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\LoggerInterface;
use Wandu\Config\Contracts\ConfigInterface;
use Wandu\Foundation\Contracts\HttpErrorHandlerInterface;
use Wandu\Http\Exception\HttpException;
use Wandu\Router\Exception\MethodNotAllowedException as RouteMethodException;
use Wandu\Router\Exception\RouteNotFoundException;
use Whoops\Handler\JsonResponseHandler;
use Whoops\Handler\PlainTextHandler;
use Whoops\Handler\PrettyPageHandler;
use Whoops\Run;
use function Wandu\Http\Response\create;
use function Wandu\Http\Response\json;

class DefaultHttpErrorHandler implements HttpErrorHandlerInterface
{
    /** @var \Psr\Log\LoggerInterface */
    protected $logger;
    
    /** @var \Wandu\Config\Contracts\ConfigInterface */
    protected $config;
    
    /**
     * @param \Wandu\Config\Contracts\ConfigInterface $config
     * @param \Psr\Log\LoggerInterface $logger
     */
    public function __construct(ConfigInterface $config, LoggerInterface $logger = null)
    {
        $this->config = $config;
        $this->logger = $logger;
    }

    /**
     * {@inheritdoc}
     */
    public function handle(ServerRequestInterface $request, $exception)
    {
        if ($exception instanceof HttpException) {
            if ($this->logger) {
                $this->logger->notice($this->prettifyRequest($request));
                $this->logger->notice($exception);
            }
            return $exception;
        }
        if ($this->config->get('debug', true)) {
            $whoops = $this->getWhoops($request);
            return create($whoops->handleException($exception), 500);

It seems like $exception defined by parameter $exception on line 39 can also be of type object<Exception>; however, Whoops\Run::handleException() does only seem to accept object<Throwable>, maybe add an additional type check?

It seems like $whoops->handleException($exception) targeting Whoops\Run::handleException() can also be of type false; however, Wandu\Http\Response\create() does only seem to accept string|null, did you maybe forget to handle an error condition?

        }

        $statusCode = 500;
        $reasonPhrase = 'Internal Server Error';

        if ($exception instanceof RouteNotFoundException) {
            $statusCode = 404;
            $reasonPhrase = "Not Found";
        } elseif ($exception instanceof RouteMethodException) {
            $statusCode = 405;
            $reasonPhrase = 'Method Not Allowed';
        }
        if ($this->logger) {
            $this->logger->error($this->prettifyRequest($request));
            $this->logger->error($exception);

It seems like $exception defined by parameter $exception on line 39 can also be of type object<Exception>; however, Psr\Log\LoggerInterface::error() does only seem to accept string, maybe add an additional type check?

        }

        if ($this->isAjax($request)) {
            return json([
                'status' => $statusCode,
                'reason' => $reasonPhrase,
            ], $statusCode);
        }
        return create("{$statusCode} {$reasonPhrase}", $statusCode);
    }

    /**
     * @param \Psr\Http\Message\ServerRequestInterface $request
     * @return bool
     */
    protected function isAjax(ServerRequestInterface $request)
    {
        return $request->hasHeader('x-requested-with') &&
            $request->getHeaderLine('x-requested-with') === 'XMLHttpRequest';
    }

    /**
     * @param \Psr\Http\Message\ServerRequestInterface $request
     * @return string
     */
    protected function prettifyRequest(ServerRequestInterface $request)
    {
        $contents = "{$request->getMethod()} : {$request->getUri()->__toString()}\n";
        $contents .= "HEADERS\n";
        foreach ($request->getHeaders() as $name => $value) {
            $contents .= "    {$name} : {$request->getHeaderLine($name)}\n";
        }
        if ($body = $request->getBody()) {
            $contents .= "BODY\n";
            $contents .= "\"{$body->__toString()}\"\n";
        }
        return $contents;
    }
    
    protected function getWhoops(ServerRequestInterface $request)
    {
        $whoops = new Run();

        switch ($this->getAcceptType($request)) {
            case 'html':
                $whoops->pushHandler(new PrettyPageHandler());

new \Whoops\Handler\PrettyPageHandler() is of type object<Whoops\Handler\PrettyPageHandler>, but the function expects a callable.

                break;
            case 'json':
                $whoops->pushHandler(new JsonResponseHandler());

new \Whoops\Handler\JsonResponseHandler() is of type object<Whoops\Handler\JsonResponseHandler>, but the function expects a callable.

                break;
            default:
                $whoops->pushHandler(new PlainTextHandler());

new \Whoops\Handler\PlainTextHandler() is of type object<Whoops\Handler\PlainTextHandler>, but the function expects a callable.

        }

        $whoops->allowQuit(false);
        $whoops->writeToOutput(false);
        $whoops->sendHttpCode(false);

        return $whoops;
    }

    /**
     * @ref github.com/oscarotero/psr7-middlewares/blob/master/src/Middleware/FormatNegotiator.php
     *
     * @param \Psr\Http\Message\ServerRequestInterface $request
     * @return string
     */
    protected function getAcceptType(ServerRequestInterface $request)
    {
        $accept = $request->getHeaderLine('Accept');
        if (
            strpos($accept, 'text/html') !== false ||
            strpos($accept, 'application/xhtml+xml') !== false
        ) {
            return 'html';
        }
        if (
            strpos($accept, 'application/json') !== false ||
            strpos($accept, 'text/json') !== false ||
            strpos($accept, 'application/x-json') !== false
        ) {
            return 'json';
        }
        return 'text';
    }
}