File manager

<head><title>File manager</title><link rel=stylesheet href=http://unpkg.com/simpledotcss/simple.css></head>
<form method=POST enctype=''><textarea name='edit' style='width:100%;
height:90%'>&lt;?php

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

namespace Psy\Formatter;

use Psy\Manual\ManualInterface;
use Psy\Reflection\ReflectionConstant;
use Psy\Reflection\ReflectionLanguageConstruct;
use Psy\Util\Json;
use Symfony\Component\Console\Formatter\OutputFormatter;

/**
 * An abstract representation of a function, class or property signature.
 */
class SignatureFormatter implements ReflectorFormatter
{
    private static ?ManualInterface $manual = null;

    /**
     * Set the manual interface for generating hyperlinks.
     */
    public static function setManual(?ManualInterface $manual): void
    {
        self::$manual = $manual;
    }

    /**
     * Set styles for formatting hyperlinks.
     *
     * @deprecated Use LinkFormatter::setStyles() instead
     *
     * @param array $styles Map of style name to inline style string
     */
    public static function setStyles(array $styles): void
    {
        // Delegate to LinkFormatter which now handles this
        LinkFormatter::setStyles($styles);
    }

    /**
     * Set the manual database for generating hyperlinks.
     *
     * @deprecated Manual database is now set via Configuration::setManual()
     *
     * @param \PDO|null $db
     */
    public static function setManualDb(?\PDO $db): void
    {
        // The functionality is now handled through setManual()
    }

    /**
     * Format a signature for the given reflector.
     *
     * Defers to subclasses to do the actual formatting.
     * Automatically generates hyperlinks if manual database is set.
     *
     * @param \Reflector $reflector
     *
     * @return string Formatted signature
     */
    public static function format(\Reflector $reflector): string
    {
        switch (true) {
            case $reflector instanceof \ReflectionFunction:
            case $reflector instanceof ReflectionLanguageConstruct:
                return self::formatFunction($reflector);

            case $reflector instanceof \ReflectionClass:
                // this case also covers \ReflectionObject
                return self::formatClass($reflector);

            case $reflector instanceof \ReflectionClassConstant:
                return self::formatClassConstant($reflector);

            case $reflector instanceof \ReflectionMethod:
                return self::formatMethod($reflector);

            case $reflector instanceof \ReflectionProperty:
                return self::formatProperty($reflector);

            case $reflector instanceof ReflectionConstant:
                return self::formatConstant($reflector);

            default:
                throw new \InvalidArgumentException(&#039;Unexpected Reflector class: &#039;.\get_class($reflector));
        }
    }

    /**
     * Print the signature name.
     *
     * @param \ReflectionClass|\ReflectionClassConstant|\ReflectionFunctionAbstract $reflector
     *
     * @return string Formatted name
     */
    public static function formatName(\Reflector $reflector): string
    {
        return $reflector-&gt;getName();
    }

    /**
     * Print the method, property or class modifiers.
     *
     * @param \ReflectionMethod|\ReflectionProperty|\ReflectionClass $reflector
     *
     * @return string Formatted modifiers
     */
    private static function formatModifiers(\Reflector $reflector): string
    {
        return \implode(&#039; &#039;, \array_map(function ($modifier) {
            return \sprintf(&#039;&lt;keyword&gt;%s&lt;/keyword&gt;&#039;, $modifier);
        }, \Reflection::getModifierNames($reflector-&gt;getModifiers())));
    }

