Syscodes\Core\Exceptions\Handler

Complexity

Total Complexity

44

Size/Duplication

Total Lines	408
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	renderExceptionWithFlatDesignDebug()	0	4	1
A	convertExceptionToResponse()	0	6	3
A	getHttpExceptionView()	0	3	1
A	shouldntReport()	0	11	3
A	report()	0	23	6
A	DebugHandler()	0	3	1
A	renderExceptionWithGDebug()	0	11	1
A	reportable()	0	5	1
A	isHttpException()	0	3	1
A	renderable()	0	5	1
A	prepareException()	0	7	2
A	renderForConsole()	0	13	1
A	shouldReport()	0	3	1
A	register()	0	1	1
A	renderHttpException()	0	14	2
A	prepareResponse()	0	12	4
A	render()	0	21	6
A	registerViewErrorPaths()	0	3	1
A	toSyscodesResponse()	0	13	2
A	renderExceptionContent()	0	8	4
A	__construct()	0	5	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 - 2021 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\Core\Exceptions;

use Exception;
use Throwable;
use Syscodes\Console\Cli;
use Syscodes\Debug\GDebug;
use Syscodes\Http\Response;
use Psr\Log\LoggerInterface;
use Syscodes\Routing\Router;
use Syscodes\Collections\Arr;
use Syscodes\Debug\ExceptionHandler;
use Syscodes\Contracts\Container\Container;
use Syscodes\Core\Http\Exceptions\HttpException;
use Syscodes\Http\Exceptions\HttpResponseException;
use Syscodes\Debug\FatalExceptions\FlattenException;
use Syscodes\Core\Http\Exceptions\NotFoundHttpException;
use Syscodes\Database\Exceptions\ModelNotFoundException;
use Syscodes\Contracts\Debug\ExceptionHandler as ExceptionHandlerContract;

/**
 * The system's main exception class is loaded for activate the render method of debugging.
 * 
 * @author Alexander Campo <jalexcam@gmail.com>
 */
class Handler implements ExceptionHandlerContract
{
    /**
     * The container implementation.
     * 
     * @var \Syscodes\Contracts\Container\Container $container
     */
    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\Contracts\Container\Container  $container
     * 
     * @return void
     */
    public function __construct(Container $container)
    {
        $this->container = $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 $this
     */
    public function reportable(callable $callback)
    {
        $this->reportCallbacks[] = $callback;

        return $this;
    }

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

        return $this;
    }
    
    /**
     * Report or log an exception.
     * 
     * @param  \Exception  $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)
    {
        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)
    {
        $dontReport = array_merge($this->dontReport, $this->coreDontReport);

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

        return false;
    }

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

        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)
    {
        if ($e instanceof ModelNotFoundException) {
            $e = new NotFoundHttpException($e->getMessage(), $e);
        }

        return $e;
    }
     
    /**
     * Prepare a response for the given exception.
     * 
     * @param  \Syscodes\Http\Request  $request
     * @param  \Throwable  $e
     * 
     * @return \Syscodes\Http\Response
     * 
     * @uses   \Syscodes\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\Core\Http\Exceptions\HttpException  $e
     * 
     * @return \Syscodes\Http\Response
     */
    protected function renderHttpException(HttpException $e)
    {
        $this->registerViewErrorPaths();

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

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

            return response()->view(

The method view() does not exist on Syscodes\Http\Response.

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

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

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

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

    /**
     * Create a response for the given exception.
     * 
     * @param  \Exception  $e
     * 
     * @return \Syscodes\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\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\Core\Http\Exceptions\HttpException.

        );
    }

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

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

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

It seems like config('app.debug') can also be of type Syscodes\Config\Configure; however, parameter $debug of Syscodes\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'));
        }
    }

    /**
     * Render an exception to a string using "GDebug".
     * 
     * @param  \Throwable  $e
     * 
     * @return void
     * 
     * @uses   \Syscodes\Debug\GDebug
     */
    protected function renderExceptionWithGDebug(Throwable $e)
    {
        return take(new GDebug, function ($debug) {

new Syscodes\Debug\GDebug() of type Syscodes\Debug\GDebug is incompatible with the type string expected by parameter $value of take().

The expression return take(new Syscodes\Debug\GDebug(), function(...) { /* ... */ })->handleException($e) returns the type string which is incompatible with the documented return type void.

            
            $debug->pushHandler($this->DebugHandler());

            $debug->writeToOutput(false);

            $debug->allowQuit(false);

        })->handleException($e);
    }

    /**
     * Get the Debug handler for the application.
     *
     * @return \Syscodes\Debug\Handlers\MainHandler
     */
    protected function DebugHandler()
    {
        return (new DebugHandler)->initDebug();
    }

    /**
     * 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(
            FlattenException::make($e)

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

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

        );
    }

    /**
     * Map the given exception into an Syscodes response.
     * 
     * @param  \Syscodes\Http\Response  $response
     * @param  \Exception  $e 
     * 
     * @return \Syscodes\Http\Response
     */
    protected function toSyscodesResponse($response, Throwable $e)
    {
        if ($response instanceof RedirectResponse) {

The type Syscodes\Core\Exceptions\RedirectResponse was not found. Maybe you did not declare it correctly or list all dependencies?

            $response = new RedirectResponse(
                $response->getTargetUrl(), $response->status(), $response->headers->all()

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

            );
        } else {
            $response = new Response(
                $response->content(), $response->status(), $response->headers->all()
            );
        }

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

    /**
     * Render an exception to the console.
     * 
     * @param  \Throwable  $e
     * 
     * @return void
     */
    public function renderForConsole(Throwable $e)
    {
        $message = sprintf(
            Cli::color("%s: ", 'light_red').
            Cli::color("%s in file %s on line %d", 'light_cyan')."\n\n%s\n",
            getClass($e, true),

getClass($e, true) of type array is incompatible with the type double|integer|string expected by parameter $values of sprintf().

            $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)
    {
        return $e instanceof HttpException;
    }
}