@averay/codeformat 0.2.1 → 0.2.3

package/vendor/friendsofphp/php-cs-fixer/src/Console/WarningsDetector.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Console;
+
+use PhpCsFixer\ToolInfo;
+use PhpCsFixer\ToolInfoInterface;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @internal
+ */
+final class WarningsDetector
+{
+    private ToolInfoInterface $toolInfo;
+
+    /**
+     * @var list<string>
+     */
+    private array $warnings = [];
+
+    public function __construct(ToolInfoInterface $toolInfo)
+    {
+        $this->toolInfo = $toolInfo;
+    }
+
+    public function detectOldMajor(): void
+    {
+        // @TODO 3.99 to be activated with new MAJOR release 4.0
+        // $currentMajorVersion = \intval(explode('.', Application::VERSION)[0], 10);
+        // $nextMajorVersion = $currentMajorVersion + 1;
+        // $this->warnings[] = "You are running PHP CS Fixer v{$currentMajorVersion}, which is not maintained anymore. Please update to v{$nextMajorVersion}.";
+        // $this->warnings[] = "You may find an UPGRADE guide at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/v{$nextMajorVersion}.0.0/UPGRADE-v{$nextMajorVersion}.md .";
+    }
+
+    public function detectOldVendor(): void
+    {
+        if ($this->toolInfo->isInstalledByComposer()) {
+            $details = $this->toolInfo->getComposerInstallationDetails();
+            if (ToolInfo::COMPOSER_LEGACY_PACKAGE_NAME === $details['name']) {
+                $this->warnings[] = \sprintf(
+                    'You are running PHP CS Fixer installed with old vendor `%s`. Please update to `%s`.',
+                    ToolInfo::COMPOSER_LEGACY_PACKAGE_NAME,
+                    ToolInfo::COMPOSER_PACKAGE_NAME
+                );
+            }
+        }
+    }
+
+    /**
+     * @return list<string>
+     */
+    public function getWarnings(): array
+    {
+        if (0 === \count($this->warnings)) {
+            return [];
+        }
+
+        return array_values(array_unique(array_merge(
+            $this->warnings,
+            ['If you need help while solving warnings, ask at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/discussions/, we will help you!']
+        )));
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Differ/DiffConsoleFormatter.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Differ;
+
+use PhpCsFixer\Preg;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @readonly
+ *
+ * @internal
+ */
+final class DiffConsoleFormatter
+{
+    private bool $isDecoratedOutput;
+
+    private string $template;
+
+    public function __construct(bool $isDecoratedOutput, string $template = '%s')
+    {
+        $this->isDecoratedOutput = $isDecoratedOutput;
+        $this->template = $template;
+    }
+
+    public function format(string $diff, string $lineTemplate = '%s'): string
+    {
+        $isDecorated = $this->isDecoratedOutput;
+
+        $template = $isDecorated
+            ? $this->template
+            : Preg::replace('/<[^<>]+>/', '', $this->template);
+
+        return \sprintf(
+            $template,
+            implode(
+                PHP_EOL,
+                array_map(
+                    static function (string $line) use ($isDecorated, $lineTemplate): string {
+                        if ($isDecorated) {
+                            $count = 0;
+                            $line = Preg::replaceCallback(
+                                '/^([+\-@].*)/',
+                                static function (array $matches): string {
+                                    if ('+' === $matches[0][0]) {
+                                        $colour = 'green';
+                                    } elseif ('-' === $matches[0][0]) {
+                                        $colour = 'red';
+                                    } else {
+                                        $colour = 'cyan';
+                                    }
+
+                                    return \sprintf('<fg=%s>%s</fg=%s>', $colour, OutputFormatter::escape($matches[0]), $colour);
+                                },
+                                $line,
+                                1,
+                                $count
+                            );
+
+                            if (0 === $count) {
+                                $line = OutputFormatter::escape($line);
+                            }
+                        }
+
+                        return \sprintf($lineTemplate, $line);
+                    },
+                    Preg::split('#\R#u', $diff)
+                )
+            )
+        );
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Differ/DifferInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Differ;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ */
+interface DifferInterface
+{
+    /**
+     * Create diff.
+     */
+    public function diff(string $old, string $new, ?\SplFileInfo $file = null): string;
+}

package/vendor/friendsofphp/php-cs-fixer/src/Differ/FullDiffer.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Differ;
+
+use SebastianBergmann\Diff\Differ;
+use SebastianBergmann\Diff\Output\StrictUnifiedDiffOutputBuilder;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @readonly
+ *
+ * @internal
+ */
+final class FullDiffer implements DifferInterface
+{
+    private Differ $differ;
+
+    public function __construct()
+    {
+        $this->differ = new Differ(new StrictUnifiedDiffOutputBuilder([
+            'collapseRanges' => false,
+            'commonLineThreshold' => 100,
+            'contextLines' => 100,
+            'fromFile' => 'Original',
+            'toFile' => 'New',
+        ]));
+    }
+
+    public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
+    {
+        return $this->differ->diff($old, $new);
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Differ/NullDiffer.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Differ;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ */
+final class NullDiffer implements DifferInterface
+{
+    public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
+    {
+        return '';
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Differ/UnifiedDiffer.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Differ;
+
+use PhpCsFixer\Preg;
+use SebastianBergmann\Diff\Differ;
+use SebastianBergmann\Diff\Output\StrictUnifiedDiffOutputBuilder;
+
+final class UnifiedDiffer implements DifferInterface
+{
+    public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
+    {
+        if (null === $file) {
+            $options = [
+                'fromFile' => 'Original',
+                'toFile' => 'New',
+            ];
+        } else {
+            $filePath = $file->getRealPath();
+
+            if (Preg::match('/\s/', $filePath)) {
+                $filePath = '"'.$filePath.'"';
+            }
+
+            $options = [
+                'fromFile' => $filePath,
+                'toFile' => $filePath,
+            ];
+        }
+
+        $differ = new Differ(new StrictUnifiedDiffOutputBuilder($options));
+
+        return $differ->diff($old, $new);
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/DocBlock/Annotation.php

@@ -0,0 +1,319 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\DocBlock;
+
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceAnalysis;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceUseAnalysis;
+
+/**
+ * This represents an entire annotation from a docblock.
+ *
+ * @author Graham Campbell <hello@gjcampbell.co.uk>
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ */
+final class Annotation
+{
+    /**
+     * All the annotation tag names with types.
+     *
+     * @var list<string>
+     */
+    private const TAGS = [
+        'method',
+        'param',
+        'property',
+        'property-read',
+        'property-write',
+        'return',
+        'throws',
+        'type',
+        'var',
+    ];
+
+    /**
+     * The lines that make up the annotation.
+     *
+     * @var array<int, Line>
+     */
+    private array $lines;
+
+    /**
+     * The position of the first line of the annotation in the docblock.
+     */
+    private int $start;
+
+    /**
+     * The position of the last line of the annotation in the docblock.
+     */
+    private int $end;
+
+    /**
+     * The associated tag.
+     */
+    private ?Tag $tag = null;
+
+    /**
+     * Lazy loaded, cached types content.
+     */
+    private ?string $typesContent = null;
+
+    /**
+     * The cached types.
+     *
+     * @var null|list<string>
+     */
+    private ?array $types = null;
+
+    private ?NamespaceAnalysis $namespace = null;
+
+    /**
+     * @var list<NamespaceUseAnalysis>
+     */
+    private array $namespaceUses;
+
+    /**
+     * Create a new line instance.
+     *
+     * @param array<int, Line>           $lines
+     * @param null|NamespaceAnalysis     $namespace
+     * @param list<NamespaceUseAnalysis> $namespaceUses
+     */
+    public function __construct(array $lines, $namespace = null, array $namespaceUses = [])
+    {
+        $this->lines = array_values($lines);
+        $this->namespace = $namespace;
+        $this->namespaceUses = $namespaceUses;
+
+        $this->start = array_key_first($lines);
+        $this->end = array_key_last($lines);
+    }
+
+    /**
+     * Get the string representation of object.
+     */
+    public function __toString(): string
+    {
+        return $this->getContent();
+    }
+
+    /**
+     * Get all the annotation tag names with types.
+     *
+     * @return list<string>
+     */
+    public static function getTagsWithTypes(): array
+    {
+        return self::TAGS;
+    }
+
+    /**
+     * Get the start position of this annotation.
+     */
+    public function getStart(): int
+    {
+        return $this->start;
+    }
+
+    /**
+     * Get the end position of this annotation.
+     */
+    public function getEnd(): int
+    {
+        return $this->end;
+    }
+
+    /**
+     * Get the associated tag.
+     */
+    public function getTag(): Tag
+    {
+        if (null === $this->tag) {
+            $this->tag = new Tag($this->lines[0]);
+        }
+
+        return $this->tag;
+    }
+
+    /**
+     * @internal
+     */
+    public function getTypeExpression(): ?TypeExpression
+    {
+        $typesContent = $this->getTypesContent();
+
+        return null === $typesContent
+            ? null
+            : new TypeExpression($typesContent, $this->namespace, $this->namespaceUses);
+    }
+
+    /**
+     * @internal
+     */
+    public function getVariableName(): ?string
+    {
+        $type = preg_quote($this->getTypesContent() ?? '', '/');
+        $regex = \sprintf(
+            '/@%s\s+(%s\s*)?(&\s*)?(\.{3}\s*)?(?<variable>\$%s)(?:.*|$)/',
+            $this->tag->getName(),
+            $type,
+            TypeExpression::REGEX_IDENTIFIER
+        );
+
+        if (Preg::match($regex, $this->lines[0]->getContent(), $matches)) {
+            return $matches['variable'];
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the types associated with this annotation.
+     *
+     * @return list<string>
+     */
+    public function getTypes(): array
+    {
+        if (null === $this->types) {
+            $typeExpression = $this->getTypeExpression();
+            $this->types = null === $typeExpression
+                ? []
+                : $typeExpression->getTypes();
+        }
+
+        return $this->types;
+    }
+
+    /**
+     * Set the types associated with this annotation.
+     *
+     * @param list<string> $types
+     */
+    public function setTypes(array $types): void
+    {
+        $origTypesContent = $this->getTypesContent();
+        $newTypesContent = implode(
+            // Fallback to union type is provided for backward compatibility (previously glue was set to `|` by default even when type was not composite)
+            // @TODO Better handling for cases where type is fixed (original type is not composite, but was made composite during fix)
+            $this->getTypeExpression()->getTypesGlue() ?? '|',
+            $types
+        );
+
+        if ($origTypesContent === $newTypesContent) {
+            return;
+        }
+
+        $pattern = '/'.preg_quote($origTypesContent, '/').'/';
+
+        $this->lines[0]->setContent(Preg::replace($pattern, $newTypesContent, $this->lines[0]->getContent(), 1));
+
+        $this->clearCache();
+    }
+
+    /**
+     * Get the normalized types associated with this annotation, so they can easily be compared.
+     *
+     * @return list<string>
+     */
+    public function getNormalizedTypes(): array
+    {
+        $typeExpression = $this->getTypeExpression();
+        if (null === $typeExpression) {
+            return [];
+        }
+
+        $normalizedTypeExpression = $typeExpression
+            ->mapTypes(static fn (TypeExpression $v) => new TypeExpression(strtolower($v->toString()), null, []))
+            ->sortTypes(static fn (TypeExpression $a, TypeExpression $b) => $a->toString() <=> $b->toString())
+        ;
+
+        return $normalizedTypeExpression->getTypes();
+    }
+
+    /**
+     * Remove this annotation by removing all its lines.
+     */
+    public function remove(): void
+    {
+        foreach ($this->lines as $line) {
+            if ($line->isTheStart() && $line->isTheEnd()) {
+                // Single line doc block, remove entirely
+                $line->remove();
+            } elseif ($line->isTheStart()) {
+                // Multi line doc block, but start is on the same line as the first annotation, keep only the start
+                $content = Preg::replace('#(\s*/\*\*).*#', '$1', $line->getContent());
+
+                $line->setContent($content);
+            } elseif ($line->isTheEnd()) {
+                // Multi line doc block, but end is on the same line as the last annotation, keep only the end
+                $content = Preg::replace('#(\s*)\S.*(\*/.*)#', '$1$2', $line->getContent());
+
+                $line->setContent($content);
+            } else {
+                // Multi line doc block, neither start nor end on this line, can be removed safely
+                $line->remove();
+            }
+        }
+
+        $this->clearCache();
+    }
+
+    /**
+     * Get the annotation content.
+     */
+    public function getContent(): string
+    {
+        return implode('', $this->lines);
+    }
+
+    public function supportTypes(): bool
+    {
+        return \in_array($this->getTag()->getName(), self::TAGS, true);
+    }
+
+    /**
+     * Get the current types content.
+     *
+     * Be careful modifying the underlying line as that won't flush the cache.
+     */
+    private function getTypesContent(): ?string
+    {
+        if (null === $this->typesContent) {
+            $name = $this->getTag()->getName();
+
+            if (!$this->supportTypes()) {
+                throw new \RuntimeException('This tag does not support types.');
+            }
+
+            $matchingResult = Preg::match(
+                '{^(?:\h*\*|/\*\*)[\h*]*@'.$name.'\h+'.TypeExpression::REGEX_TYPES.'(?:(?:[*\h\v]|\&?[\.\$]).*)?\r?$}is',
+                $this->lines[0]->getContent(),
+                $matches
+            );
+
+            $this->typesContent = $matchingResult
+                ? $matches['types']
+                : null;
+        }
+
+        return $this->typesContent;
+    }
+
+    private function clearCache(): void
+    {
+        $this->types = null;
+        $this->typesContent = null;
+    }
+}