Syscodes\Components\Core\Exceptions\Handler

Complexity

Total Complexity

45

Size/Duplication

Total Lines	398
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	shouldReport()	0	3	1
A	prepareException()	0	7	2
A	reportable()	0	5	1
A	registerViewErrorPaths()	0	3	1
B	render()	0	29	8
A	getHttpExceptionView()	0	3	1
A	prepareResponse()	0	12	4
A	shouldntReport()	0	11	3
A	report()	0	23	6
A	__construct()	0	5	1
A	renderHttpException()	0	14	2
A	renderExceptionContent()	0	8	4
A	renderable()	0	5	1
A	convertExceptionToResponse()	0	6	3
A	register()	0	1	1
A	renderExceptionWithFlatDesignDebug()	0	4	1
A	renderForConsole()	0	12	1
A	toSyscodesResponse()	0	13	2
A	isHttpException()	0	3	1
A	renderExceptionWithDebug()	0	3	1

<?php 

/**
 * Lenevor Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file license.md.
 * It is also available through the world-wide-web at this URL:
 * https://lenevor.com/license
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@Lenevor.com so we can send you a copy immediately.
 *
 * @package     Lenevor
 * @subpackage  Base
 * @link        https://lenevor.com
 * @copyright   Copyright (c) 2019 - 2023 Alexander Campo <jalexcam@gmail.com>
 * @license     https://opensource.org/licenses/BSD-3-Clause New BSD license or see https://lenevor.com/license or see /license.md
 */

namespace Syscodes\Components\Core\Exceptions;

use Exception;
use Throwable;
use Psr\Log\LoggerInterface;
use Syscodes\Components\Http\Response;
use Syscodes\Components\Routing\Router;
use Syscodes\Components\Http\RedirectResponse;
use Syscodes\Components\Debug\ExceptionHandler;
use Syscodes\Components\Contracts\Container\Container;
use Syscodes\Components\Contracts\Core\ExceptionRender;
use Syscodes\Components\Core\Http\Exceptions\HttpException;
use Syscodes\Components\Http\Exceptions\HttpResponseException;
use Syscodes\Components\Debug\FatalExceptions\FlattenException;
use Syscodes\Components\Core\Http\Exceptions\NotFoundHttpException;
use Syscodes\Components\Database\Erostrine\Exceptions\ModelNotFoundException;
use Syscodes\Components\Contracts\Debug\ExceptionHandler as ExceptionHandlerContract;

/**
 * The system's main exception class is loaded for activate the render method of debugging.
 */
class Handler implements ExceptionHandlerContract
{
    /**
     * The container implementation.
     * 
     * @var \Syscodes\Contracts\Container\Container $container

The type Syscodes\Contracts\Container\Container was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected $container;

    /**
     * A list of the exception types that should not be reported.
     * 
     * @var array $dontReport
     */
    protected $dontReport = [];

    /**
     * A list of the Core exception types that should not be reported.
     * 
     * @var array $coreDontReport
     */
    protected $coreDontReport = [
        HttpException::class,
        HttpResponseException::class,
        ModelNotFoundException::class,
    ];

    /**
     * The callbacks that should be used during reporting.
     * 
     * @var array $reportCallbacks
     */
    protected $reportCallbacks = [];

    /**
     * The callbacks that should be used during rendering.
     * 
     * @var array $renderCallbacks
     */
    protected $renderCallbacks = [];

    /**
     * Constructor. Create a new exception handler instance.
     * 
     * @param  \Syscodes\Components\Contracts\Container\Container  $container
     * 
     * @return void
     */
    public function __construct(Container $container)
    {
        $this->container = $container;

It seems like $container of type Syscodes\Components\Contracts\Container\Container is incompatible with the declared type Syscodes\Contracts\Container\Container of property $container.

        $this->register();
    }

    /**
     * Register the exception handling with callbacks for the application.
     * 
     * @return void
     */
    public function register() {}

    /**
     * Register a reportable callback.
     * 
     * @param  \callable  $callback

The type callable was not found. Maybe you did not declare it correctly or list all dependencies?

     * 
     * @return static
     */
    public function reportable(callable $callback): static
    {
        $this->reportCallbacks[] = $callback;

        return $this;
    }

    /**
     * Register a renderable callback.
     * 
     * @param  \callable  $callback
     * 
     * @return static
     */
    public function renderable(callable $callback): static
    {
        $this->renderCallbacks[] = $callback;

        return $this;
    }
    
    /**
     * Report or log an exception.
     * 
     * @param  \Throwable  $e
     * 
     * @return mixed
     * 
     * @throws \Exception
     */
    public function report(Throwable $e)
    {
        if ($this->shouldntReport($e)) {
            return;
        }

        if (method_exists($e, 'report')) {
            return $e->report($e);
        }
        
        foreach ($this->reportCallbacks as $reportCallback) {
            if ($reportCallback($e) === false) {
                return;
            }
        }

        try {
            $logger = $this->container->make(LoggerInterface::class);
        } catch (Exception $e) {
            throw $e;
        }
        
        $logger->error($e->getMessage());
    }

