comparison vendor/psy/psysh/src/Formatter/SignatureFormatter.php @ 17:129ea1e6d783

Update, including to Drupal core 8.6.10

 
             case $reflector instanceof ReflectionConstant_:
                 return self::formatConstant($reflector);
 
             default:
-                throw new \InvalidArgumentException('Unexpected Reflector class: ' . get_class($reflector));
+                throw new \InvalidArgumentException('Unexpected Reflector class: ' . \get_class($reflector));
         }
     }
 
     /**
      * Print the signature name.

     private static function formatModifiers(\Reflector $reflector)
     {
         if ($reflector instanceof \ReflectionClass && $reflector->isTrait()) {
             // For some reason, PHP 5.x returns `abstract public` modifiers for
             // traits. Let's just ignore that business entirely.
-            if (version_compare(PHP_VERSION, '7.0.0', '<')) {
+            if (\version_compare(PHP_VERSION, '7.0.0', '<')) {
                 return [];
             }
         }
 
-        return implode(' ', array_map(function ($modifier) {
-            return sprintf('<keyword>%s</keyword>', $modifier);
+        return \implode(' ', \array_map(function ($modifier) {
+            return \sprintf('<keyword>%s</keyword>', $modifier);
         }, \Reflection::getModifierNames($reflector->getModifiers())));
     }
 
     /**
      * Format a class signature.

             $chunks[] = 'trait';
         } else {
             $chunks[] = $reflector->isInterface() ? 'interface' : 'class';
         }
 
-        $chunks[] = sprintf('<class>%s</class>', self::formatName($reflector));
+        $chunks[] = \sprintf('<class>%s</class>', self::formatName($reflector));
 
         if ($parent = $reflector->getParentClass()) {
             $chunks[] = 'extends';
-            $chunks[] = sprintf('<class>%s</class>', $parent->getName());
+            $chunks[] = \sprintf('<class>%s</class>', $parent->getName());
         }
 
         $interfaces = $reflector->getInterfaceNames();
         if (!empty($interfaces)) {
-            sort($interfaces);
+            \sort($interfaces);
 
             $chunks[] = 'implements';
-            $chunks[] = implode(', ', array_map(function ($name) {
-                return sprintf('<class>%s</class>', $name);
+            $chunks[] = \implode(', ', \array_map(function ($name) {
+                return \sprintf('<class>%s</class>', $name);
             }, $interfaces));
         }
 
-        return implode(' ', $chunks);
+        return \implode(' ', $chunks);
     }
 
     /**
      * Format a constant signature.
      *

     private static function formatClassConstant($reflector)
     {
         $value = $reflector->getValue();
         $style = self::getTypeStyle($value);
 
-        return sprintf(
+        return \sprintf(
             '<keyword>const</keyword> <const>%s</const> = <%s>%s</%s>',
             self::formatName($reflector),
             $style,
             OutputFormatter::escape(Json::encode($value)),
             $style

     private static function formatConstant($reflector)
     {
         $value = $reflector->getValue();
         $style = self::getTypeStyle($value);
 
-        return sprintf(
+        return \sprintf(
             '<keyword>define</keyword>(<string>%s</string>, <%s>%s</%s>)',
             OutputFormatter::escape(Json::encode($reflector->getName())),
             $style,
             OutputFormatter::escape(Json::encode($value)),
             $style

      *
      * @return string
      */
     private static function getTypeStyle($value)
     {
-        if (is_int($value) || is_float($value)) {
+        if (\is_int($value) || \is_float($value)) {
             return 'number';
-        } elseif (is_string($value)) {
+        } elseif (\is_string($value)) {
             return 'string';
-        } elseif (is_bool($value) || is_null($value)) {
+        } elseif (\is_bool($value) || \is_null($value)) {
             return 'bool';
         } else {
             return 'strong'; // @codeCoverageIgnore
         }
     }

      *
      * @return string Formatted signature
      */
     private static function formatProperty(\ReflectionProperty $reflector)
     {
-        return sprintf(
+        return \sprintf(
             '%s <strong>$%s</strong>',
             self::formatModifiers($reflector),
             $reflector->getName()
         );
     }

      *
      * @return string Formatted signature
      */
     private static function formatFunction(\ReflectionFunctionAbstract $reflector)
     {
-        return sprintf(
+        return \sprintf(
             '<keyword>function</keyword> %s<function>%s</function>(%s)',
             $reflector->returnsReference() ? '&' : '',
             self::formatName($reflector),
-            implode(', ', self::formatFunctionParams($reflector))
+            \implode(', ', self::formatFunctionParams($reflector))
         );
     }
 
     /**
      * Format a method signature.

      *
      * @return string Formatted signature
      */
     private static function formatMethod(\ReflectionMethod $reflector)
     {
-        return sprintf(
+        return \sprintf(
             '%s %s',
             self::formatModifiers($reflector),
             self::formatFunction($reflector)
         );
     }

             $hint = '';
             try {
                 if ($param->isArray()) {
                     $hint = '<keyword>array</keyword> ';
                 } elseif ($class = $param->getClass()) {
-                    $hint = sprintf('<class>%s</class> ', $class->getName());
+                    $hint = \sprintf('<class>%s</class> ', $class->getName());
                 }
             } catch (\Exception $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> ', $guess);
+                $chunks = \explode('$' . $param->getName(), (string) $param);
+                $chunks = \explode(' ', \trim($chunks[0]));
+                $guess  = \end($chunks);
+
+                $hint = \sprintf('<urgent>%s</urgent> ', $guess);
                 // @codeCoverageIgnoreEnd
             }
 
             if ($param->isOptional()) {
                 if (!$param->isDefaultValueAvailable()) {
                     $value     = 'unknown';
                     $typeStyle = 'urgent';
                 } else {
                     $value     = $param->getDefaultValue();
                     $typeStyle = self::getTypeStyle($value);
-                    $value     = is_array($value) ? 'array()' : is_null($value) ? 'null' : var_export($value, true);
+                    $value     = \is_array($value) ? 'array()' : \is_null($value) ? 'null' : \var_export($value, true);
                 }
-                $default = sprintf(' = <%s>%s</%s>', $typeStyle, OutputFormatter::escape($value), $typeStyle);
+                $default = \sprintf(' = <%s>%s</%s>', $typeStyle, OutputFormatter::escape($value), $typeStyle);
             } else {
                 $default = '';
             }
 
-            $params[] = sprintf(
+            $params[] = \sprintf(
                 '%s%s<strong>$%s</strong>%s',
                 $param->isPassedByReference() ? '&' : '',
                 $hint,
                 $param->getName(),
                 $default