Conia\Chuck\ErrorHandler

Complexity

Total Complexity

13

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
B	handleException()	0	41	6
A	__construct()	0	2	1
A	handleError()	0	11	2
A	getLoggerMethod()	0	10	1
A	setup()	0	5	1
A	log()	0	7	2

<?php

declare(strict_types=1);

namespace Conia\Chuck;

use Conia\Chuck\Config;
use Conia\Chuck\Exception\ExitException;
use Conia\Chuck\Exception\HttpBadRequest;
use Conia\Chuck\Exception\HttpError;
use Conia\Chuck\Exception\HttpForbidden;
use Conia\Chuck\Exception\HttpMethodNotAllowed;
use Conia\Chuck\Exception\HttpNotFound;
use Conia\Chuck\Exception\HttpServerError;
use Conia\Chuck\Exception\HttpUnauthorized;
use Conia\Chuck\Registry\Registry;
use Conia\Chuck\ResponseFactory;
use ErrorException;
use Throwable;

class ErrorHandler
{
    public function __construct(protected Config $config, protected Registry $registry)
    {
    }

    public function setup(): callable|null
    {
        set_error_handler([$this, 'handleError'], E_ALL);

        return set_exception_handler([$this, 'handleException']);
    }

    public function handleError(
        int $level,
        string $message,
        string $file = '',
        int $line = 0,
    ): bool {
        if ($level & error_reporting()) {
            throw new ErrorException($message, $level, $level, $file, $line);
        }

        return false;
    }

    public function handleException(Throwable $exception): void
    {
        $response = (new ResponseFactory($this->registry))->html(null);
        $debug = $this->config->debug();

        if ($exception instanceof HttpError) {
            $code = $exception->getCode();
            $response->status($code);
            $body = '<h1>' . htmlspecialchars($exception->getTitle()) . '</h1>';
            $subTitle = $exception->getSubtitle();

            if ($subTitle) {
                $body .= '<h2>' . htmlspecialchars($subTitle) . '</h2>';
            } else {
                $body .= '<h2>HTTP Error</h2>';
            }
        } elseif ($exception instanceof ExitException) {
            // Would stop the test suit
            // @codeCoverageIgnoreStart
            exit;

Using exit here is not recommended.

        // @codeCoverageIgnoreEnd
        } else {
            $code = 500;
            $response->status($code);
            $body = '<h1>500 Internal Server Error</h1>';
            $body .= '<h2>' . htmlspecialchars($exception->getMessage()) . '</h2>';
        }

        if ($debug && $code === 500) {
            $trace = str_replace(
                ['<', '>', '"'],
                ['&lt;', '&gt', '&quot;'],
                $exception->getTraceAsString()
            );
            $trace = implode('<br>#', explode('#', $trace));
            $body .= preg_replace('/^<br>/', '', $trace);
        }

        $this->log($exception);

        (new Emitter())->emit($response->body($body)->psr7());
    }

    public function log(Throwable $exception): void
    {
        $logger = $this->config->logger();

        if ($logger) {

$logger is of type Psr\Log\LoggerInterface, thus it always evaluated to true.

            $method = $this->getLoggerMethod($exception);
            ([$logger, $method])('Uncaught Exception:', ['exception' => $exception]);
        }
    }

    protected function getLoggerMethod(Throwable $exception): string
    {
        return match ($exception::class) {
            HttpNotFound::class => 'info',
            HttpMethodNotAllowed::class => 'info',
            HttpForbidden::class => 'notice',
            HttpUnauthorized::class => 'notice',
            HttpBadRequest::class => 'warning',
            HttpServerError::class => 'error',
            default => 'error',
        };
    }
}