Run::handleException() - Code Metrics - Inspection of "System "runtime" facade implementation" - filp/whoops - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#374)

by Guido

created 2016-01-22 18:04 UTC

Run::handleException() C

↳ Parent: Run

Complexity

Conditions	8
Paths	36

Size

Total Lines	63
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	20
CRAP Score	9.1158

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	63
ccs	20
cts	27
cp	0.7407
rs	6.8825
cc	8
eloc	22
nc	36
nop	1
crap	9.1158

How to fix Long Method

<?php
/**
 * Whoops - php errors for cool kids
 * @author Filipe Dobreira <http://github.com/filp>
 */

namespace Whoops;

use InvalidArgumentException;
use Whoops\Exception\ErrorException;
use Whoops\Exception\Inspector;
use Whoops\Handler\CallbackHandler;
use Whoops\Handler\Handler;
use Whoops\Handler\HandlerInterface;
use Whoops\Util\Misc;
use Whoops\Util\SystemFacade;

final class Run
{
    const EXCEPTION_HANDLER = "handleException";
    const ERROR_HANDLER     = "handleError";
    const SHUTDOWN_HANDLER  = "handleShutdown";

    protected $isRegistered;
    protected $allowQuit       = true;
    protected $sendOutput      = true;

    /**
     * @var integer|false
     */
    protected $sendHttpCode    = 500;

    /**
     * @var HandlerInterface[]
     */
    protected $handlerStack = array();

    protected $silencedPatterns = array();

    protected $system;

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

    /**
     * Pushes a handler to the end of the stack
     *
     * @throws InvalidArgumentException  If argument is not callable or instance of HandlerInterface
     * @param  Callable|HandlerInterface $handler
     * @return Run
     */
    public function pushHandler($handler)
    {
        if (is_callable($handler)) {
            $handler = new CallbackHandler($handler);
        }

        if (!$handler instanceof HandlerInterface) {
            throw new InvalidArgumentException(
                  "Argument to " . __METHOD__ . " must be a callable, or instance of "
                . "Whoops\\Handler\\HandlerInterface"
            );
        }

        $this->handlerStack[] = $handler;
        return $this;
    }

    /**
     * Removes the last handler in the stack and returns it.
     * Returns null if there"s nothing else to pop.
     * @return null|HandlerInterface
     */
    public function popHandler()
    {
        return array_pop($this->handlerStack);
    }

    /**
     * Returns an array with all handlers, in the
     * order they were added to the stack.
     * @return array
     */
    public function getHandlers()
    {
        return $this->handlerStack;
    }

    /**
     * Clears all handlers in the handlerStack, including
     * the default PrettyPage handler.
     * @return Run
     */
    public function clearHandlers()
    {
        $this->handlerStack = array();
        return $this;
    }

    /**
     * @param  \Throwable $exception
     * @return Inspector
     */
    protected function getInspector($exception)
    {
        return new Inspector($exception);
    }

    /**
     * Registers this instance as an error handler.
     * @return Run
     */
    public function register()
    {
        if (!$this->isRegistered) {
            // Workaround PHP bug 42098
            // https://bugs.php.net/bug.php?id=42098
            class_exists("\\Whoops\\Exception\\ErrorException");
            class_exists("\\Whoops\\Exception\\FrameCollection");
            class_exists("\\Whoops\\Exception\\Frame");
            class_exists("\\Whoops\\Exception\\Inspector");

            $this->system->setErrorHandler(array($this, self::ERROR_HANDLER));
            $this->system->setExceptionHandler(array($this, self::EXCEPTION_HANDLER));
            $this->system->registerShutdownFunction(array($this, self::SHUTDOWN_HANDLER));

            $this->isRegistered = true;
        }

        return $this;
    }

    /**
     * Unregisters all handlers registered by this Whoops\Run instance
     * @return Run
     */
    public function unregister()
    {
        if ($this->isRegistered) {
            $this->system->restoreExceptionHandler();
            $this->system->restoreErrorHandler();

            $this->isRegistered = false;
        }

        return $this;
    }

    /**
     * Should Whoops allow Handlers to force the script to quit?
     * @param  bool|int $exit
     * @return bool
     */
    public function allowQuit($exit = null)
    {
        if (func_num_args() == 0) {
            return $this->allowQuit;
        }

        return $this->allowQuit = (bool) $exit;
    }