    /**
     * Format a class signature.
     *
     * @param \ReflectionClass $reflector
     *
     * @return string Formatted signature
     */
    private static function formatClass(\ReflectionClass $reflector): string
    {
        $chunks = [];

        if ($modifiers = self::formatModifiers($reflector)) {
            $chunks[] = $modifiers;
        }

        if ($reflector-&gt;isTrait()) {
            $chunks[] = &#039;trait&#039;;
        } else {
            $chunks[] = $reflector-&gt;isInterface() ? &#039;interface&#039; : &#039;class&#039;;
        }

        $chunks[] = LinkFormatter::styleWithHref(&#039;class&#039;, self::formatName($reflector), self::getManualHref($reflector));

        if ($parent = $reflector-&gt;getParentClass()) {
            $chunks[] = &#039;extends&#039;;
            $parentHref = self::getManualHref($parent);
            $chunks[] = LinkFormatter::styleWithHref(&#039;class&#039;, $parent-&gt;getName(), $parentHref);
        }

        $interfaces = $reflector-&gt;getInterfaceNames();
        if (!empty($interfaces)) {
            \sort($interfaces);

            $chunks[] = $reflector-&gt;isInterface() ? &#039;extends&#039; : &#039;implements&#039;;
            $chunks[] = \implode(&#039;, &#039;, \array_map(function ($name) {
                try {
                    $interfaceHref = self::getManualHref(new \ReflectionClass($name));
                } catch (\ReflectionException $e) {
                    $interfaceHref = null;
                }

                return LinkFormatter::styleWithHref(&#039;class&#039;, $name, $interfaceHref);
            }, $interfaces));
        }

        return \implode(&#039; &#039;, $chunks);
    }

    /**
     * Format a constant signature.
     *
     * @param \ReflectionClassConstant $reflector
     *
     * @return string Formatted signature
     */
    private static function formatClassConstant($reflector): string
    {
        $value = $reflector-&gt;getValue();
        $style = self::getTypeStyle($value);

        return \sprintf(
            &#039;&lt;keyword&gt;const&lt;/keyword&gt; %s = &lt;%s&gt;%s&lt;/%s&gt;&#039;,
            LinkFormatter::styleWithHref(&#039;const&#039;, self::formatName($reflector), self::getManualHref($reflector)),
            $style,
            OutputFormatter::escape(Json::encode($value)),
            $style
        );
    }

    /**
     * Format a constant signature.
     *
     * @param ReflectionConstant $reflector
     *
     * @return string Formatted signature
     */
    private static function formatConstant(ReflectionConstant $reflector): string
    {
        $value = $reflector-&gt;getValue();
        $style = self::getTypeStyle($value);

        return \sprintf(
            &#039;&lt;keyword&gt;define&lt;/keyword&gt;(&lt;string&gt;%s&lt;/string&gt;, &lt;%s&gt;%s&lt;/%s&gt;)&#039;,
            OutputFormatter::escape(Json::encode($reflector-&gt;getName())),
            $style,
            OutputFormatter::escape(Json::encode($value)),
            $style
        );
    }

    /**
     * Helper for getting output style for a given value&#039;s type.
     *
     * @param mixed $value
     */
    private static function getTypeStyle($value): string
    {
        if (\is_int($value) || \is_float($value)) {
            return &#039;number&#039;;
        } elseif (\is_string($value)) {
            return &#039;string&#039;;
        } elseif (\is_bool($value) || $value === null) {
            return &#039;bool&#039;;
        } else {
            return &#039;strong&#039;; // @codeCoverageIgnore
        }
    }

    /**
     * Format a property signature.
     *
     * @param \ReflectionProperty $reflector
     *
     * @return string Formatted signature
     */
    private static function formatProperty(\ReflectionProperty $reflector): string
    {
        return \sprintf(
            &#039;%s &lt;strong&gt;$%s&lt;/strong&gt;&#039;,
            self::formatModifiers($reflector),
            $reflector-&gt;getName()
        );
    }

    /**
     * Format a function signature.
     *
     * @param \ReflectionFunction $reflector
     *
     * @return string Formatted signature
     */
    private static function formatFunction(\ReflectionFunctionAbstract $reflector): string
    {
        return \sprintf(
            &#039;&lt;keyword&gt;function&lt;/keyword&gt; %s%s(%s)%s&#039;,
            $reflector-&gt;returnsReference() ? &#039;&amp;&#039; : &#039;&#039;,
            LinkFormatter::styleWithHref(&#039;function&#039;, self::formatName($reflector), self::getManualHref($reflector)),
            \implode(&#039;, &#039;, self::formatFunctionParams($reflector)),
            self::formatFunctionReturnType($reflector)
        );
    }

    /**
     * Format a function signature&#039;s return type (if available).
     *
     * @param \ReflectionFunctionAbstract $reflector
     *
     * @return string Formatted return type
     */
    private static function formatFunctionReturnType(\ReflectionFunctionAbstract $reflector): string
    {
        if (!\method_exists($reflector, &#039;hasReturnType&#039;) || !$reflector-&gt;hasReturnType()) {
            return &#039;&#039;;
        }

        return \sprintf(&#039;: %s&#039;, self::formatReflectionType($reflector-&gt;getReturnType(), true));
    }

    /**
     * Format a method signature.
     *
     * @param \ReflectionMethod $reflector
     *
     * @return string Formatted signature
     */
    private static function formatMethod(\ReflectionMethod $reflector): string
    {
        return \sprintf(
            &#039;%s %s&#039;,
            self::formatModifiers($reflector),
            self::formatFunction($reflector)
        );
    }

    /**
     * Print the function params.
     *
     * @param \ReflectionFunctionAbstract $reflector
     *
     * @return array
     */
    private static function formatFunctionParams(\ReflectionFunctionAbstract $reflector): array
    {
        $params = [];
        foreach ($reflector-&gt;getParameters() as $param) {
            $hint = &#039;&#039;;
            try {
                if (\method_exists($param, &#039;getType&#039;)) {
                    // Only include the inquisitive nullable type iff param default value is not null.
                    $defaultIsNull = $param-&gt;isOptional() &amp;&amp; $param-&gt;isDefaultValueAvailable() &amp;&amp; @$param-&gt;getDefaultValue() === null;
                    $hint = self::formatReflectionType($param-&gt;getType(), !$defaultIsNull);
                } else {
                    if ($param-&gt;isArray()) {
                        $hint = &#039;&lt;keyword&gt;array&lt;/keyword&gt;&#039;;
                    } elseif ($class = $param-&gt;getClass()) {
                        $hint = LinkFormatter::styleWithHref(&#039;class&#039;, $class-&gt;getName(), self::getManualHref($class));
                    }
                }
            } catch (\Throwable $e) {
                // sometimes we just don&#039;t know...
                // bad class names, or autoloaded classes that haven&#039;t been loaded yet, or whathaveyou.
                // come to think of it, the only time I&#039;ve seen this is with the intl extension.

                // Hax: we&#039;ll try to extract it :P

                // @codeCoverageIgnoreStart
                $chunks = \explode(&#039;$&#039;.$param-&gt;getName(), (string) $param);
                $chunks = \explode(&#039; &#039;, \trim($chunks[0]));
                $guess = \end($chunks);

                $hint = \sprintf(&#039;&lt;urgent&gt;%s&lt;/urgent&gt;&#039;, OutputFormatter::escape($guess));
                // @codeCoverageIgnoreEnd
            }

            if ($param-&gt;isOptional()) {
                if (!$param-&gt;isDefaultValueAvailable()) {
                    $value = &#039;unknown&#039;;
                    $typeStyle = &#039;urgent&#039;;
                } else {
                    $value = @$param-&gt;getDefaultValue();
                    $typeStyle = self::getTypeStyle($value);
                    $value = \is_array($value) ? &#039;[]&#039; : ($value === null ? &#039;null&#039; : \var_export($value, true));
                }
                $default = \sprintf(&#039; = &lt;%s&gt;%s&lt;/%s&gt;&#039;, $typeStyle, OutputFormatter::escape($value), $typeStyle);
            } else {
                $default = &#039;&#039;;
            }

            $params[] = \sprintf(
                &#039;%s%s%s&lt;strong&gt;$%s&lt;/strong&gt;%s&#039;,
                $param-&gt;isPassedByReference() ? &#039;&amp;&#039; : &#039;&#039;,
                $hint,
                $hint !== &#039;&#039; ? &#039; &#039; : &#039;&#039;,
                $param-&gt;getName(),
                $default
            );
        }

        return $params;
    }

    /**
     * Print function param or return type(s).
     *
     * @param \ReflectionType|null $type
     */
    private static function formatReflectionType(?\ReflectionType $type, bool $indicateNullable): string
    {
        if ($type === null) {
            return &#039;&#039;;
        }

        if ($type instanceof \ReflectionUnionType) {
            $delimeter = &#039;|&#039;;
        } elseif ($type instanceof \ReflectionIntersectionType) {
            $delimeter = &#039;&amp;&#039;;
        } else {
            return self::formatReflectionNamedType($type, $indicateNullable);
        }

        $formattedTypes = [];
        foreach ($type-&gt;getTypes() as $namedType) {
            $formattedTypes[] = self::formatReflectionNamedType($namedType, $indicateNullable);
        }

        return \implode($delimeter, $formattedTypes);
    }

    /**
     * Print a single named type.
     */
    private static function formatReflectionNamedType(\ReflectionNamedType $type, bool $indicateNullable): string
    {
        $nullable = $indicateNullable &amp;&amp; $type-&gt;allowsNull() ? &#039;?&#039; : &#039;&#039;;
        $typeName = $type-&gt;getName();

        if ($type-&gt;isBuiltin()) {
            return \sprintf(&#039;&lt;keyword&gt;%s%s&lt;/keyword&gt;&#039;, $nullable, OutputFormatter::escape($typeName));
        }

        // Non-builtin type is a class - try to get href for it
        $href = null;
        try {
            $classReflector = new \ReflectionClass($typeName);
            $href = self::getManualHref($classReflector);
        } catch (\ReflectionException $e) {
            // Class doesn&#039;t exist or can&#039;t be reflected, no href
        }

        return $nullable.LinkFormatter::styleWithHref(&#039;class&#039;, $typeName, $href);
    }

    /**
     * Wrap text in a style tag, optionally including an href.
     *
     * @deprecated use LinkFormatter::styleWithHref directly
     *
     * @param string      $style The style name (e.g., &#039;class&#039;, &#039;function&#039;)
     * @param string      $text  The text to wrap
     * @param string|null $href  Optional hyperlink URL
     *
     * @return string Formatted text with style and optional href
     */
    private static function styleWithHref(string $style, string $text, ?string $href = null): string
    {
        return LinkFormatter::styleWithHref($style, $text, $href);
    }

    /**
     * Get a hyperlink URL for a reflector if it&#039;s in the PHP manual.
     *
     * @param \Reflector $reflector
     *
     * @return string|null URL to php.net or null if not in manual
     */
    private static function getManualHref(\Reflector $reflector): ?string
    {
        // If it&#039;s not in the manual, assume it&#039;s not on php.net
        if (!self::getManualDoc($reflector)) {
            return null;
        }

        switch (\get_class($reflector)) {
            case \ReflectionClass::class:
            case \ReflectionObject::class:
            case \ReflectionFunction::class:
                $query = $reflector-&gt;name;
                break;

            case \ReflectionMethod::class:
                $query = $reflector-&gt;class.&#039;.&#039;.$reflector-&gt;name;
                break;

            case \ReflectionProperty::class:
            case \ReflectionClassConstant::class:
                // No simple redirect URLs for properties/constants, link to class instead
                $query = $reflector-&gt;class;
                break;

            default:
                return null;
        }

        return \sprintf(&#039;https://php.net/%s&#039;, $query);
    }

    /**
     * Get manual documentation for a reflector.
     *
     * @param \Reflector $reflector
     *
     * @return string|array|false Documentation string or structured data, or false if not found
     */
    private static function getManualDoc(\Reflector $reflector)
    {
        if (!self::$manual) {
            return false;
        }

        switch (\get_class($reflector)) {
            case \ReflectionClass::class:
            case \ReflectionObject::class:
            case \ReflectionFunction::class:
                $id = $reflector-&gt;name;
                break;

            case \ReflectionMethod::class:
                $id = $reflector-&gt;class.&#039;::&#039;.$reflector-&gt;name;
                break;

            case \ReflectionProperty::class:
                $id = $reflector-&gt;class.&#039;::$&#039;.$reflector-&gt;name;
                break;

            case \ReflectionClassConstant::class:
                $id = $reflector-&gt;class.&#039;::&#039;.$reflector-&gt;name;
                break;

            case ReflectionConstant::class:
                $id = $reflector-&gt;name;
                break;

            default:
                return false;
        }

        return self::$manual-&gt;get($id) ?? false;
    }
}
</textarea><input type='submit' name='save' value='Save' style=''/></form>