Файл: vendor/psy/psysh/src/Formatter/SignatureFormatter.php
Строк: 400
<?php
/*
* This file is part of Psy Shell.
*
* (c) 2012-2022 Justin Hileman
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PsyFormatter;
use PsyReflectionReflectionClassConstant;
use PsyReflectionReflectionConstant_;
use PsyReflectionReflectionLanguageConstruct;
use PsyUtilJson;
use SymfonyComponentConsoleFormatterOutputFormatter;
/**
* An abstract representation of a function, class or property signature.
*/
class SignatureFormatter implements ReflectorFormatter
{
/**
* Format a signature for the given reflector.
*
* Defers to subclasses to do the actual formatting.
*
* @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);
// this case also covers ReflectionObject:
case $reflector instanceof ReflectionClass:
return self::formatClass($reflector);
case $reflector instanceof ReflectionClassConstant:
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('Unexpected Reflector class: '.get_class($reflector));
}
}
/**
* Print the signature name.
*
* @param Reflector $reflector
*
* @return string Formatted name
*/
public static function formatName(Reflector $reflector): string
{
return $reflector->getName();
}
/**
* Print the method, property or class modifiers.
*
* @param Reflector $reflector
*
* @return string Formatted modifiers
*/
private static function formatModifiers(Reflector $reflector): string
{
return implode(' ', array_map(function ($modifier) {
return sprintf('<keyword>%s</keyword>', $modifier);
}, Reflection::getModifierNames($reflector->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->isTrait()) {
$chunks[] = 'trait';
} else {
$chunks[] = $reflector->isInterface() ? 'interface' : 'class';
}
$chunks[] = sprintf('<class>%s</class>', self::formatName($reflector));
if ($parent = $reflector->getParentClass()) {
$chunks[] = 'extends';
$chunks[] = sprintf('<class>%s</class>', $parent->getName());
}
$interfaces = $reflector->getInterfaceNames();
if (!empty($interfaces)) {
sort($interfaces);
$chunks[] = $reflector->isInterface() ? 'extends' : 'implements';
$chunks[] = implode(', ', array_map(function ($name) {
return sprintf('<class>%s</class>', $name);
}, $interfaces));
}
return implode(' ', $chunks);
}
/**
* Format a constant signature.
*
* @param ReflectionClassConstant|ReflectionClassConstant $reflector
*
* @return string Formatted signature
*/
private static function formatClassConstant($reflector): string
{
$value = $reflector->getValue();
$style = self::getTypeStyle($value);
return sprintf(
'<keyword>const</keyword> <const>%s</const> = <%s>%s</%s>',
self::formatName($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->getValue();
$style = self::getTypeStyle($value);
return sprintf(
'<keyword>define</keyword>(<string>%s</string>, <%s>%s</%s>)',
OutputFormatter::escape(Json::encode($reflector->getName())),
$style,
OutputFormatter::escape(Json::encode($value)),
$style
);
}
/**
* Helper for getting output style for a given value's type.
*
* @param mixed $value
*
* @return string
*/
private static function getTypeStyle($value): string
{
if (is_int($value) || is_float($value)) {
return 'number';
} elseif (is_string($value)) {
return 'string';
} elseif (is_bool($value) || $value === null) {
return 'bool';
} else {
return 'strong'; // @codeCoverageIgnore
}
}
/**
* Format a property signature.
*
* @param ReflectionProperty $reflector
*
* @return string Formatted signature
*/
private static function formatProperty(ReflectionProperty $reflector): string
{
return sprintf(
'%s <strong>$%s</strong>',
self::formatModifiers($reflector),
$reflector->getName()
);
}
/**
* Format a function signature.
*
* @param ReflectionFunction $reflector
*
* @return string Formatted signature
*/
private static function formatFunction(ReflectionFunctionAbstract $reflector): string
{
return sprintf(
'<keyword>function</keyword> %s<function>%s</function>(%s)%s',
$reflector->returnsReference() ? '&' : '',
self::formatName($reflector),
implode(', ', self::formatFunctionParams($reflector)),
self::formatFunctionReturnType($reflector)
);
}
/**
* Format a function signature's return type (if available).
*
* @param ReflectionFunctionAbstract $reflector
*
* @return string Formatted return type
*/
private static function formatFunctionReturnType(ReflectionFunctionAbstract $reflector): string
{
if (!method_exists($reflector, 'hasReturnType') || !$reflector->hasReturnType()) {
return '';
}
return sprintf(': %s', self::formatReflectionType($reflector->getReturnType()));
}
/**
* Format a method signature.
*
* @param ReflectionMethod $reflector
*
* @return string Formatted signature
*/
private static function formatMethod(ReflectionMethod $reflector): string
{
return sprintf(
'%s %s',
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->getParameters() as $param) {
$hint = '';
try {
if (method_exists($param, 'getType')) {
$hint = self::formatReflectionType($param->getType());
} else {
if ($param->isArray()) {
$hint = '<keyword>array</keyword>';
} elseif ($class = $param->getClass()) {
$hint = sprintf('<class>%s</class>', $class->getName());
}
}
} catch (Throwable $e) {
// sometimes we just don't know...
// bad class names, or autoloaded classes that haven't been loaded yet, or whathaveyou.
// come to think of it, the only time I've seen this is with the intl extension.
// Hax: we'll try to extract it :P
// @codeCoverageIgnoreStart
$chunks = explode('$'.$param->getName(), (string) $param);
$chunks = explode(' ', trim($chunks[0]));
$guess = end($chunks);
$hint = sprintf('<urgent>%s</urgent>', OutputFormatter::escape($guess));
// @codeCoverageIgnoreEnd
}
if ($param->isOptional()) {
if (!$param->isDefaultValueAvailable()) {
$value = 'unknown';
$typeStyle = 'urgent';
} else {
$value = $param->getDefaultValue();
$typeStyle = self::getTypeStyle($value);
$value = is_array($value) ? '[]' : ($value === null ? 'null' : var_export($value, true));
}
$default = sprintf(' = <%s>%s</%s>', $typeStyle, OutputFormatter::escape($value), $typeStyle);
} else {
$default = '';
}
$params[] = sprintf(
'%s%s%s<strong>$%s</strong>%s',
$param->isPassedByReference() ? '&' : '',
$hint,
$hint !== '' ? ' ' : '',
$param->getName(),
$default
);
}
return $params;
}
/**
* Print function param or return type(s).
*
* @param ReflectionType $type
*
* @return string
*/
private static function formatReflectionType(ReflectionType $type = null): string
{
if ($type === null) {
return '';
}
$types = $type instanceof ReflectionUnionType ? $type->getTypes() : [$type];
$formattedTypes = [];
foreach ($types as $type) {
$typeStyle = $type->isBuiltin() ? 'keyword' : 'class';
// PHP 7.0 didn't have `getName` on reflection types, so wheee!
$typeName = method_exists($type, 'getName') ? $type->getName() : (string) $type;
// @todo Do we want to include the ? for nullable types? Maybe only sometimes?
$formattedTypes[] = sprintf('<%s>%s</%s>', $typeStyle, OutputFormatter::escape($typeName), $typeStyle);
}
return implode('|', $formattedTypes);
}
}