PlainTextHandler::__construct() - Code Metrics - Inspection of "Fix issues with frameworks like Laravel on PHP7" - filp/whoops - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — v1 (#422)

unknown

created 2016-06-30 13:49 UTC

PlainTextHandler::__construct() A

↳ Parent: PlainTextHandler

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1.037

Importance

Changes	1
Bugs	0	Features	1

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

<?php
/**
* Whoops - php errors for cool kids
* @author Filipe Dobreira <http://github.com/filp>
* Plaintext handler for command line and logs.
* @author Pierre-Yves Landuré <https://howto.biapy.com/>
*/

namespace Whoops\Handler;

use InvalidArgumentException;
use Psr\Log\LoggerInterface;
use Whoops\Exception\Frame;

/**
* Handler outputing plaintext error messages. Can be used
* directly, or will be instantiated automagically by Whoops\Run
* if passed to Run::pushHandler
*/
class PlainTextHandler extends Handler
{
    const VAR_DUMP_PREFIX = '   | ';

    /**
     * @var \Psr\Log\LoggerInterface
     */
    protected $logger;

    /**
     * @var bool
     */
    private $addTraceToOutput = true;

    /**
     * @var bool|integer
     */
    private $addTraceFunctionArgsToOutput = false;

    /**
     * @var integer
     */
    private $traceFunctionArgsOutputLimit = 1024;

    /**
     * @var bool
     */
    private $onlyForCommandLine = false;

    /**
     * @var bool
     */
    private $outputOnlyIfCommandLine = true;

    /**
     * @var bool
     */
    private $loggerOnly = false;

    /**
     * Constructor.
     * @throws InvalidArgumentException     If argument is not null or a LoggerInterface
     * @param  \Psr\Log\LoggerInterface|null $logger
     */
    public function __construct($logger = null)
    {
        $this->setLogger($logger);
    }

    /**
     * Set the output logger interface.
     * @throws InvalidArgumentException     If argument is not null or a LoggerInterface
     * @param  \Psr\Log\LoggerInterface|null $logger
     */
    public function setLogger($logger = null)
    {
        if (! (is_null($logger)
            || $logger instanceof LoggerInterface)) {
            throw new InvalidArgumentException(
                'Argument to ' . __METHOD__ .
                " must be a valid Logger Interface (aka. Monolog), " .
                get_class($logger) . ' given.'
            );
        }

        $this->logger = $logger;
    }

    /**
     * @return \Psr\Log\LoggerInterface|null
     */
    public function getLogger()
    {
        return $this->logger;
    }

    /**
     * Add error trace to output.
     * @param  bool|null  $addTraceToOutput
     * @return bool|$this
     */
    public function addTraceToOutput($addTraceToOutput = null)
    {
        if (func_num_args() == 0) {
            return $this->addTraceToOutput;
        }

        $this->addTraceToOutput = (bool) $addTraceToOutput;
        return $this;
    }

    /**
     * Add error trace function arguments to output.
     * Set to True for all frame args, or integer for the n first frame args.
     * @param  bool|integer|null $addTraceFunctionArgsToOutput
     * @return null|bool|integer
     */
    public function addTraceFunctionArgsToOutput($addTraceFunctionArgsToOutput = null)
    {
        if (func_num_args() == 0) {
            return $this->addTraceFunctionArgsToOutput;
        }

        if (! is_integer($addTraceFunctionArgsToOutput)) {
            $this->addTraceFunctionArgsToOutput = (bool) $addTraceFunctionArgsToOutput;
        } else {
            $this->addTraceFunctionArgsToOutput = $addTraceFunctionArgsToOutput;
        }
    }

    /**
     * Set the size limit in bytes of frame arguments var_dump output.
     * If the limit is reached, the var_dump output is discarded.
     * Prevent memory limit errors.
     * @var integer
     */
    public function setTraceFunctionArgsOutputLimit($traceFunctionArgsOutputLimit)
    {
        $this->traceFunctionArgsOutputLimit = (integer) $traceFunctionArgsOutputLimit;
    }

    /**
     * Get the size limit in bytes of frame arguments var_dump output.
     * If the limit is reached, the var_dump output is discarded.
     * Prevent memory limit errors.
     * @return integer
     */
    public function getTraceFunctionArgsOutputLimit()
    {
        return $this->traceFunctionArgsOutputLimit;
    }

    /**
     * Restrict error handling to command line calls.
     * @param  bool|null $onlyForCommandLine
     * @return null|bool
     */
    public function onlyForCommandLine($onlyForCommandLine = null)
    {
        if (func_num_args() == 0) {
            return $this->onlyForCommandLine;
        }
        $this->onlyForCommandLine = (bool) $onlyForCommandLine;
    }

    /**
     * Output the error message only if using command line.
     * else, output to logger if available.
     * Allow to safely add this handler to web pages.
     * @param  bool|null $outputOnlyIfCommandLine
     * @return null|bool
     */
    public function outputOnlyIfCommandLine($outputOnlyIfCommandLine = null)
    {
        if (func_num_args() == 0) {
            return $this->outputOnlyIfCommandLine;
        }
        $this->outputOnlyIfCommandLine = (bool) $outputOnlyIfCommandLine;
    }

    /**
     * Only output to logger.
     * @param  bool|null $loggerOnly
     * @return null|bool
     */
    public function loggerOnly($loggerOnly = null)
    {
        if (func_num_args() == 0) {
            return $this->loggerOnly;
        }

        $this->loggerOnly = (bool) $loggerOnly;
    }

    /**
     * Check, if possible, that this execution was triggered by a command line.
     * @return bool
     */
    private function isCommandLine()
    {
        return PHP_SAPI == 'cli';
    }

    /**
     * Test if handler can process the exception..
     * @return bool
     */
    private function canProcess()
    {
        return $this->isCommandLine() || !$this->onlyForCommandLine();
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
    }

    /**
     * Test if handler can output to stdout.
     * @return bool
     */
    private function canOutput()
    {
        return ($this->isCommandLine() || ! $this->outputOnlyIfCommandLine())
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            && ! $this->loggerOnly();
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
    }

    /**
     * Get the frame args var_dump.
     * @param  \Whoops\Exception\Frame $frame [description]
     * @param  integer                 $line  [description]
     * @return string
     */
    private function getFrameArgsOutput(Frame $frame, $line)
    {
        if ($this->addTraceFunctionArgsToOutput() === false
            || $this->addTraceFunctionArgsToOutput() < $line) {
            return '';
        }

        // Dump the arguments:
        ob_start();
        var_dump($frame->getArgs());
        if (ob_get_length() > $this->getTraceFunctionArgsOutputLimit()) {
            // The argument var_dump is to big.
            // Discarded to limit memory usage.
            ob_clean();
            return sprintf(
                "\n%sArguments dump length greater than %d Bytes. Discarded.",
                self::VAR_DUMP_PREFIX,
                $this->getTraceFunctionArgsOutputLimit()
            );
        }

        return sprintf("\n%s",
            preg_replace('/^/m', self::VAR_DUMP_PREFIX, ob_get_clean())
        );
    }

    /**
     * Get the exception trace as plain text.
     * @return string
     */
    private function getTraceOutput()
    {
        if (! $this->addTraceToOutput()) {
            return '';
        }
        $inspector = $this->getInspector();
        $frames = $inspector->getFrames();

        $response = "\nStack trace:";

        $line = 1;
        foreach ($frames as $frame) {
            /** @var Frame $frame */
            $class = $frame->getClass();

            $template = "\n%3d. %s->%s() %s:%d%s";
            if (! $class) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                // Remove method arrow (->) from output.
                $template = "\n%3d. %s%s() %s:%d%s";
            }

            $response .= sprintf(
                $template,
                $line,
                $class,
                $frame->getFunction(),
                $frame->getFile(),
                $frame->getLine(),
                $this->getFrameArgsOutput($frame, $line)
            );

            $line++;
        }

        return $response;
    }

    /**
     * @return int
     */
    public function handle()
    {
        if (! $this->canProcess()) {
            return Handler::DONE;
        }

        $exception = $this->getException();

        $response = sprintf("%s: %s in file %s on line %d%s\n",
                get_class($exception),
                $exception->getMessage(),
                $exception->getFile(),
                $exception->getLine(),
                $this->getTraceOutput()
            );

        if ($this->getLogger()) {
            $this->getLogger()->error($response);
        }

        if (! $this->canOutput()) {
            return Handler::DONE;
        }

        if (class_exists('\Whoops\Util\Misc')
            && \Whoops\Util\Misc::canSendHeaders()) {
            header('Content-Type: text/plain');
        }

        echo $response;

        return Handler::QUIT;
    }
}