    /**
     * Silence particular errors in particular files
     * @param  array|string $patterns List or a single regex pattern to match
     * @param  int          $levels   Defaults to E_STRICT | E_DEPRECATED
     * @return \Whoops\Run
     */
    public function silenceErrorsInPaths($patterns, $levels = 10240)
    {
        $this->silencedPatterns = array_merge(
            $this->silencedPatterns,
            array_map(
                function ($pattern) use ($levels) {
                    return array(
                        "pattern" => $pattern,
                        "levels" => $levels,
                    );
                },
                (array) $patterns
            )
        );
        return $this;
    }

    /*
     * Should Whoops send HTTP error code to the browser if possible?
     * Whoops will by default send HTTP code 500, but you may wish to
     * use 502, 503, or another 5xx family code.
     *
     * @param bool|int $code
     * @return int|false
     */
    public function sendHttpCode($code = null)
    {
        if (func_num_args() == 0) {
            return $this->sendHttpCode;
        }

        if (!$code) {
            return $this->sendHttpCode = false;
        }

        if ($code === true) {
            $code = 500;
        }

        if ($code < 400 || 600 <= $code) {
            throw new InvalidArgumentException(
                 "Invalid status code '$code', must be 4xx or 5xx"
            );
        }

        return $this->sendHttpCode = $code;
    }

    /**
     * Should Whoops push output directly to the client?
     * If this is false, output will be returned by handleException
     * @param  bool|int $send
     * @return bool
     */
    public function writeToOutput($send = null)
    {
        if (func_num_args() == 0) {
            return $this->sendOutput;
        }

        return $this->sendOutput = (bool) $send;
    }

    /**
     * Handles an exception, ultimately generating a Whoops error
     * page.
     *
     * @param  \Throwable $exception
     * @return string     Output generated by handlers
     */
    public function handleException($exception)
    {
        // Walk the registered handlers in the reverse order
        // they were registered, and pass off the exception
        $inspector = $this->getInspector($exception);

        // Capture output produced while handling the exception,
        // we might want to send it straight away to the client,
        // or return it silently.
        $this->system->startOutputBuffering();

        // Just in case there are no handlers:
        $handlerResponse = null;

        foreach (array_reverse($this->handlerStack) as $handler) {
            $handler->setRun($this);
            $handler->setInspector($inspector);
            $handler->setException($exception);

            // The HandlerInterface does not require an Exception passed to handle()
            // and neither of our bundled handlers use it.
            // However, 3rd party handlers may have already relied on this parameter,
            // and removing it would be possibly breaking for users.
            $handlerResponse = $handler->handle($exception);

            if (in_array($handlerResponse, array(Handler::LAST_HANDLER, Handler::QUIT))) {
                // The Handler has handled the exception in some way, and
                // wishes to quit execution (Handler::QUIT), or skip any
                // other handlers (Handler::LAST_HANDLER). If $this->allowQuit
                // is false, Handler::QUIT behaves like Handler::LAST_HANDLER
                break;
            }
        }

        $willQuit = $handlerResponse == Handler::QUIT && $this->allowQuit();

        $output = $this->system->cleanOutputBuffer();

        // If we're allowed to, send output generated by handlers directly
        // to the output, otherwise, and if the script doesn't quit, return
        // it so that it may be used by the caller
        if ($this->writeToOutput()) {
            // @todo Might be able to clean this up a bit better
            // If we're going to quit execution, cleanup all other output
            // buffers before sending our own output:
            if ($willQuit) {
                while ($this->system->getOutputBufferLevel() > 0) {
                    $this->system->endOutputBuffering();
                }
            }

            $this->writeToOutputNow($output);
        }

        if ($willQuit) {
            // HHVM fix for https://github.com/facebook/hhvm/issues/4055
            $this->system->flushOutputBuffer();

            $this->system->stopExecution(1);
        }

        return $output;
    }

