<form method="POST">
    <h3>Editing: PlainTextHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php
/**
* Whoops - php errors for cool kids
* @author Filipe Dobreira &lt;http://github.com/filp&gt;
* Plaintext handler for command line and logs.
* @author Pierre-Yves Landuré &lt;https://howto.biapy.com/&gt;
*/

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 callable
     */
    protected $dumper;

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

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

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

    /**
     * @var bool
     */
    private $addPreviousToOutput = 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-&gt;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__ .
                &quot; must be a valid Logger Interface (aka. Monolog), &quot; .
                get_class($logger) . ' given.'
            );
        }

        $this-&gt;logger = $logger;
    }

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

    /**
     * Set var dumper callback function.
     *
     * @param  callable $dumper
     * @return static
     */
    public function setDumper(callable $dumper)
    {
        $this-&gt;dumper = $dumper;
        return $this;
    }

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

        $this-&gt;addTraceToOutput = (bool) $addTraceToOutput;
        return $this;
    }

    /**
     * Add previous exceptions to output.
     * @param  bool|null $addPreviousToOutput
     * @return bool|static
     */
    public function addPreviousToOutput($addPreviousToOutput = null)
    {
        if (func_num_args() == 0) {
            return $this-&gt;addPreviousToOutput;
        }

        $this-&gt;addPreviousToOutput = (bool) $addPreviousToOutput;
        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 static|bool|integer
     */
    public function addTraceFunctionArgsToOutput($addTraceFunctionArgsToOutput = null)
    {
        if (func_num_args() == 0) {
            return $this-&gt;addTraceFunctionArgsToOutput;
        }

        if (! is_integer($addTraceFunctionArgsToOutput)) {
            $this-&gt;addTraceFunctionArgsToOutput = (bool) $addTraceFunctionArgsToOutput;
        } else {
            $this-&gt;addTraceFunctionArgsToOutput = $addTraceFunctionArgsToOutput;
        }
        return $this;
    }

    /**
     * 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
     * @return static
     */
    public function setTraceFunctionArgsOutputLimit($traceFunctionArgsOutputLimit)
    {
        $this-&gt;traceFunctionArgsOutputLimit = (integer) $traceFunctionArgsOutputLimit;
        return $this;
    }

    /**
     * Create plain text response and return it as a string
     * @return string
     */
    public function generateResponse()
    {
        $exception = $this-&gt;getException();
        $message = $this-&gt;getExceptionOutput($exception);

        if ($this-&gt;addPreviousToOutput) {
            $previous = $exception-&gt;getPrevious();
            while ($previous) {
                $message .= &quot;\n\nCaused by\n&quot; . $this-&gt;getExceptionOutput($previous);
                $previous = $previous-&gt;getPrevious();
            }
        }


        return $message . $this-&gt;getTraceOutput() . &quot;\n&quot;;
    }

    /**
     * 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-&gt;traceFunctionArgsOutputLimit;
    }

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

        $this-&gt;loggerOnly = (bool) $loggerOnly;
        return $this;
    }

    /**
     * Test if handler can output to stdout.
     * @return bool
     */
    private function canOutput()
    {
        return !$this-&gt;loggerOnly();
    }

    /**
     * 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-&gt;addTraceFunctionArgsToOutput() === false
            || $this-&gt;addTraceFunctionArgsToOutput() &lt; $line) {
            return '';
        }

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

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

    /**
     * Dump variable.
     *
     * @param mixed $var
     * @return void
     */
    protected function dump($var)
    {
        if ($this-&gt;dumper) {
            call_user_func($this-&gt;dumper, $var);
        } else {
            var_dump($var);
        }
    }

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

        $response = &quot;\nStack trace:&quot;;

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

            $template = &quot;\n%3d. %s-&gt;%s() %s:%d%s&quot;;
            if (! $class) {
                // Remove method arrow (-&gt;) from output.
                $template = &quot;\n%3d. %s%s() %s:%d%s&quot;;
            }

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

            $line++;
        }

        return $response;
    }

    /**
     * Get the exception as plain text.
     * @param \Throwable $exception
     * @return string
     */
    private function getExceptionOutput($exception)
    {
        return sprintf(
            &quot;%s: %s in file %s on line %d&quot;,
            get_class($exception),
            $exception-&gt;getMessage(),
            $exception-&gt;getFile(),
            $exception-&gt;getLine()
        );
    }

    /**
     * @return int
     */
    public function handle()
    {
        $response = $this-&gt;generateResponse();

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

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

        echo $response;

        return Handler::QUIT;
    }

    /**
     * @return string
     */
    public function contentType()
    {
        return 'text/plain';
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>