    /**
     * Determine if the exception should be reported.
     * 
     * @param  \Throwable  $e
     * 
     * @return bool
     */
    public function shouldReport(Throwable $e): bool
    {
        return ! $this->shouldntReport($e);
    }

    /**
     * Determine if the exception is in the "do not report" list.
     * 
     * @param  \Throwable  $e
     * 
     * @return bool
     */
    public function shouldntReport(Throwable $e): bool
    {
        $dontReport = array_merge($this->dontReport, $this->coreDontReport);

        foreach ($dontReport as $type) {
            if ($e instanceof $type) {
                return true;
            }
        }

        return false;
    }

    /**
     * Render an exception into an HTTP response.
     * 
     * @param  \Syscodes\Components\Http\Request  $request
     * @param  \Throwable  $e
     * 
     * @return \Syscodes\Components\Http\Response
     */
    public function render($request, Throwable $e)
    {
        if (method_exists($e, 'render') && $response = $e->render($request)) {
            return Router::toResponse($request, $response);

The method toResponse() does not exist on Syscodes\Components\Routing\Router. Since you implemented __callStatic, consider adding a @method annotation.

        }
        
        $e = $this->prepareException($e);
        
        foreach ($this->renderCallbacks as $renderCallback) {
            $response = $renderCallback($e, $request);
            
            if ( ! is_null($response)) {
                return $response;
            }
        }

        foreach ($this->renderCallbacks as $renderCallback) {
            $response = $renderCallback($e, $request);

            if ( ! is_null($response)) {
                return $response;
            }
        }

        if ($e instanceof HttpResponseException) {
            $e->getResponse();
        }

        return $this->prepareResponse($request, $e);
    }

    /**
     * Prepare exception for rendering.
     * 
     * @param  \Throwable  $e
     * 
     * @return \Throwable
     */
    protected function prepareException(Throwable $e): Throwable
    {
        if ($e instanceof ModelNotFoundException) {
            $e = new NotFoundHttpException($e->getMessage(), $e);
        }

        return $e;
    }
     
    /**
     * Prepare a response for the given exception.
     * 
     * @param  \Syscodes\Components\Http\Request  $request
     * @param  \Throwable  $e
     * 
     * @return \Syscodes\Components\Http\Response
     * 
     * @uses   \Syscodes\Components\Core\Http\Exceptions\HttpException
     */
    protected function prepareResponse($request, Throwable $e)

The parameter $request is not used and could be removed.

    {
        if ( ! $this->isHttpException($e) && config('app.debug')) {
            return $this->toSyscodesResponse($this->convertExceptionToResponse($e), $e);
        }

        // When the debug is not active, the HTTP 500 code view is throw
        if ( ! $this->isHttpException($e)) {
            $e = new HttpException(500, $e->getMessage());
        }

        return $this->toSyscodesResponse($this->renderHttpException($e), $e);
    }

    /**
     * Render the given HttpException.
     * 
     * @param  \Syscodes\Components\Core\Http\Exceptions\HttpException  $e
     * 
     * @return \Syscodes\Components\Http\Response
     */
    protected function renderHttpException(HttpException $e)
    {
        $this->registerViewErrorPaths();

        if (view()->viewExists($view = $this->getHttpExceptionView($e))) {

The method viewExists() does not exist on Syscodes\Components\View\View. Since you implemented __call, consider adding a @method annotation.

            return response()->view(

The method view() does not exist on Syscodes\Components\Http\Response. It seems like you code against a sub-type of Syscodes\Components\Http\Response such as Syscodes\Components\Http\RedirectResponse.

                $view, 
                ['exception' => $e],
                $e->getStatusCode(),
                $e->getHeaders()
            );
        }

        return $this->convertExceptionToResponse($e);
    }

    /**
     * Register the error view paths.
     * 
     * @return void
     */
    protected function registerViewErrorPaths(): void
    {
        (new RegisterErrorViewPaths)();
    }

    /**
     * Get the view used to render HTTP exceptions.
     * 
     * @param  \Syscodes\Components\Core\Http\Exceptions\HttpException  $e
     * 
     * @return string
     */
    protected function getHttpExceptionView(HttpException $e): string
    {
        return "errors::{$e->getStatusCode()}";
    }