1		<?php
2		/**
3		* Whoops - php errors for cool kids
4		* @author Filipe Dobreira <http://github.com/filp>
5		* Plaintext handler for command line and logs.
6		* @author Pierre-Yves Landuré <https://howto.biapy.com/>
7		*/
8
9		namespace Whoops\Handler;
10
11		use InvalidArgumentException;
12		use Psr\Log\LoggerInterface;
13		use Whoops\Exception\Frame;
14
15		/**
16		* Handler outputing plaintext error messages. Can be used
17		* directly, or will be instantiated automagically by Whoops\Run
18		* if passed to Run::pushHandler
19		*/
20		class PlainTextHandler extends Handler
21		{
22		const VAR_DUMP_PREFIX = ' \| ';
23
24		/**
25		* @var \Psr\Log\LoggerInterface
26		*/
27		protected $logger;
28
29		/**
30		* @var bool
31		*/
32		private $addTraceToOutput = true;
33
34		/**
35		* @var bool\|integer
36		*/
37		private $addTraceFunctionArgsToOutput = false;
38
39		/**
40		* @var integer
41		*/
42		private $traceFunctionArgsOutputLimit = 1024;
43
44		/**
45		* @var bool
46		*/
47		private $onlyForCommandLine = false;
48
49		/**
50		* @var bool
51		*/
52		private $outputOnlyIfCommandLine = true;
53
54		/**
55		* @var bool
56		*/
57		private $loggerOnly = false;
58
59		/**
60		* Constructor.
61		* @throws InvalidArgumentException If argument is not null or a LoggerInterface
62		* @param \Psr\Log\LoggerInterface\|null $logger
63		*/
64	1	public function __construct($logger = null)
65		{
66	1	$this->setLogger($logger);
67		}
68
69		/**
70		* Set the output logger interface.
71		* @throws InvalidArgumentException If argument is not null or a LoggerInterface
72		* @param \Psr\Log\LoggerInterface\|null $logger
73		*/
74	2	public function setLogger($logger = null)
75		{
76	2	if (! (is_null($logger)
77	2	\|\| $logger instanceof LoggerInterface)) {
78	2	throw new InvalidArgumentException(
79	2	'Argument to ' . __METHOD__ .
80	2	" must be a valid Logger Interface (aka. Monolog), " .
81	2	get_class($logger) . ' given.'
82	2	);
83		}
84
85	1	$this->logger = $logger;
86	1	}
87
88		/**
89		* @return \Psr\Log\LoggerInterface\|null
90		*/
91		public function getLogger()
92		{
93		return $this->logger;
94		}
95
96		/**
97		* Add error trace to output.
98		* @param bool\|null $addTraceToOutput
99		* @return bool\|$this
100		*/
101	4	public function addTraceToOutput($addTraceToOutput = null)
102		{
103	4	if (func_num_args() == 0) {
104	4	return $this->addTraceToOutput;
105		}
106
107	4	$this->addTraceToOutput = (bool) $addTraceToOutput;
108	4	return $this;
109		}
110
111		/**
112		* Add error trace function arguments to output.
113		* Set to True for all frame args, or integer for the n first frame args.
114		* @param bool\|integer\|null $addTraceFunctionArgsToOutput
115		* @return null\|bool\|integer
116		*/
117	2	public function addTraceFunctionArgsToOutput($addTraceFunctionArgsToOutput = null)
118		{
119	2	if (func_num_args() == 0) {
120	2	return $this->addTraceFunctionArgsToOutput;
121		}
122
123	2	if (! is_integer($addTraceFunctionArgsToOutput)) {
124	1	$this->addTraceFunctionArgsToOutput = (bool) $addTraceFunctionArgsToOutput;
125	1	} else {
126	2	$this->addTraceFunctionArgsToOutput = $addTraceFunctionArgsToOutput;
127		}
128	2	}
129
130		/**
131		* Set the size limit in bytes of frame arguments var_dump output.
132		* If the limit is reached, the var_dump output is discarded.
133		* Prevent memory limit errors.
134		* @var integer
135		*/
136	1	public function setTraceFunctionArgsOutputLimit($traceFunctionArgsOutputLimit)
137		{
138	1	$this->traceFunctionArgsOutputLimit = (integer) $traceFunctionArgsOutputLimit;
139	1	}
140
141		/**
142		* Get the size limit in bytes of frame arguments var_dump output.
143		* If the limit is reached, the var_dump output is discarded.
144		* Prevent memory limit errors.
145		* @return integer
146		*/
147	1	public function getTraceFunctionArgsOutputLimit()
148		{
149	1	return $this->traceFunctionArgsOutputLimit;
150		}
151
152		/**
153		* Restrict error handling to command line calls.
154		* @param bool\|null $onlyForCommandLine
155		* @return null\|bool
156		*/
157	1	public function onlyForCommandLine($onlyForCommandLine = null)
158		{
159	1	if (func_num_args() == 0) {
160	1	return $this->onlyForCommandLine;
161		}
162	1	$this->onlyForCommandLine = (bool) $onlyForCommandLine;
163	1	}
164
165		/**
166		* Output the error message only if using command line.
167		* else, output to logger if available.
168		* Allow to safely add this handler to web pages.
169		* @param bool\|null $outputOnlyIfCommandLine
170		* @return null\|bool
171		*/
172	1	public function outputOnlyIfCommandLine($outputOnlyIfCommandLine = null)
173		{
174	1	if (func_num_args() == 0) {
175	1	return $this->outputOnlyIfCommandLine;
176		}
177	1	$this->outputOnlyIfCommandLine = (bool) $outputOnlyIfCommandLine;
178	1	}
179
180		/**
181		* Only output to logger.
182		* @param bool\|null $loggerOnly
183		* @return null\|bool
184		*/
185	1	public function loggerOnly($loggerOnly = null)
186		{
187	1	if (func_num_args() == 0) {
188	1	return $this->loggerOnly;
189		}
190
191	1	$this->loggerOnly = (bool) $loggerOnly;
192	1	}
193
194		/**
195		* Check, if possible, that this execution was triggered by a command line.
196		* @return bool
197		*/
198		private function isCommandLine()
199		{
200		return PHP_SAPI == 'cli';
201		}
202
203		/**
204		* Test if handler can process the exception..
205		* @return bool
206		*/
207	2	private function canProcess()
208		{
209	2	return $this->isCommandLine() \|\| !$this->onlyForCommandLine();
		0 ignored issues – show Bug Best Practice introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report The expression `$this->onlyForCommandLine()` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
210		}
211
212		/**
213		* Test if handler can output to stdout.
214		* @return bool
215		*/
216	2	private function canOutput()
217		{
218	2	return ($this->isCommandLine() \|\| ! $this->outputOnlyIfCommandLine())
		0 ignored issues – show Bug Best Practice introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report The expression `$this->outputOnlyIfCommandLine()` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
219	2	&& ! $this->loggerOnly();
		0 ignored issues – show Bug Best Practice introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report The expression `$this->loggerOnly()` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
220		}
221
222		/**
223		* Get the frame args var_dump.
224		* @param \Whoops\Exception\Frame $frame [description]
225		* @param integer $line [description]
226		* @return string
227		*/
228	1	private function getFrameArgsOutput(Frame $frame, $line)
229		{
230	1	if ($this->addTraceFunctionArgsToOutput() === false
231	1	\|\| $this->addTraceFunctionArgsToOutput() < $line) {
232	1	return '';
233		}
234
235		// Dump the arguments:
236	1	ob_start();
237	1	var_dump($frame->getArgs());
238	1	if (ob_get_length() > $this->getTraceFunctionArgsOutputLimit()) {
239		// The argument var_dump is to big.
240		// Discarded to limit memory usage.
241		ob_clean();
242		return sprintf(
243		"\n%sArguments dump length greater than %d Bytes. Discarded.",
244		self::VAR_DUMP_PREFIX,
245		$this->getTraceFunctionArgsOutputLimit()
246		);
247		}
248
249	1	return sprintf("\n%s",
250	1	preg_replace('/^/m', self::VAR_DUMP_PREFIX, ob_get_clean())
251	1	);
252		}
253
254		/**
255		* Get the exception trace as plain text.
256		* @return string
257		*/
258	2	private function getTraceOutput()
259		{
260	2	if (! $this->addTraceToOutput()) {
261		return '';
262		}
263	2	$inspector = $this->getInspector();
264	2	$frames = $inspector->getFrames();
265
266	2	$response = "\nStack trace:";
267
268	2	$line = 1;
269	2	foreach ($frames as $frame) {
270		/** @var Frame $frame */
271	2	$class = $frame->getClass();
272
273	2	$template = "\n%3d. %s->%s() %s:%d%s";
274	2	if (! $class) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report The expression `$class` of type `string\|null` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
275		// Remove method arrow (->) from output.
276		$template = "\n%3d. %s%s() %s:%d%s";
277		}
278
279	2	$response .= sprintf(
280	2	$template,
281	2	$line,
282	2	$class,
283	2	$frame->getFunction(),
284	2	$frame->getFile(),
285	2	$frame->getLine(),
286	2	$this->getFrameArgsOutput($frame, $line)
287	2	);
288
289	2	$line++;
290	2	}
291
292	2	return $response;
293		}
294
295		/**
296		* @return int
297		*/
298	3	public function handle()
299		{
300	3	if (! $this->canProcess()) {
301		return Handler::DONE;
302		}
303
304	3	$exception = $this->getException();
305
306	3	$response = sprintf("%s: %s in file %s on line %d%s\n",
307	3	get_class($exception),
308	3	$exception->getMessage(),
309	3	$exception->getFile(),
310	3	$exception->getLine(),
311	3	$this->getTraceOutput()
312	3	);
313
314	3	if ($this->getLogger()) {
315		$this->getLogger()->error($response);
316		}
317
318	3	if (! $this->canOutput()) {
319		return Handler::DONE;
320		}
321
322	3	if (class_exists('\Whoops\Util\Misc')
323	3	&& \Whoops\Util\Misc::canSendHeaders()) {
324		header('Content-Type: text/plain');
325		}
326
327	3	echo $response;
328
329	3	return Handler::QUIT;
330		}
331		}
332

filp / whoops

Pull Request — v1 (#422)

PlainTextHandler::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like