@averay/codeformat 0.2.1 → 0.2.3

package/vendor/symfony/console/Output/AnsiColorMode.php

@@ -0,0 +1,106 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+use Symfony\Component\Console\Exception\InvalidArgumentException;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Julien Boudry <julien@condorcet.vote>
+ */
+enum AnsiColorMode
+{
+    /*
+     * Classical 4-bit Ansi colors, including 8 classical colors and 8 bright color. Output syntax is "ESC[${foreGroundColorcode};${backGroundColorcode}m"
+     * Must be compatible with all terminals and it's the minimal version supported.
+     */
+    case Ansi4;
+
+    /*
+     * 8-bit Ansi colors (240 different colors + 16 duplicate color codes, ensuring backward compatibility).
+     * Output syntax is: "ESC[38;5;${foreGroundColorcode};48;5;${backGroundColorcode}m"
+     * Should be compatible with most terminals.
+     */
+    case Ansi8;
+
+    /*
+     * 24-bit Ansi colors (RGB).
+     * Output syntax is: "ESC[38;2;${foreGroundColorcodeRed};${foreGroundColorcodeGreen};${foreGroundColorcodeBlue};48;2;${backGroundColorcodeRed};${backGroundColorcodeGreen};${backGroundColorcodeBlue}m"
+     * May be compatible with many modern terminals.
+     */
+    case Ansi24;
+
+    /**
+     * Converts an RGB hexadecimal color to the corresponding Ansi code.
+     */
+    public function convertFromHexToAnsiColorCode(string $hexColor): string
+    {
+        $hexColor = str_replace('#', '', $hexColor);
+
+        if (3 === \strlen($hexColor)) {
+            $hexColor = $hexColor[0].$hexColor[0].$hexColor[1].$hexColor[1].$hexColor[2].$hexColor[2];
+        }
+
+        if (6 !== \strlen($hexColor)) {
+            throw new InvalidArgumentException(\sprintf('Invalid "#%s" color.', $hexColor));
+        }
+
+        $color = hexdec($hexColor);
+
+        $r = ($color >> 16) & 255;
+        $g = ($color >> 8) & 255;
+        $b = $color & 255;
+
+        return match ($this) {
+            self::Ansi4 => (string) $this->convertFromRGB($r, $g, $b),
+            self::Ansi8 => '8;5;'.$this->convertFromRGB($r, $g, $b),
+            self::Ansi24 => \sprintf('8;2;%d;%d;%d', $r, $g, $b),
+        };
+    }
+
+    private function convertFromRGB(int $r, int $g, int $b): int
+    {
+        return match ($this) {
+            self::Ansi4 => $this->degradeHexColorToAnsi4($r, $g, $b),
+            self::Ansi8 => $this->degradeHexColorToAnsi8($r, $g, $b),
+            default => throw new InvalidArgumentException("RGB cannot be converted to {$this->name}."),
+        };
+    }
+
+    private function degradeHexColorToAnsi4(int $r, int $g, int $b): int
+    {
+        return round($b / 255) << 2 | (round($g / 255) << 1) | round($r / 255);
+    }
+
+    /**
+     * Inspired from https://github.com/ajalt/colormath/blob/e464e0da1b014976736cf97250063248fc77b8e7/colormath/src/commonMain/kotlin/com/github/ajalt/colormath/model/Ansi256.kt code (MIT license).
+     */
+    private function degradeHexColorToAnsi8(int $r, int $g, int $b): int
+    {
+        if ($r === $g && $g === $b) {
+            if ($r < 8) {
+                return 16;
+            }
+
+            if ($r > 248) {
+                return 231;
+            }
+
+            return (int) round(($r - 8) / 247 * 24) + 232;
+        }
+
+        return 16 +
+            (36 * (int) round($r / 255 * 5)) +
+            (6 * (int) round($g / 255 * 5)) +
+            (int) round($b / 255 * 5);
+    }
+}