    /**
     * 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)
    {
        if ($level & $this->system->getErrorReportingLevel()) {
            foreach ($this->silencedPatterns as $entry) {
                $pathMatches = (bool) preg_match($entry["pattern"], $file);
                $levelMatches = $level & $entry["levels"];
                if ($pathMatches && $levelMatches) {
                    // Ignore the error, abort handling
                    return true;
                }
            }

            // XXX we pass $level for the "code" param only for BC reasons.
            // see https://github.com/filp/whoops/issues/267
            $exception = new ErrorException($message, /*code*/ $level, /*severity*/ $level, $file, $line);
            if ($this->canThrowExceptions) {
                throw $exception;
            } else {
                $this->handleException($exception);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
            // Do not propagate errors which were already handled by Whoops.
            return true;
        }

        // Propagate error to the next handler, allows error_get_last() to
        // work on silenced errors.
        return false;
    }

    /**
     * Special case to deal with Fatal errors and the like.
     */
    public function handleShutdown()
    {
        // If we reached this step, we are in shutdown handler.
        // An exception thrown in a shutdown handler will not be propagated
        // to the exception handler. Pass that information along.
        $this->canThrowExceptions = false;

        $error = $this->system->getLastError();
        if ($error && Misc::isLevelFatal($error['type'])) {

            // If there was a fatal error,
            // it was not handled in handleError yet.
            $this->handleError(
                $error['type'],
                $error['message'],
                $error['file'],
                $error['line']
            );
        }
    }

    /**
     * In certain scenarios, like in shutdown handler, we can not throw exceptions
     * @var bool
     */
    private $canThrowExceptions = true;

    /**
     * Echo something to the browser
     * @param  string $output
     * @return $this
     */
    private function writeToOutputNow($output)
    {
        if ($this->sendHttpCode() && \Whoops\Util\Misc::canSendHeaders()) {
            $this->system->setHttpResponseCode(
                $this->sendHttpCode()

            );
        }

        echo $output;

        return $this;
    }
}


