Inspector::getExceptionName() - Code Metrics - Inspection of "Display messages from previous exceptions" - filp/whoops - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#596)

unknown

created 2018-10-20 16:10 UTC

Inspector::getExceptionName() A

↳ Parent: Inspector

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	1
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2

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

namespace Whoops\Exception;

use Whoops\Util\Misc;

class Inspector
{
    /**
     * @var \Throwable
     */
    private $exception;

    /**
     * @var \Whoops\Exception\FrameCollection
     */
    private $frames;

    /**
     * @var \Whoops\Exception\Inspector
     */
    private $previousExceptionInspector;

    /**
     * @var \Throwable[]
     */
    private $previousExceptions;

    /**
     * @param \Throwable $exception The exception to inspect
     */
    public function __construct($exception)
    {
        $this->exception = $exception;
    }

    /**
     * @return \Throwable
     */
    public function getException()
    {
        return $this->exception;
    }

    /**
     * @return string
     */
    public function getExceptionName()
    {
        return get_class($this->exception);
    }

    /**
     * @return string
     */
    public function getExceptionMessage()
    {
        return $this->extractDocrefUrl($this->exception->getMessage())['message'];
    }

    /**
     * @return string[]
     */
    public function getPreviousExceptionMessages()
    {
        return array_map(function ($prev) {
            /** @var \Throwable $prev */
            return $this->extractDocrefUrl($prev->getMessage())['message'];
        }, $this->getPreviousExceptions());
    }

    /**
     * @return int[]
     */
    public function getPreviousExceptionCodes()
    {
        return array_map(function ($prev) {
            /** @var \Throwable $prev */
            return $prev->getCode();
        }, $this->getPreviousExceptions());
    }

    /**
     * Returns a url to the php-manual related to the underlying error - when available.
     *
     * @return string|null
     */
    public function getExceptionDocrefUrl()
    {
        return $this->extractDocrefUrl($this->exception->getMessage())['url'];
    }

    private function extractDocrefUrl($message)
    {
        $docref = [
            'message' => $message,
            'url' => null,
        ];

        // php embbeds urls to the manual into the Exception message with the following ini-settings defined
        // http://php.net/manual/en/errorfunc.configuration.php#ini.docref-root
        if (!ini_get('html_errors') || !ini_get('docref_root')) {
            return $docref;
        }

        $pattern = "/\[<a href='([^']+)'>(?:[^<]+)<\/a>\]/";
        if (preg_match($pattern, $message, $matches)) {
            // -> strip those automatically generated links from the exception message
            $docref['message'] = preg_replace($pattern, '', $message, 1);
            $docref['url'] = $matches[1];
        }

        return $docref;
    }

    /**
     * Does the wrapped Exception has a previous Exception?
     * @return bool
     */
    public function hasPreviousException()
    {
        return $this->previousExceptionInspector || $this->exception->getPrevious();
    }

    /**
     * Returns an Inspector for a previous Exception, if any.
     * @todo   Clean this up a bit, cache stuff a bit better.
     * @return Inspector
     */
    public function getPreviousExceptionInspector()
    {
        if ($this->previousExceptionInspector === null) {
            $previousException = $this->exception->getPrevious();

            if ($previousException) {
                $this->previousExceptionInspector = new Inspector($previousException);
            }
        }

        return $this->previousExceptionInspector;
    }


    /**
     * Returns an array of all previous exceptions for this inspector's exception
     * @return \Throwable[]
     */
    public function getPreviousExceptions()
    {
        if ($this->previousExceptions === null) {
            $this->previousExceptions = [];

            $prev = $this->exception->getPrevious();
            while ($prev !== null) {
                $this->previousExceptions[] = $prev;
                $prev = $prev->getPrevious();
            }
        }

        return $this->previousExceptions;
    }