package/vendor/symfony/console/Output/BufferedOutput.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+/**
+ * @author Jean-François Simon <contact@jfsimon.fr>
+ */
+class BufferedOutput extends Output
+{
+    private string $buffer = '';
+
+    /**
+     * Empties buffer and returns its content.
+     */
+    public function fetch(): string
+    {
+        $content = $this->buffer;
+        $this->buffer = '';
+
+        return $content;
+    }
+
+    protected function doWrite(string $message, bool $newline): void
+    {
+        $this->buffer .= $message;
+
+        if ($newline) {
+            $this->buffer .= \PHP_EOL;
+        }
+    }
+}

package/vendor/symfony/console/Output/ConsoleOutput.php

@@ -0,0 +1,153 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+use Symfony\Component\Console\Formatter\OutputFormatterInterface;
+
+/**
+ * ConsoleOutput is the default class for all CLI output. It uses STDOUT and STDERR.
+ *
+ * This class is a convenient wrapper around `StreamOutput` for both STDOUT and STDERR.
+ *
+ *     $output = new ConsoleOutput();
+ *
+ * This is equivalent to:
+ *
+ *     $output = new StreamOutput(fopen('php://stdout', 'w'));
+ *     $stdErr = new StreamOutput(fopen('php://stderr', 'w'));
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ConsoleOutput extends StreamOutput implements ConsoleOutputInterface
+{
+    private OutputInterface $stderr;
+    private array $consoleSectionOutputs = [];
+
+    /**
+     * @param int                           $verbosity The verbosity level (one of the VERBOSITY constants in OutputInterface)
+     * @param bool|null                     $decorated Whether to decorate messages (null for auto-guessing)
+     * @param OutputFormatterInterface|null $formatter Output formatter instance (null to use default OutputFormatter)
+     */
+    public function __construct(int $verbosity = self::VERBOSITY_NORMAL, ?bool $decorated = null, ?OutputFormatterInterface $formatter = null)
+    {
+        parent::__construct($this->openOutputStream(), $verbosity, $decorated, $formatter);
+
+        if (null === $formatter) {
+            // for BC reasons, stdErr has it own Formatter only when user don't inject a specific formatter.
+            $this->stderr = new StreamOutput($this->openErrorStream(), $verbosity, $decorated);
+
+            return;
+        }
+
+        $actualDecorated = $this->isDecorated();
+        $this->stderr = new StreamOutput($this->openErrorStream(), $verbosity, $decorated, $this->getFormatter());
+
+        if (null === $decorated) {
+            $this->setDecorated($actualDecorated && $this->stderr->isDecorated());
+        }
+    }
+
+    /**
+     * Creates a new output section.
+     */
+    public function section(): ConsoleSectionOutput
+    {
+        return new ConsoleSectionOutput($this->getStream(), $this->consoleSectionOutputs, $this->getVerbosity(), $this->isDecorated(), $this->getFormatter());
+    }
+
+    public function setDecorated(bool $decorated): void
+    {
+        parent::setDecorated($decorated);
+        $this->stderr->setDecorated($decorated);
+    }
+
+    public function setFormatter(OutputFormatterInterface $formatter): void
+    {
+        parent::setFormatter($formatter);
+        $this->stderr->setFormatter($formatter);
+    }
+
+    public function setVerbosity(int $level): void
+    {
+        parent::setVerbosity($level);
+        $this->stderr->setVerbosity($level);
+    }
+
+    public function getErrorOutput(): OutputInterface
+    {
+        return $this->stderr;
+    }
+
+    public function setErrorOutput(OutputInterface $error): void
+    {
+        $this->stderr = $error;
+    }
+
+    /**
+     * Returns true if current environment supports writing console output to
+     * STDOUT.
+     */
+    protected function hasStdoutSupport(): bool
+    {
+        return false === $this->isRunningOS400();
+    }
+
+    /**
+     * Returns true if current environment supports writing console output to
+     * STDERR.
+     */
+    protected function hasStderrSupport(): bool
+    {
+        return false === $this->isRunningOS400();
+    }
+
+    /**
+     * Checks if current executing environment is IBM iSeries (OS400), which
+     * doesn't properly convert character-encodings between ASCII to EBCDIC.
+     */
+    private function isRunningOS400(): bool
+    {
+        $checks = [
+            \function_exists('php_uname') ? php_uname('s') : '',
+            getenv('OSTYPE'),
+            \PHP_OS,
+        ];
+
+        return false !== stripos(implode(';', $checks), 'OS400');
+    }
+
+    /**
+     * @return resource
+     */
+    private function openOutputStream()
+    {
+        if (!$this->hasStdoutSupport()) {
+            return fopen('php://output', 'w');
+        }
+
+        // Use STDOUT when possible to prevent from opening too many file descriptors
+        return \defined('STDOUT') ? \STDOUT : (@fopen('php://stdout', 'w') ?: fopen('php://output', 'w'));
+    }
+
+    /**
+     * @return resource
+     */
+    private function openErrorStream()
+    {
+        if (!$this->hasStderrSupport()) {
+            return fopen('php://output', 'w');
+        }
+
+        // Use STDERR when possible to prevent from opening too many file descriptors
+        return \defined('STDERR') ? \STDERR : (@fopen('php://stderr', 'w') ?: fopen('php://output', 'w'));
+    }
+}