1		<?php
2		/**
3		* Whoops - php errors for cool kids
4		* @author Filipe Dobreira <http://github.com/filp>
5		*/
6
7		namespace Whoops;
8
9		use InvalidArgumentException;
10		use Whoops\Exception\ErrorException;
11		use Whoops\Exception\Inspector;
12		use Whoops\Handler\CallbackHandler;
13		use Whoops\Handler\Handler;
14		use Whoops\Handler\HandlerInterface;
15		use Whoops\Util\Misc;
16		use Whoops\Util\SystemFacade;
17
18		final class Run
19		{
20		const EXCEPTION_HANDLER = "handleException";
21		const ERROR_HANDLER = "handleError";
22		const SHUTDOWN_HANDLER = "handleShutdown";
23
24		protected $isRegistered;
25		protected $allowQuit = true;
26		protected $sendOutput = true;
27
28		/**
29		* @var integer\|false
30		*/
31		protected $sendHttpCode = 500;
32
33		/**
34		* @var HandlerInterface[]
35		*/
36		protected $handlerStack = array();
37
38		protected $silencedPatterns = array();
39
40		protected $system;
41
42	4	public function __construct(SystemFacade $system = null)
43		{
44	4	$this->system = $system ?: new SystemFacade;
45	4	}
46
47		/**
48		* Pushes a handler to the end of the stack
49		*
50		* @throws InvalidArgumentException If argument is not callable or instance of HandlerInterface
51		* @param Callable\|HandlerInterface $handler
52		* @return Run
53		*/
54	8	public function pushHandler($handler)
55		{
56	8	if (is_callable($handler)) {
57	1	$handler = new CallbackHandler($handler);
58	1	}
59
60	8	if (!$handler instanceof HandlerInterface) {
61	1	throw new InvalidArgumentException(
62	1	"Argument to " . __METHOD__ . " must be a callable, or instance of "
63	1	. "Whoops\\Handler\\HandlerInterface"
64	1	);
65		}
66
67	7	$this->handlerStack[] = $handler;
68	7	return $this;
69		}
70
71		/**
72		* Removes the last handler in the stack and returns it.
73		* Returns null if there"s nothing else to pop.
74		* @return null\|HandlerInterface
75		*/
76	1	public function popHandler()
77		{
78	1	return array_pop($this->handlerStack);
79		}
80
81		/**
82		* Returns an array with all handlers, in the
83		* order they were added to the stack.
84		* @return array
85		*/
86	2	public function getHandlers()
87		{
88	2	return $this->handlerStack;
89		}
90
91		/**
92		* Clears all handlers in the handlerStack, including
93		* the default PrettyPage handler.
94		* @return Run
95		*/
96	1	public function clearHandlers()
97		{
98	1	$this->handlerStack = array();
99	1	return $this;
100		}
101
102		/**
103		* @param \Throwable $exception
104		* @return Inspector
105		*/
106	1	protected function getInspector($exception)
107		{
108	1	return new Inspector($exception);
109		}
110
111		/**
112		* Registers this instance as an error handler.
113		* @return Run
114		*/
115	4	public function register()
116		{
117	4	if (!$this->isRegistered) {
118		// Workaround PHP bug 42098
119		// https://bugs.php.net/bug.php?id=42098
120	4	class_exists("\\Whoops\\Exception\\ErrorException");
121	4	class_exists("\\Whoops\\Exception\\FrameCollection");
122	4	class_exists("\\Whoops\\Exception\\Frame");
123	4	class_exists("\\Whoops\\Exception\\Inspector");
124
125	4	$this->system->setErrorHandler(array($this, self::ERROR_HANDLER));
126	4	$this->system->setExceptionHandler(array($this, self::EXCEPTION_HANDLER));
127	4	$this->system->registerShutdownFunction(array($this, self::SHUTDOWN_HANDLER));
128
129	4	$this->isRegistered = true;
130	4	}
131
132	4	return $this;
133		}
134
135		/**
136		* Unregisters all handlers registered by this Whoops\Run instance
137		* @return Run
138		*/
139	1	public function unregister()
140		{
141	1	if ($this->isRegistered) {
142	1	$this->system->restoreExceptionHandler();
143	1	$this->system->restoreErrorHandler();
144
145	1	$this->isRegistered = false;
146	1	}
147
148	1	return $this;
149		}
150
151		/**
152		* Should Whoops allow Handlers to force the script to quit?
153		* @param bool\|int $exit
154		* @return bool
155		*/
156	4	public function allowQuit($exit = null)
157		{
158	4	if (func_num_args() == 0) {
159	1	return $this->allowQuit;
160		}
161
162	4	return $this->allowQuit = (bool) $exit;
163		}
164
165		/**
166		* Silence particular errors in particular files
167		* @param array\|string $patterns List or a single regex pattern to match
168		* @param int $levels Defaults to E_STRICT \| E_DEPRECATED
169		* @return \Whoops\Run
170		*/
171	1	public function silenceErrorsInPaths($patterns, $levels = 10240)
172		{
173	1	$this->silencedPatterns = array_merge(
174	1	$this->silencedPatterns,
175	1	array_map(
176	1	function ($pattern) use ($levels) {
177		return array(
178	1	"pattern" => $pattern,
179	1	"levels" => $levels,
180	1	);
181	1	},
182		(array) $patterns
183	1	)
184	1	);
185	1	return $this;
186		}
187
188		/*
189		* Should Whoops send HTTP error code to the browser if possible?
190		* Whoops will by default send HTTP code 500, but you may wish to
191		* use 502, 503, or another 5xx family code.
192		*
193		* @param bool\|int $code
194		* @return int\|false
195		*/
196	3	public function sendHttpCode($code = null)
197		{
198	3	if (func_num_args() == 0) {
199	2	return $this->sendHttpCode;
200		}
201
202	2	if (!$code) {
203		return $this->sendHttpCode = false;
204		}
205
206	2	if ($code === true) {
207	1	$code = 500;
208	1	}
209
210	2	if ($code < 400 \|\| 600 <= $code) {
211	1	throw new InvalidArgumentException(
212	1	"Invalid status code '$code', must be 4xx or 5xx"
213	1	);
214		}
215
216	1	return $this->sendHttpCode = $code;
217		}
218
219		/**
220		* Should Whoops push output directly to the client?
221		* If this is false, output will be returned by handleException
222		* @param bool\|int $send
223		* @return bool
224		*/
225	3	public function writeToOutput($send = null)
226		{
227	3	if (func_num_args() == 0) {
228	3	return $this->sendOutput;
229		}
230
231	1	return $this->sendOutput = (bool) $send;
232		}
233
234		/**
235		* Handles an exception, ultimately generating a Whoops error
236		* page.
237		*
238		* @param \Throwable $exception
239		* @return string Output generated by handlers
240		*/
241	5	public function handleException($exception)
242		{
243		// Walk the registered handlers in the reverse order
244		// they were registered, and pass off the exception
245	5	$inspector = $this->getInspector($exception);
246
247		// Capture output produced while handling the exception,
248		// we might want to send it straight away to the client,
249		// or return it silently.
250	5	$this->system->startOutputBuffering();
251
252		// Just in case there are no handlers:
253	5	$handlerResponse = null;
254
255	5	foreach (array_reverse($this->handlerStack) as $handler) {
256	5	$handler->setRun($this);
257	5	$handler->setInspector($inspector);
258	5	$handler->setException($exception);
259
260		// The HandlerInterface does not require an Exception passed to handle()
261		// and neither of our bundled handlers use it.
262		// However, 3rd party handlers may have already relied on this parameter,
263		// and removing it would be possibly breaking for users.
264	5	$handlerResponse = $handler->handle($exception);
265
266	5	if (in_array($handlerResponse, array(Handler::LAST_HANDLER, Handler::QUIT))) {
267		// The Handler has handled the exception in some way, and
268		// wishes to quit execution (Handler::QUIT), or skip any
269		// other handlers (Handler::LAST_HANDLER). If $this->allowQuit
270		// is false, Handler::QUIT behaves like Handler::LAST_HANDLER
271	2	break;
272		}
273	5	}
274
275	5	$willQuit = $handlerResponse == Handler::QUIT && $this->allowQuit();
276
277	5	$output = $this->system->cleanOutputBuffer();
278
279		// If we're allowed to, send output generated by handlers directly
280		// to the output, otherwise, and if the script doesn't quit, return
281		// it so that it may be used by the caller
282	5	if ($this->writeToOutput()) {
283		// @todo Might be able to clean this up a bit better
284		// If we're going to quit execution, cleanup all other output
285		// buffers before sending our own output:
286	4	if ($willQuit) {
287		while ($this->system->getOutputBufferLevel() > 0) {
288		$this->system->endOutputBuffering();
289		}
290		}
291
292	4	$this->writeToOutputNow($output);
293	4	}
294
295	5	if ($willQuit) {
296		// HHVM fix for https://github.com/facebook/hhvm/issues/4055
297		$this->system->flushOutputBuffer();
298
299		$this->system->stopExecution(1);
300		}
301
302	5	return $output;
303		}
304
305		/**
306		* Converts generic PHP errors to \ErrorException
307		* instances, before passing them off to be handled.
308		*
309		* This method MUST be compatible with set_error_handler.
310		*
311		* @param int $level
312		* @param string $message
313		* @param string $file
314		* @param int $line
315		*
316		* @return bool
317		* @throws ErrorException
318		*/
319	5	public function handleError($level, $message, $file = null, $line = null)
320		{
321	5	if ($level & $this->system->getErrorReportingLevel()) {
322	2	foreach ($this->silencedPatterns as $entry) {
323		$pathMatches = (bool) preg_match($entry["pattern"], $file);
324		$levelMatches = $level & $entry["levels"];
325		if ($pathMatches && $levelMatches) {
326		// Ignore the error, abort handling
327		return true;
328		}
329	2	}
330
331		// XXX we pass $level for the "code" param only for BC reasons.
332		// see https://github.com/filp/whoops/issues/267
333	2	$exception = new ErrorException($message, /code/ $level, /severity/ $level, $file, $line);
334	2	if ($this->canThrowExceptions) {
335	2	throw $exception;
336		} else {
337		$this->handleException($exception);
		0 ignored issues – show Documentation introduced 2015-12-12 21:25 UTC by Report Bug Copy Issue Report `$exception` is of type `object<Whoops\Exception\ErrorException>`, but the function expects a `object<Throwable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
338		}
339		// Do not propagate errors which were already handled by Whoops.
340		return true;
341		}
342
343		// Propagate error to the next handler, allows error_get_last() to
344		// work on silenced errors.
345	3	return false;
346		}
347
348		/**
349		* Special case to deal with Fatal errors and the like.
350		*/
351		public function handleShutdown()
352		{
353		// If we reached this step, we are in shutdown handler.
354		// An exception thrown in a shutdown handler will not be propagated
355		// to the exception handler. Pass that information along.
356		$this->canThrowExceptions = false;
357
358		$error = $this->system->getLastError();
359		if ($error && Misc::isLevelFatal($error['type'])) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-22 16:45 UTC by Report Bug Copy Issue Report The expression `$error` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
360		// If there was a fatal error,
361		// it was not handled in handleError yet.
362		$this->handleError(
363		$error['type'],
364		$error['message'],
365		$error['file'],
366		$error['line']
367		);
368		}
369		}
370
371		/**
372		* In certain scenarios, like in shutdown handler, we can not throw exceptions
373		* @var bool
374		*/
375		private $canThrowExceptions = true;
376
377		/**
378		* Echo something to the browser
379		* @param string $output
380		* @return $this
381		*/
382	1	private function writeToOutputNow($output)
383		{
384	1	if ($this->sendHttpCode() && \Whoops\Util\Misc::canSendHeaders()) {
385		$this->system->setHttpResponseCode(
386		$this->sendHttpCode()
		0 ignored issues – show Bug introduced 2016-01-22 18:26 UTC by Report Bug Copy Issue Report It seems like `$this->sendHttpCode()` targeting `Whoops\Run::sendHttpCode()` can also be of type `boolean`; however, `Whoops\Util\SystemFacade::setHttpResponseCode()` does only seem to accept `integer`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
387		);
388		}
389
390	1	echo $output;
391
392	1	return $this;
393		}
394		}
395

filp / whoops

Pull Request — master (#374)

Run::handleException() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like