    /**
     * Returns an iterator for the inspected exception's
     * frames.
     * @return \Whoops\Exception\FrameCollection
     */
    public function getFrames()
    {
        if ($this->frames === null) {
            $frames = $this->getTrace($this->exception);

            // Fill empty line/file info for call_user_func_array usages (PHP Bug #44428)
            foreach ($frames as $k => $frame) {
                if (empty($frame['file'])) {
                    // Default values when file and line are missing
                    $file = '[internal]';
                    $line = 0;

                    $next_frame = !empty($frames[$k + 1]) ? $frames[$k + 1] : [];

                    if ($this->isValidNextFrame($next_frame)) {
                        $file = $next_frame['file'];
                        $line = $next_frame['line'];
                    }

                    $frames[$k]['file'] = $file;
                    $frames[$k]['line'] = $line;
                }
            }

            // Find latest non-error handling frame index ($i) used to remove error handling frames
            $i = 0;
            foreach ($frames as $k => $frame) {
                if ($frame['file'] == $this->exception->getFile() && $frame['line'] == $this->exception->getLine()) {
                    $i = $k;
                }
            }

            // Remove error handling frames
            if ($i > 0) {
                array_splice($frames, 0, $i);
            }

            $firstFrame = $this->getFrameFromException($this->exception);
            array_unshift($frames, $firstFrame);

            $this->frames = new FrameCollection($frames);

            if ($previousInspector = $this->getPreviousExceptionInspector()) {
                // Keep outer frame on top of the inner one
                $outerFrames = $this->frames;
                $newFrames = clone $previousInspector->getFrames();
                // I assume it will always be set, but let's be safe
                if (isset($newFrames[0])) {
                    $newFrames[0]->addComment(
                        $previousInspector->getExceptionMessage(),
                        'Exception message:'
                    );
                }
                $newFrames->prependFrames($outerFrames->topDiff($newFrames));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $this->frames = $newFrames;
            }
        }

        return $this->frames;
    }

    /**
     * Gets the backtrace from an exception.
     *
     * If xdebug is installed
     *
     * @param \Throwable $e
     * @return array
     */
    protected function getTrace($e)
    {
        $traces = $e->getTrace();

        // Get trace from xdebug if enabled, failure exceptions only trace to the shutdown handler by default
        if (!$e instanceof \ErrorException) {
            return $traces;
        }

        if (!Misc::isLevelFatal($e->getSeverity())) {
            return $traces;
        }

        if (!extension_loaded('xdebug') || !xdebug_is_enabled()) {
            return [];
        }

        // Use xdebug to get the full stack trace and remove the shutdown handler stack trace
        $stack = array_reverse(xdebug_get_function_stack());
        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
        $traces = array_diff_key($stack, $trace);

        return $traces;
    }

    /**
     * Given an exception, generates an array in the format
     * generated by Exception::getTrace()
     * @param  \Throwable $exception
     * @return array
     */
    protected function getFrameFromException($exception)
    {
        return [
            'file'  => $exception->getFile(),
            'line'  => $exception->getLine(),
            'class' => get_class($exception),
            'args'  => [
                $exception->getMessage(),
            ],
        ];
    }

    /**
     * Given an error, generates an array in the format
     * generated by ErrorException
     * @param  ErrorException $exception
     * @return array
     */
    protected function getFrameFromError(ErrorException $exception)
    {
        return [
            'file'  => $exception->getFile(),
            'line'  => $exception->getLine(),
            'class' => null,
            'args'  => [],
        ];
    }

    /**
     * Determine if the frame can be used to fill in previous frame's missing info
     * happens for call_user_func and call_user_func_array usages (PHP Bug #44428)
     *
     * @param array $frame
     * @return bool
     */
    protected function isValidNextFrame(array $frame)
    {
        if (empty($frame['file'])) {
            return false;
        }

        if (empty($frame['line'])) {
            return false;
        }

        if (empty($frame['function']) || !stristr($frame['function'], 'call_user_func')) {
            return false;
        }

        return true;
    }
}


