Handler::prepareResponse() - Code Metrics - Inspection of "Merge branch 'master' into 0.7.0" - lenevor/syscodes - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 0.7.0 ( 3fbacd...941781 )

by Alexander
created 2021-03-18 13:59 UTC
Handler::prepareResponse() A

↳ Parent: Handler
Complexity

Conditions	4
Paths	3
Size

Total Lines	12
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	4
eloc	5
c	1
b	0
f	0
nc	3
nop	2
dl	0
loc	12
rs	10
<?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 [email protected] so we can send you a copy immediately.
 *
 * @package     Lenevor
 * @subpackage  Base
 * @link        https://lenevor.com
 * @copyright   Copyright (c) 2019 - 2021 Alexander Campo <[email protected]>
 * @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 <[email protected]>
 */
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
filter:
    dependency_paths: ["lib/*"]
     * 
     * @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)
    protected function prepareResponse(/** @scrutinizer ignore-unused */ $request, Throwable $e)
    {
        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))) {
        if (view()->/** @scrutinizer ignore-call */ viewExists($view = $this->getHttpExceptionView($e))) {
            return response()->view(
            return response()->/** @scrutinizer ignore-call */ view(
                $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,
            $this->isHttpException($e) ? $e->/** @scrutinizer ignore-call */ getStatusCode() : 500,
            $this->isHttpException($e) ? $e->getHeaders() : []
            $this->isHttpException($e) ? $e->/** @scrutinizer ignore-call */ getHeaders() : []
        );
    }

    /**
     * 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) 
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                        : $this->renderExceptionWithFlatDesignDebug($e, config('app.debug'));
                        : $this->renderExceptionWithFlatDesignDebug($e, /** @scrutinizer ignore-type */ config('app.debug'));
        } 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) {
        return take(/** @scrutinizer ignore-type */ new GDebug, function ($debug) {
            
            $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)
            /** @scrutinizer ignore-type */ FlattenException::make($e)
        );
    }

    /**
     * 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) {
filter:
    dependency_paths: ["lib/*"]
            $response = new RedirectResponse(
                $response->getTargetUrl(), $response->status(), $response->headers->all()
                           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  \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),
            /** @scrutinizer ignore-type */ 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)
    {
        return $e instanceof HttpException;
    }
}
lenevor / syscodes

Push — 0.7.0 ( 3fbacd...941781 )

Handler::prepareResponse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
