Handler

Complexity

Total Complexity

11

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	1	1
A	register()	0	10	1
A	handleFatalError()	0	16	4
A	handleError()	0	3	1
A	handleException()	0	4	1
A	render()	0	8	2
A	errorType()	0	21	1

<?php

 /**
  * Handler class.
  *
  * Provides basic error and exception handling for your application.
  * It captures and handles all unhandled exceptions and errors.
  *
  * @license    http://opensource.org/licenses/MIT The MIT License (MIT)
  * @author     Omar El Gabry <omar.elgabry.93@gmail.com>
  */

class Handler{

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

    /**
     * Constructor
     *
     */
    private function __construct(){}

    /**
     * Register the error and exception handlers.
     * Must be called at the beginning of your application
     *
     * @return void
     */
    public static function register(){

        // turn off all error reporting as well,
        // because we will take care of it
        error_reporting(0);

        set_error_handler(__CLASS__ . "::handleError");
        set_exception_handler(__CLASS__ .'::handleException');
        register_shutdown_function(__CLASS__ ."::handleFatalError" );
    }

     /**
      * Handle fatal errors
      *
      * @return void
      */
    public static function handleFatalError(){

        if (PHP_SAPI === 'cli') { return; }
        $error = error_get_last();

        if (!is_array($error)) { return; }

        $fatals = [E_USER_ERROR, E_ERROR, E_PARSE];

        if (!in_array($error['type'], $fatals, true)) {
            return;
        }

        // self::handleError($error['type'], $error['message'], $error['file'], $error['line'], null);

82% of this comment could be valid code. Did you maybe forget this after debugging?

        self::handleException(new ErrorException($error['message'], 0, $error['type'], $error['file'], $error['line']));
    }

    /**
     * Handle errors
     *
     * @return void
     * @throws ErrorException
     */
    public static function handleError($errno, $errmsg, $filename, $linenum, $vars){

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

        throw new ErrorException($errmsg, 0, $errno, $filename, $linenum);
    }

    /**
     * Handle & log exceptions
     *
     * @return void
     * @see http://php.net/manual/en/function.set-exception-handler.php
     */
    public static function handleException($e) {
        Logger::Log(get_class($e), $e->getMessage(), $e->getFile(), $e->getLine());
        self::render($e);
    }

    /**
     * display system error page as result of an error or exception
     *
     * @param  Exception  $e
     * @return Response
     */
    private static  function render(Exception $e){

        if($e->getCode() === 400){
            return (new ErrorsController())->error(400)->send();
        }
        
        return (new ErrorsController())->error(500)->send();
    }

    /**
     * Map an error code to error text
     *
     * @param int $errno
     * @return string error text
     */
    private static function errorType($errno){

This method is not used, and could be removed.

        // define an assoc array of error string
        $errortype = array (
            E_ERROR              => 'Error',
            E_WARNING            => 'Warning',
            E_PARSE              => 'Parsing Error',
            E_NOTICE             => 'Notice',
            E_CORE_ERROR         => 'Core Error',
            E_CORE_WARNING       => 'Core Warning',
            E_COMPILE_ERROR      => 'Compile Error',
            E_COMPILE_WARNING    => 'Compile Warning',
            E_USER_ERROR         => 'User Error',
            E_USER_WARNING       => 'User Warning',
            E_USER_NOTICE        => 'User Notice',
            E_STRICT             => 'Runtime Notice',
            E_RECOVERABLE_ERROR  => 'Catchable Fatal Error'
        );

        return $errortype[$errno];
    }

}