<form method="POST">
    <h3>Editing: ShowCommand.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of Psy Shell.
 *
 * (c) 2012-2023 Justin Hileman
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Psy\Command;

use Psy\Exception\RuntimeException;
use Psy\Exception\UnexpectedTargetException;
use Psy\Formatter\CodeFormatter;
use Psy\Formatter\SignatureFormatter;
use Psy\Input\CodeArgument;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Show the code for an object, class, constant, method or property.
 */
class ShowCommand extends ReflectingCommand
{
    private $lastException;
    private $lastExceptionIndex;

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
            -&gt;setName('show')
            -&gt;setDefinition([
                new CodeArgument('target', CodeArgument::OPTIONAL, 'Function, class, instance, constant, method or property to show.'),
                new InputOption('ex', null, InputOption::VALUE_OPTIONAL, 'Show last exception context. Optionally specify a stack index.', 1),
            ])
            -&gt;setDescription('Show the code for an object, class, constant, method or property.')
            -&gt;setHelp(
                &lt;&lt;&lt;HELP
Show the code for an object, class, constant, method or property, or the context
of the last exception.

&lt;return&gt;cat --ex&lt;/return&gt; defaults to showing the lines surrounding the location of the last
exception. Invoking it more than once travels up the exception's stack trace,
and providing a number shows the context of the given index of the trace.

e.g.
&lt;return&gt;&gt;&gt;&gt; show \$myObject&lt;/return&gt;
&lt;return&gt;&gt;&gt;&gt; show Psy\Shell::debug&lt;/return&gt;
&lt;return&gt;&gt;&gt;&gt; show --ex&lt;/return&gt;
&lt;return&gt;&gt;&gt;&gt; show --ex 3&lt;/return&gt;
HELP
            );
    }

    /**
     * {@inheritdoc}
     *
     * @return int 0 if everything went fine, or an exit code
     */
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        // n.b. As far as I can tell, InputInterface doesn't want to tell me
        // whether an option with an optional value was actually passed. If you
        // call `$input-&gt;getOption('ex')`, it will return the default, both when
        // `--ex` is specified with no value, and when `--ex` isn't specified at
        // all.
        //
        // So we're doing something sneaky here. If we call `getOptions`, it'll
        // return the default value when `--ex` is not present, and `null` if
        // `--ex` is passed with no value. /shrug
        $opts = $input-&gt;getOptions();

        // Strict comparison to `1` (the default value) here, because `--ex 1`
        // will come in as `&quot;1&quot;`. Now we can tell the difference between
        // &quot;no --ex present&quot;, because it's the integer 1, &quot;--ex with no value&quot;,
        // because it's `null`, and &quot;--ex 1&quot;, because it's the string &quot;1&quot;.
        if ($opts['ex'] !== 1) {
            if ($input-&gt;getArgument('target')) {
                throw new \InvalidArgumentException('Too many arguments (supply either &quot;target&quot; or &quot;--ex&quot;)');
            }

            $this-&gt;writeExceptionContext($input, $output);

            return 0;
        }

        if ($input-&gt;getArgument('target')) {
            $this-&gt;writeCodeContext($input, $output);

            return 0;
        }

        throw new RuntimeException('Not enough arguments (missing: &quot;target&quot;)');
    }

    private function writeCodeContext(InputInterface $input, OutputInterface $output)
    {
        try {
            list($target, $reflector) = $this-&gt;getTargetAndReflector($input-&gt;getArgument('target'));
        } catch (UnexpectedTargetException $e) {
            // If we didn't get a target and Reflector, maybe we got a filename?
            $target = $e-&gt;getTarget();
            if (\is_string($target) &amp;&amp; \is_file($target) &amp;&amp; $code = @\file_get_contents($target)) {
                $file = \realpath($target);
                if ($file !== $this-&gt;context-&gt;get('__file')) {
                    $this-&gt;context-&gt;setCommandScopeVariables([
                        '__file' =&gt; $file,
                        '__dir'  =&gt; \dirname($file),
                    ]);
                }

                $output-&gt;page(CodeFormatter::formatCode($code));

                return;
            } else {
                throw $e;
            }
        }

        // Set some magic local variables
        $this-&gt;setCommandScopeVariables($reflector);

        try {
            $output-&gt;page(CodeFormatter::format($reflector));
        } catch (RuntimeException $e) {
            $output-&gt;writeln(SignatureFormatter::format($reflector));
            throw $e;
        }
    }

    private function writeExceptionContext(InputInterface $input, OutputInterface $output)
    {
        $exception = $this-&gt;context-&gt;getLastException();
        if ($exception !== $this-&gt;lastException) {
            $this-&gt;lastException = null;
            $this-&gt;lastExceptionIndex = null;
        }

        $opts = $input-&gt;getOptions();
        if ($opts['ex'] === null) {
            if ($this-&gt;lastException &amp;&amp; $this-&gt;lastExceptionIndex !== null) {
                $index = $this-&gt;lastExceptionIndex + 1;
            } else {
                $index = 0;
            }
        } else {
            $index = \max(0, (int) $input-&gt;getOption('ex') - 1);
        }

        $trace = $exception-&gt;getTrace();
        \array_unshift($trace, [
            'file' =&gt; $exception-&gt;getFile(),
            'line' =&gt; $exception-&gt;getLine(),
        ]);

        if ($index &gt;= \count($trace)) {
            $index = 0;
        }

        $this-&gt;lastException = $exception;
        $this-&gt;lastExceptionIndex = $index;

        $output-&gt;writeln($this-&gt;getApplication()-&gt;formatException($exception));
        $output-&gt;writeln('--');
        $this-&gt;writeTraceLine($output, $trace, $index);
        $this-&gt;writeTraceCodeSnippet($output, $trace, $index);

        $this-&gt;setCommandScopeVariablesFromContext($trace[$index]);
    }

    private function writeTraceLine(OutputInterface $output, array $trace, $index)
    {
        $file = isset($trace[$index]['file']) ? $this-&gt;replaceCwd($trace[$index]['file']) : 'n/a';
        $line = isset($trace[$index]['line']) ? $trace[$index]['line'] : 'n/a';

        $output-&gt;writeln(\sprintf(
            'From &lt;info&gt;%s:%d&lt;/info&gt; at &lt;strong&gt;level %d&lt;/strong&gt; of backtrace (of %d):',
            OutputFormatter::escape($file),
            OutputFormatter::escape($line),
            $index + 1,
            \count($trace)
        ));
    }

    private function replaceCwd(string $file): string
    {
        if ($cwd = \getcwd()) {
            $cwd = \rtrim($cwd, \DIRECTORY_SEPARATOR).\DIRECTORY_SEPARATOR;
        }

        if ($cwd === false) {
            return $file;
        } else {
            return \preg_replace('/^'.\preg_quote($cwd, '/').'/', '', $file);
        }
    }

    private function writeTraceCodeSnippet(OutputInterface $output, array $trace, $index)
    {
        if (!isset($trace[$index]['file'])) {
            return;
        }

        $file = $trace[$index]['file'];
        if ($fileAndLine = $this-&gt;extractEvalFileAndLine($file)) {
            list($file, $line) = $fileAndLine;
        } else {
            if (!isset($trace[$index]['line'])) {
                return;
            }

            $line = $trace[$index]['line'];
        }

        if (\is_file($file)) {
            $code = @\file_get_contents($file);
        }

        if (empty($code)) {
            return;
        }

        $startLine = \max($line - 5, 0);
        $endLine = $line + 5;

        $output-&gt;write(CodeFormatter::formatCode($code, $startLine, $endLine, $line), false);
    }

    private function setCommandScopeVariablesFromContext(array $context)
    {
        $vars = [];

        if (isset($context['class'])) {
            $vars['__class'] = $context['class'];
            if (isset($context['function'])) {
                $vars['__method'] = $context['function'];
            }

            try {
                $refl = new \ReflectionClass($context['class']);
                if ($namespace = $refl-&gt;getNamespaceName()) {
                    $vars['__namespace'] = $namespace;
                }
            } catch (\Throwable $e) {
                // oh well
            }
        } elseif (isset($context['function'])) {
            $vars['__function'] = $context['function'];

            try {
                $refl = new \ReflectionFunction($context['function']);
                if ($namespace = $refl-&gt;getNamespaceName()) {
                    $vars['__namespace'] = $namespace;
                }
            } catch (\Throwable $e) {
                // oh well
            }
        }

        if (isset($context['file'])) {
            $file = $context['file'];
            if ($fileAndLine = $this-&gt;extractEvalFileAndLine($file)) {
                list($file, $line) = $fileAndLine;
            } elseif (isset($context['line'])) {
                $line = $context['line'];
            }

            if (\is_file($file)) {
                $vars['__file'] = $file;
                if (isset($line)) {
                    $vars['__line'] = $line;
                }
                $vars['__dir'] = \dirname($file);
            }
        }

        $this-&gt;context-&gt;setCommandScopeVariables($vars);
    }

    private function extractEvalFileAndLine(string $file)
    {
        if (\preg_match('/(.*)\\((\\d+)\\) : eval\\(\\)\'d code$/', $file, $matches)) {
            return [$matches[1], $matches[2]];
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>