package/vendor/symfony/console/Output/ConsoleOutputInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+/**
+ * ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
+ * This adds information about stderr and section output stream.
+ *
+ * @author Dariusz Górecki <darek.krk@gmail.com>
+ */
+interface ConsoleOutputInterface extends OutputInterface
+{
+    /**
+     * Gets the OutputInterface for errors.
+     */
+    public function getErrorOutput(): OutputInterface;
+
+    public function setErrorOutput(OutputInterface $error): void;
+
+    public function section(): ConsoleSectionOutput;
+}

package/vendor/symfony/console/Output/ConsoleSectionOutput.php

@@ -0,0 +1,237 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+use Symfony\Component\Console\Formatter\OutputFormatterInterface;
+use Symfony\Component\Console\Helper\Helper;
+use Symfony\Component\Console\Terminal;
+
+/**
+ * @author Pierre du Plessis <pdples@gmail.com>
+ * @author Gabriel Ostrolucký <gabriel.ostrolucky@gmail.com>
+ */
+class ConsoleSectionOutput extends StreamOutput
+{
+    private array $content = [];
+    private int $lines = 0;
+    private array $sections;
+    private Terminal $terminal;
+    private int $maxHeight = 0;
+
+    /**
+     * @param resource               $stream
+     * @param ConsoleSectionOutput[] $sections
+     */
+    public function __construct($stream, array &$sections, int $verbosity, bool $decorated, OutputFormatterInterface $formatter)
+    {
+        parent::__construct($stream, $verbosity, $decorated, $formatter);
+        array_unshift($sections, $this);
+        $this->sections = &$sections;
+        $this->terminal = new Terminal();
+    }
+
+    /**
+     * Defines a maximum number of lines for this section.
+     *
+     * When more lines are added, the section will automatically scroll to the
+     * end (i.e. remove the first lines to comply with the max height).
+     */
+    public function setMaxHeight(int $maxHeight): void
+    {
+        // when changing max height, clear output of current section and redraw again with the new height
+        $previousMaxHeight = $this->maxHeight;
+        $this->maxHeight = $maxHeight;
+        $existingContent = $this->popStreamContentUntilCurrentSection($previousMaxHeight ? min($previousMaxHeight, $this->lines) : $this->lines);
+
+        parent::doWrite($this->getVisibleContent(), false);
+        parent::doWrite($existingContent, false);
+    }
+
+    /**
+     * Clears previous output for this section.
+     *
+     * @param int $lines Number of lines to clear. If null, then the entire output of this section is cleared
+     */
+    public function clear(?int $lines = null): void
+    {
+        if (!$this->content || !$this->isDecorated()) {
+            return;
+        }
+
+        if ($lines) {
+            array_splice($this->content, -$lines);
+        } else {
+            $lines = $this->lines;
+            $this->content = [];
+        }
+
+        $this->lines -= $lines;
+
+        parent::doWrite($this->popStreamContentUntilCurrentSection($this->maxHeight ? min($this->maxHeight, $lines) : $lines), false);
+    }
+
+    /**
+     * Overwrites the previous output with a new message.
+     */
+    public function overwrite(string|iterable $message): void
+    {
+        $this->clear();
+        $this->writeln($message);
+    }
+
+    public function getContent(): string
+    {
+        return implode('', $this->content);
+    }
+
+    public function getVisibleContent(): string
+    {
+        if (0 === $this->maxHeight) {
+            return $this->getContent();
+        }
+
+        return implode('', \array_slice($this->content, -$this->maxHeight));
+    }
+
+    /**
+     * @internal
+     */
+    public function addContent(string $input, bool $newline = true): int
+    {
+        $width = $this->terminal->getWidth();
+        $lines = explode(\PHP_EOL, $input);
+        $linesAdded = 0;
+        $count = \count($lines) - 1;
+        foreach ($lines as $i => $lineContent) {
+            // re-add the line break (that has been removed in the above `explode()` for
+            // - every line that is not the last line
+            // - if $newline is required, also add it to the last line
+            if ($i < $count || $newline) {
+                $lineContent .= \PHP_EOL;
+            }
+
+            // skip line if there is no text (or newline for that matter)
+            if ('' === $lineContent) {
+                continue;
+            }
+
+            // For the first line, check if the previous line (last entry of `$this->content`)
+            // needs to be continued (i.e. does not end with a line break).
+            if (0 === $i
+                && (false !== $lastLine = end($this->content))
+                && !str_ends_with($lastLine, \PHP_EOL)
+            ) {
+                // deduct the line count of the previous line
+                $this->lines -= (int) ceil($this->getDisplayLength($lastLine) / $width) ?: 1;
+                // concatenate previous and new line
+                $lineContent = $lastLine.$lineContent;
+                // replace last entry of `$this->content` with the new expanded line
+                array_splice($this->content, -1, 1, $lineContent);
+            } else {
+                // otherwise just add the new content
+                $this->content[] = $lineContent;
+            }
+
+            $linesAdded += (int) ceil($this->getDisplayLength($lineContent) / $width) ?: 1;
+        }
+
+        $this->lines += $linesAdded;
+
+        return $linesAdded;
+    }
+
+    /**
+     * @internal
+     */
+    public function addNewLineOfInputSubmit(): void
+    {
+        $this->content[] = \PHP_EOL;
+        ++$this->lines;
+    }
+
+    protected function doWrite(string $message, bool $newline): void
+    {
+        // Simulate newline behavior for consistent output formatting, avoiding extra logic
+        if (!$newline && str_ends_with($message, \PHP_EOL)) {
+            $message = substr($message, 0, -\strlen(\PHP_EOL));
+            $newline = true;
+        }
+
+        if (!$this->isDecorated()) {
+            parent::doWrite($message, $newline);
+
+            return;
+        }
+
+        // Check if the previous line (last entry of `$this->content`) needs to be continued
+        // (i.e. does not end with a line break). In which case, it needs to be erased first.
+        $linesToClear = $deleteLastLine = ($lastLine = end($this->content) ?: '') && !str_ends_with($lastLine, \PHP_EOL) ? 1 : 0;
+
+        $linesAdded = $this->addContent($message, $newline);
+
+        if ($lineOverflow = $this->maxHeight > 0 && $this->lines > $this->maxHeight) {
+            // on overflow, clear the whole section and redraw again (to remove the first lines)
+            $linesToClear = $this->maxHeight;
+        }
+
+        $erasedContent = $this->popStreamContentUntilCurrentSection($linesToClear);
+
+        if ($lineOverflow) {
+            // redraw existing lines of the section
+            $previousLinesOfSection = \array_slice($this->content, $this->lines - $this->maxHeight, $this->maxHeight - $linesAdded);
+            parent::doWrite(implode('', $previousLinesOfSection), false);
+        }
+
+        // if the last line was removed, re-print its content together with the new content.
+        // otherwise, just print the new content.
+        parent::doWrite($deleteLastLine ? $lastLine.$message : $message, true);
+        parent::doWrite($erasedContent, false);
+    }
+
+    /**
+     * At initial stage, cursor is at the end of stream output. This method makes cursor crawl upwards until it hits
+     * current section. Then it erases content it crawled through. Optionally, it erases part of current section too.
+     */
+    private function popStreamContentUntilCurrentSection(int $numberOfLinesToClearFromCurrentSection = 0): string
+    {
+        $numberOfLinesToClear = $numberOfLinesToClearFromCurrentSection;
+        $erasedContent = [];
+
+        foreach ($this->sections as $section) {
+            if ($section === $this) {
+                break;
+            }
+
+            $numberOfLinesToClear += $section->maxHeight ? min($section->lines, $section->maxHeight) : $section->lines;
+            if ('' !== $sectionContent = $section->getVisibleContent()) {
+                if (!str_ends_with($sectionContent, \PHP_EOL)) {
+                    $sectionContent .= \PHP_EOL;
+                }
+                $erasedContent[] = $sectionContent;
+            }
+        }
+
+        if ($numberOfLinesToClear > 0) {
+            // move cursor up n lines
+            parent::doWrite(\sprintf("\x1b[%dA", $numberOfLinesToClear), false);
+            // erase to end of screen
+            parent::doWrite("\x1b[0J", false);
+        }
+
+        return implode('', array_reverse($erasedContent));
+    }
+
+    private function getDisplayLength(string $text): int
+    {
+        return Helper::width(Helper::removeDecoration($this->getFormatter(), str_replace("\t", '        ', $text)));
+    }
+}