    /**
     * Create a response for the given exception.
     * 
     * @param  \Throwable  $e
     * 
     * @return \Syscodes\Components\Http\Response
     */
    protected function convertExceptionToResponse(Throwable $e)
    {
        return Response::render(
            $this->renderExceptionContent($e),
            $this->isHttpException($e) ? $e->getStatusCode() : 500,

The method getStatusCode() does not exist on Throwable. It seems like you code against a sub-type of Throwable such as Syscodes\Components\Core\Http\Exceptions\HttpException.

            $this->isHttpException($e) ? $e->getHeaders() : []

The method getHeaders() does not exist on Throwable. It seems like you code against a sub-type of Throwable such as Syscodes\Components\Core\Http\Exceptions\HttpException.

        );
    }

    /**
     * Gets the response content for the given exception.
     * 
     * @param  \Throwable  $e
     * 
     * @return string
     */
    protected function renderExceptionContent(Throwable $e): string
    {
        try {
            return config('app.debug') && app()->has(ExceptionRender::class)
                        ? $this->renderExceptionWithDebug($e) 

Are you sure the usage of $this->renderExceptionWithDebug($e) targeting Syscodes\Components\Core\Exceptions\Handler::renderExceptionWithDebug() seems to always return null.

                        : $this->renderExceptionWithFlatDesignDebug($e, config('app.debug'));

It seems like config('app.debug') can also be of type Syscodes\Components\Config\Configure; however, parameter $debug of Syscodes\Components\Core\Exceptions\Handler::renderExceptionWithFlatDesignDebug() does only seem to accept boolean, maybe add an additional type check?

        } catch (Exception $e) {
            $this->renderExceptionWithFlatDesignDebug($e, config('app.debug'));

In this branch, the function will implicitly return null which is incompatible with the type-hinted return string. Consider adding a return statement or allowing null as return value.

        }
    }

    /**
     * Render an exception to a string of debug.
     * 
     * @param  \Throwable  $e
     * 
     * @return void
     * 
     * @uses   \Syscodes\Components\Contracts\Core\ExceptionRender
     */
    protected function renderExceptionWithDebug(Throwable $e)
    {
        return app(ExceptionRender::class)->render($e);

The method render() does not exist on Syscodes\Components\Contracts\Core\Application.

    }

    /**
     * Render an exception to a string using Flat Design Debug.
     * 
     * @param  \Throwable  $e
     * @param  bool  $debug
     * 
     * @return string
     */
    protected function renderExceptionWithFlatDesignDebug(Throwable $e, $debug)
    {
        return (new ExceptionHandler($debug))->getHtmlResponse(

The expression return new Syscodes\Components\Debug\ExceptionHandler($debug)->getHtmlResponse(Syscodes\Components\Debug\FatalExceptions\FlattenException::make($e)) returns the type void which is incompatible with the documented return type string.

Are you sure the usage of new Syscodes\Components\Debug\ExceptionHandler($debug)->getHtmlResponse(Syscodes\Components\Debug\FatalExceptions\FlattenException::make($e)) targeting Syscodes\Components\Debug\ExceptionHandler::getHtmlResponse() seems to always return null.

            FlattenException::make($e)

Are you sure the usage of Syscodes\Components\Debug\FatalExceptions\FlattenException::make($e) targeting Syscodes\Components\Debug\FatalExceptions\FlattenException::make() seems to always return null.

Syscodes\Components\Debug\FatalExceptions\FlattenException::make($e) of type void is incompatible with the type Exception|Syscodes\Components\Debug\FlattenExceptions\FlattenException expected by parameter $exception of Syscodes\Components\Debug\ExceptionHandler::getHtmlResponse().

        );
    }

    /**
     * Map the given exception into an Syscodes response.
     * 
     * @param  \Syscodes\Components\Http\Response  $response
     * @param  \Exception  $e 
     * 
     * @return \Syscodes\Components\Http\Response
     */
    protected function toSyscodesResponse($response, Throwable $e)
    {
        if ($response instanceof RedirectResponse) {
            $response = new RedirectResponse(
                $response->getTargetUrl(), $response->status(), $response->headers->all()
            );
        } else {
            $response = new Response(
                $response->content(), $response->status(), $response->headers->all()
            );
        }

        return $response->withException($e);
    }

    /**
     * Render an exception to the console.
     * 
     * @param  \Syscodes\Components\Contracts\Console\Output\ConsoleOutput  $output
     * @param  \Throwable  $e
     * 
     * @return void
     */
    public function renderForConsole($output, Throwable $e)
    {
        $message = sprintf(
            $output->write("<error>".getClass($e, true)."</>")." %s in file %s on line %d\n\n%s\n",
            //getClass($e, true),
            $e->getMessage(),            
            $e->getFile(),
            $e->getLine(),
            $e->getTraceAsString()
        );

        echo $message;
    }

    /**
     * Determine if the given exception is an HTTP exception.
     * 
     * @param  \Throwable  $e
     * 
     * @return bool
     */
    protected function isHttpException(Throwable $e): bool
    {
        return $e instanceof HttpException;
    }
}