1		<?php
2		/**
3		* Whoops - php errors for cool kids
4		* @author Filipe Dobreira <http://github.com/filp>
5		*/
6
7		namespace Whoops\Exception;
8
9		use Whoops\Util\Misc;
10
11		class Inspector
12		{
13		/**
14		* @var \Throwable
15		*/
16		private $exception;
17
18		/**
19		* @var \Whoops\Exception\FrameCollection
20		*/
21		private $frames;
22
23		/**
24		* @var \Whoops\Exception\Inspector
25		*/
26		private $previousExceptionInspector;
27
28		/**
29		* @var \Throwable[]
30		*/
31	3	private $previousExceptions;
32
33	3	/**
34	3	* @param \Throwable $exception The exception to inspect
35		*/
36		public function __construct($exception)
37		{
38		$this->exception = $exception;
39	3	}
40
41	3	/**
42		* @return \Throwable
43		*/
44		public function getException()
45		{
46		return $this->exception;
47	2	}
48
49	2	/**
50		* @return string
51		*/
52		public function getExceptionName()
53		{
54		return get_class($this->exception);
55		}
56
57		/**
58		* @return string
59		*/
60		public function getExceptionMessage()
61		{
62		return $this->extractDocrefUrl($this->exception->getMessage())['message'];
63		}
64
65		/**
66		* @return string[]
67		*/
68		public function getPreviousExceptionMessages()
69		{
70		return array_map(function ($prev) {
71		/** @var \Throwable $prev */
72		return $this->extractDocrefUrl($prev->getMessage())['message'];
73		}, $this->getPreviousExceptions());
74		}
75
76		/**
77		* @return int[]
78		*/
79		public function getPreviousExceptionCodes()
80		{
81		return array_map(function ($prev) {
82		/** @var \Throwable $prev */
83		return $prev->getCode();
84		}, $this->getPreviousExceptions());
85		}
86
87		/**
88		* Returns a url to the php-manual related to the underlying error - when available.
89		*
90		* @return string\|null
91		*/
92		public function getExceptionDocrefUrl()
93		{
94		return $this->extractDocrefUrl($this->exception->getMessage())['url'];
95		}
96
97	2	private function extractDocrefUrl($message)
98		{
99	2	$docref = [
100		'message' => $message,
101		'url' => null,
102		];
103
104		// php embbeds urls to the manual into the Exception message with the following ini-settings defined
105		// http://php.net/manual/en/errorfunc.configuration.php#ini.docref-root
106		if (!ini_get('html_errors') \|\| !ini_get('docref_root')) {
107	2	return $docref;
108		}
109	2
110	2	$pattern = "/\[<a href='([^']+)'>(?:[^<]+)<\/a>\]/";
111		if (preg_match($pattern, $message, $matches)) {
112	2	// -> strip those automatically generated links from the exception message
113	1	$docref['message'] = preg_replace($pattern, '', $message, 1);
114	1	$docref['url'] = $matches[1];
115	2	}
116
117	2	return $docref;
118		}
119
120		/**
121		* Does the wrapped Exception has a previous Exception?
122		* @return bool
123		*/
124		public function hasPreviousException()
125	3	{
126		return $this->previousExceptionInspector \|\| $this->exception->getPrevious();
127	3	}
128	3
129		/**
130		* Returns an Inspector for a previous Exception, if any.
131	3	* @todo Clean this up a bit, cache stuff a bit better.
132	3	* @return Inspector
133		*/
134	3	public function getPreviousExceptionInspector()
135	3	{
136		if ($this->previousExceptionInspector === null) {
137	3	$previousException = $this->exception->getPrevious();
138
139	3	if ($previousException) {
140		$this->previousExceptionInspector = new Inspector($previousException);
141		}
142		}
143
144	3	return $this->previousExceptionInspector;
145	3	}
146	3
147	3
148		/**
149		* Returns an array of all previous exceptions for this inspector's exception
150	3	* @return \Throwable[]
151	3	*/
152	3	public function getPreviousExceptions()
153		{
154		if ($this->previousExceptions === null) {
155	3	$this->previousExceptions = [];
156
157		$prev = $this->exception->getPrevious();
158	3	while ($prev !== null) {
159		$this->previousExceptions[] = $prev;
160		$prev = $prev->getPrevious();
161		}
162	3	}
163	3
164		return $this->previousExceptions;
165	3	}
166
167	3	/**
168		* Returns an iterator for the inspected exception's
169	1	* frames.
170	1	* @return \Whoops\Exception\FrameCollection
171		*/
172	1	public function getFrames()
173	1	{
174	1	if ($this->frames === null) {
175		$frames = $this->getTrace($this->exception);
176	1
177	1	// Fill empty line/file info for call_user_func_array usages (PHP Bug #44428)
178	1	foreach ($frames as $k => $frame) {
179	1	if (empty($frame['file'])) {
180	1	// Default values when file and line are missing
181	3	$file = '[internal]';
182		$line = 0;
183	3
184		$next_frame = !empty($frames[$k + 1]) ? $frames[$k + 1] : [];
185
186		if ($this->isValidNextFrame($next_frame)) {
187		$file = $next_frame['file'];
188		$line = $next_frame['line'];
189		}
190
191		$frames[$k]['file'] = $file;
192		$frames[$k]['line'] = $line;
193		}
194	1	}
195
196	1	// Find latest non-error handling frame index ($i) used to remove error handling frames
197		$i = 0;
198		foreach ($frames as $k => $frame) {
199	1	if ($frame['file'] == $this->exception->getFile() && $frame['line'] == $this->exception->getLine()) {
200	1	$i = $k;
201		}
202		}
203
204		// Remove error handling frames
205		if ($i > 0) {
206		array_splice($frames, 0, $i);
207		}
208
209		$firstFrame = $this->getFrameFromException($this->exception);
210		array_unshift($frames, $firstFrame);
211
212		$this->frames = new FrameCollection($frames);
213
214		if ($previousInspector = $this->getPreviousExceptionInspector()) {
215		// Keep outer frame on top of the inner one
216		$outerFrames = $this->frames;
217		$newFrames = clone $previousInspector->getFrames();
218		// I assume it will always be set, but let's be safe
219		if (isset($newFrames[0])) {
220		$newFrames[0]->addComment(
221		$previousInspector->getExceptionMessage(),
222		'Exception message:'
223		);
224		}
225	1	$newFrames->prependFrames($outerFrames->topDiff($newFrames));
		0 ignored issues – show Documentation introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report `$outerFrames->topDiff($newFrames)` is of type `array<integer,array>`, but the function expects a `array<integer,object<Whoops\Exception\Frame>>`. 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...
226		$this->frames = $newFrames;
227		}
228	1	}
229	1
230	1	return $this->frames;
231		}
232	1
233	1	/**
234	1	* Gets the backtrace from an exception.
235		*
236		* If xdebug is installed
237		*
238		* @param \Throwable $e
239		* @return array
240		*/
241		protected function getTrace($e)
242		{
243		$traces = $e->getTrace();
244
245		// Get trace from xdebug if enabled, failure exceptions only trace to the shutdown handler by default
246		if (!$e instanceof \ErrorException) {
247		return $traces;
248		}
249
250		if (!Misc::isLevelFatal($e->getSeverity())) {
251		return $traces;
252		}
253
254		if (!extension_loaded('xdebug') \|\| !xdebug_is_enabled()) {
255		return [];
256		}
257
258		// Use xdebug to get the full stack trace and remove the shutdown handler stack trace
259		$stack = array_reverse(xdebug_get_function_stack());
260	1	$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
261		$traces = array_diff_key($stack, $trace);
262	1
263		return $traces;
264		}
265
266	1	/**
267		* Given an exception, generates an array in the format
268		* generated by Exception::getTrace()
269		* @param \Throwable $exception
270	1	* @return array
271	1	*/
272		protected function getFrameFromException($exception)
273		{
274		return [
275		'file' => $exception->getFile(),
276		'line' => $exception->getLine(),
277		'class' => get_class($exception),
278		'args' => [
279		$exception->getMessage(),
280		],
281		];
282		}
283
284		/**
285		* Given an error, generates an array in the format
286		* generated by ErrorException
287		* @param ErrorException $exception
288		* @return array
289		*/
290		protected function getFrameFromError(ErrorException $exception)
291		{
292		return [
293		'file' => $exception->getFile(),
294		'line' => $exception->getLine(),
295		'class' => null,
296		'args' => [],
297		];
298		}
299
300		/**
301		* Determine if the frame can be used to fill in previous frame's missing info
302		* happens for call_user_func and call_user_func_array usages (PHP Bug #44428)
303		*
304		* @param array $frame
305		* @return bool
306		*/
307		protected function isValidNextFrame(array $frame)
308		{
309		if (empty($frame['file'])) {
310		return false;
311		}
312
313		if (empty($frame['line'])) {
314		return false;
315		}
316
317		if (empty($frame['function']) \|\| !stristr($frame['function'], 'call_user_func')) {
318		return false;
319		}
320
321		return true;
322		}
323		}
324

filp / whoops

Pull Request — master (#596)

Inspector::getExceptionName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like