package/vendor/symfony/console/Output/NullOutput.php

@@ -0,0 +1,94 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Output;
+
+use Symfony\Component\Console\Formatter\NullOutputFormatter;
+use Symfony\Component\Console\Formatter\OutputFormatterInterface;
+
+/**
+ * NullOutput suppresses all output.
+ *
+ *     $output = new NullOutput();
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Tobias Schultze <http://tobion.de>
+ */
+class NullOutput implements OutputInterface
+{
+    private NullOutputFormatter $formatter;
+
+    public function setFormatter(OutputFormatterInterface $formatter): void
+    {
+        // do nothing
+    }
+
+    public function getFormatter(): OutputFormatterInterface
+    {
+        // to comply with the interface we must return a OutputFormatterInterface
+        return $this->formatter ??= new NullOutputFormatter();
+    }
+
+    public function setDecorated(bool $decorated): void
+    {
+        // do nothing
+    }
+
+    public function isDecorated(): bool
+    {
+        return false;
+    }
+
+    public function setVerbosity(int $level): void
+    {
+        // do nothing
+    }
+
+    public function getVerbosity(): int
+    {
+        return self::VERBOSITY_SILENT;
+    }
+
+    public function isSilent(): bool
+    {
+        return true;
+    }
+
+    public function isQuiet(): bool
+    {
+        return false;
+    }
+
+    public function isVerbose(): bool
+    {
+        return false;
+    }
+
+    public function isVeryVerbose(): bool
+    {
+        return false;
+    }
+
+    public function isDebug(): bool
+    {
+        return false;
+    }
+
+    public function writeln(string|iterable $messages, int $options = self::OUTPUT_NORMAL): void
+    {
+        // do nothing
+    }
+
+    public function write(string|iterable $messages, bool $newline = false, int $options = self::OUTPUT_NORMAL): void
+    {
+        // do nothing
+    }
+}