Rarst\wps\Whoops_Run_Composite

Complexity

Total Complexity

19

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	register()	0	10	1
A	unregister()	0	4	1
A	pushHandler()	0	3	1
A	skipAllNoticesAndWarnings()	0	3	1
A	watchSpecificPlugins()	0	3	1
A	watchSpecificThemes()	0	3	1
C	handleError()	0	52	11

<?php
namespace Rarst\wps;

use Whoops\Exception\ErrorException;
use Whoops\Exception\Inspector;
use Whoops\Run;
use Whoops\Util\SystemFacade;

/**
 * This class will show Errors and Warnings only if they are coming from
 * Specific Plugin
 */
class Whoops_Run_Composite {

    /**
     * @var SystemFacade
     */
    private $system;
    
    /**
     * @var Run
     */
    private $run;
    
    private $skipAllNoticesAndWarnings = false;

    private $watchSpecificPlugins = [];

    private $watchSpecificThemes = [];

    public function __construct(SystemFacade $system = null)
    {
        $this->system = $system ?: new SystemFacade;
        $this->run = new Run($this->system);
    }

    public function register() {
        class_exists("\\Whoops\\Exception\\ErrorException");
        class_exists("\\Whoops\\Exception\\FrameCollection");
        class_exists("\\Whoops\\Exception\\Frame");
        class_exists("\\Whoops\\Exception\\Inspector");

        $this->system->setErrorHandler([$this, Run::ERROR_HANDLER]);
        $this->system->setExceptionHandler([$this->run, Run::EXCEPTION_HANDLER]);
        $this->system->registerShutdownFunction([$this->run, Run::SHUTDOWN_HANDLER]);
    }

    public function unregister() {
        $this->system->restoreExceptionHandler();
        $this->system->restoreErrorHandler();
    }

    public function pushHandler($handler) {
        $this->run->pushHandler($handler);
    }

    public function skipAllNoticesAndWarnings() {
        $this->skipAllNoticesAndWarnings = true;
    }

    public function watchSpecificPlugins($plugins) {
        $this->watchSpecificPlugins = $plugins;
    }

    public function watchSpecificThemes($themes) {
        $this->watchSpecificThemes = $themes;
    }

    /**
     * Converts generic PHP errors to \ErrorException
     * instances, before passing them off to be handled.
     *
     * This method MUST be compatible with set_error_handler.
     *
     * @param int    $level
     * @param string $message
     * @param string $file
     * @param int    $line
     *
     * @return bool
     * @throws ErrorException
     */
    public function handleError($level, $message, $file = null, $line = null) {

        // Handle all fatals, exceptions etc.
        if(in_array(
            $level, 
            [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR, E_RECOVERABLE_ERROR]
        )) {
            $this->run->handleError($level, $message, $file, $line);
            return false;
        }

        // If All Notices and Warnings should be skipped, then short-circuit
        // error handler.
        if($this->skipAllNoticesAndWarnings) {
            return false;
        }

        // Watch for all plugins and Themes
        if( empty($this->watchSpecificPlugins) && empty($this->watchSpecificThemes ) ) {
            $this->run->handleError($level, $message, $file, $line);
            return false;
        }

        $watchablePlugins = empty($this->watchSpecificPlugins) ? [] : array_map(function($pluginBaseFolder){
            return 'plugins/' . $pluginBaseFolder;
        }, $this->watchSpecificPlugins);

        $watchableThemes = empty($this->watchSpecificThemes) ? [] : array_map(function($themeBaseFolder){
            return 'themes/' . $themeBaseFolder;
        }, $this->watchSpecificThemes);

        $directoriesToWatchFor = array_merge($watchablePlugins, $watchableThemes);
        $errorBelongsToWatchCriteria = false;
        
        // We are creating an exception object because Inspector Class needs it.
        $exception = new ErrorException($message, /*code*/ $level, /*severity*/ $level, $file, $line);
        $frames = (new Inspector($exception))->getFrames();

$exception is of type object<Whoops\Exception\ErrorException>, but the function expects a object<Throwable>.

        foreach( $frames as $frame ) {
            foreach($directoriesToWatchFor as $directory) {
                if (strpos($frame->getFile(), $directory) !== false) {
                    $errorBelongsToWatchCriteria = true;
                    break 2;
                }
            }
        }

        if($errorBelongsToWatchCriteria) {
            $this->run->handleError($level, $message, $file, $line);
        }

        return false;
    }
}