@averay/codeformat 0.2.0 → 0.2.2

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/OctalNotationFixer.php

@@ -0,0 +1,64 @@
+<?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\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\FixerDefinition\VersionSpecification;
+use PhpCsFixer\FixerDefinition\VersionSpecificCodeSample;
+use PhpCsFixer\Preg;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class OctalNotationFixer extends AbstractFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Literal octal must be in `0o` notation.',
+            [
+                new VersionSpecificCodeSample(
+                    "<?php \$foo = 0123;\n",
+                    new VersionSpecification(8_01_00)
+                ),
+            ]
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return \PHP_VERSION_ID >= 8_01_00 && $tokens->isTokenKindFound(T_LNUMBER);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        foreach ($tokens as $index => $token) {
+            if (!$token->isGivenKind(T_LNUMBER)) {
+                continue;
+            }
+
+            $content = $token->getContent();
+
+            $newContent = Preg::replace('#^0_*+([0-7_]+)$#', '0o$1', $content);
+
+            if ($content === $newContent) {
+                continue;
+            }
+
+            $tokens[$index] = new Token([T_LNUMBER, $newContent]);
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/PsrAutoloadingFixer.php

@@ -0,0 +1,291 @@
+<?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\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\DocBlock\TypeExpression;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurableFixerTrait;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\FileSpecificCodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Preg;
+use PhpCsFixer\StdinFileInfo;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ * @author Bram Gotink <bram@gotink.me>
+ * @author Graham Campbell <hello@gjcampbell.co.uk>
+ * @author Kuba Werłos <werlos@gmail.com>
+ *
+ * @implements ConfigurableFixerInterface<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration>
+ *
+ * @phpstan-type _AutogeneratedInputConfiguration array{
+ *  dir?: null|string,
+ * }
+ * @phpstan-type _AutogeneratedComputedConfiguration array{
+ *  dir: null|string,
+ * }
+ */
+final class PsrAutoloadingFixer extends AbstractFixer implements ConfigurableFixerInterface
+{
+    /** @use ConfigurableFixerTrait<_AutogeneratedInputConfiguration, _AutogeneratedComputedConfiguration> */
+    use ConfigurableFixerTrait;
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Classes must be in a path that matches their namespace, be at least one namespace deep and the class name should match the file name.',
+            [
+                new FileSpecificCodeSample(
+                    '<?php
+namespace PhpCsFixer\FIXER\Basic;
+class InvalidName {}
+',
+                    new \SplFileInfo(__FILE__)
+                ),
+                new FileSpecificCodeSample(
+                    '<?php
+namespace PhpCsFixer\FIXER\Basic;
+class InvalidName {}
+',
+                    new \SplFileInfo(__FILE__),
+                    ['dir' => './src']
+                ),
+            ],
+            null,
+            'This fixer may change your class name, which will break the code that depends on the old name.'
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAnyTokenKindsFound(Token::getClassyTokenKinds());
+    }
+
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before SelfAccessorFixer.
+     */
+    public function getPriority(): int
+    {
+        return -10;
+    }
+
+    public function supports(\SplFileInfo $file): bool
+    {
+        if ($file instanceof StdinFileInfo) {
+            return false;
+        }
+
+        if (
+            // ignore file with extension other than php
+            ('php' !== $file->getExtension())
+            // ignore file with name that cannot be a class name
+            || !Preg::match('/^'.TypeExpression::REGEX_IDENTIFIER.'$/', $file->getBasename('.php'))
+        ) {
+            return false;
+        }
+
+        try {
+            $tokens = Tokens::fromCode(\sprintf('<?php class %s {}', $file->getBasename('.php')));
+
+            if ($tokens[3]->isKeyword() || $tokens[3]->isMagicConstant()) {
+                // name cannot be a class name - detected by PHP 5.x
+                return false;
+            }
+        } catch (\ParseError $e) {
+            // name cannot be a class name - detected by PHP 7.x
+            return false;
+        }
+
+        // ignore stubs/fixtures, since they typically contain invalid files for various reasons
+        return !Preg::match('{[/\\\](stub|fixture)s?[/\\\]}i', $file->getRealPath());
+    }
+
+    protected function configurePostNormalisation(): void
+    {
+        if (null !== $this->configuration['dir']) {
+            $realpath = realpath($this->configuration['dir']);
+
+            if (false === $realpath) {
+                throw new \InvalidArgumentException(\sprintf('Failed to resolve configured directory "%s".', $this->configuration['dir']));
+            }
+
+            $this->configuration['dir'] = $realpath;
+        }
+    }
+
+    protected function createConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('dir', 'If provided, the directory where the project code is placed.'))
+                ->setAllowedTypes(['null', 'string'])
+                ->setDefault(null)
+                ->getOption(),
+        ]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $tokenAnalyzer = new TokensAnalyzer($tokens);
+
+        if (null !== $this->configuration['dir'] && !str_starts_with($file->getRealPath(), $this->configuration['dir'])) {
+            return;
+        }
+
+        $namespace = null;
+        $namespaceStartIndex = null;
+        $namespaceEndIndex = null;
+
+        $classyName = null;
+        $classyIndex = null;
+
+        foreach ($tokens as $index => $token) {
+            if ($token->isGivenKind(T_NAMESPACE)) {
+                if (null !== $namespace) {
+                    return;
+                }
+
+                $namespaceStartIndex = $tokens->getNextMeaningfulToken($index);
+                $namespaceEndIndex = $tokens->getNextTokenOfKind($namespaceStartIndex, [';']);
+                $namespace = trim($tokens->generatePartialCode($namespaceStartIndex, $namespaceEndIndex - 1));
+            } elseif ($token->isClassy()) {
+                if ($tokenAnalyzer->isAnonymousClass($index)) {
+                    continue;
+                }
+
+                if (null !== $classyName) {
+                    return;
+                }
+
+                $classyIndex = $tokens->getNextMeaningfulToken($index);
+                $classyName = $tokens[$classyIndex]->getContent();
+            }
+        }
+
+        if (null === $classyName) {
+            return;
+        }
+
+        $expectedClassyName = $this->calculateClassyName($file, $namespace, $classyName);
+
+        if ($classyName !== $expectedClassyName) {
+            $tokens[$classyIndex] = new Token([T_STRING, $expectedClassyName]);
+        }
+
+        if (null === $this->configuration['dir'] || null === $namespace) {
+            return;
+        }
+
+        if (!is_dir($this->configuration['dir'])) {
+            return;
+        }
+
+        $configuredDir = realpath($this->configuration['dir']);
+        $fileDir = \dirname($file->getRealPath());
+
+        if (\strlen($configuredDir) >= \strlen($fileDir)) {
+            return;
+        }
+
+        $newNamespace = substr(str_replace('/', '\\', $fileDir), \strlen($configuredDir) + 1);
+        $originalNamespace = substr($namespace, -\strlen($newNamespace));
+
+        if ($originalNamespace !== $newNamespace && strtolower($originalNamespace) === strtolower($newNamespace)) {
+            $tokens->clearRange($namespaceStartIndex, $namespaceEndIndex);
+            $namespace = substr($namespace, 0, -\strlen($newNamespace)).$newNamespace;
+
+            $newNamespace = Tokens::fromCode('<?php namespace '.$namespace.';');
+            $newNamespace->clearRange(0, 2);
+            $newNamespace->clearEmptyTokens();
+
+            $tokens->insertAt($namespaceStartIndex, $newNamespace);
+        }
+    }
+
+    private function calculateClassyName(\SplFileInfo $file, ?string $namespace, string $currentName): string
+    {
+        $name = $file->getBasename('.php');
+        $maxNamespace = $this->calculateMaxNamespace($file, $namespace);
+
+        if (null !== $this->configuration['dir']) {
+            return ('' !== $maxNamespace ? (str_replace('\\', '_', $maxNamespace).'_') : '').$name;
+        }
+
+        $namespaceParts = array_reverse(explode('\\', $maxNamespace));
+
+        foreach ($namespaceParts as $namespacePart) {
+            $nameCandidate = \sprintf('%s_%s', $namespacePart, $name);
+
+            if (strtolower($nameCandidate) !== strtolower(substr($currentName, -\strlen($nameCandidate)))) {
+                break;
+            }
+
+            $name = $nameCandidate;
+        }
+
+        return $name;
+    }
+
+    private function calculateMaxNamespace(\SplFileInfo $file, ?string $namespace): string
+    {
+        if (null === $this->configuration['dir']) {
+            $root = \dirname($file->getRealPath());
+
+            while ($root !== \dirname($root)) {
+                $root = \dirname($root);
+            }
+        } else {
+            $root = realpath($this->configuration['dir']);
+        }
+
+        $namespaceAccordingToFileLocation = trim(str_replace(\DIRECTORY_SEPARATOR, '\\', substr(\dirname($file->getRealPath()), \strlen($root))), '\\');
+
+        if (null === $namespace) {
+            return $namespaceAccordingToFileLocation;
+        }
+
+        $namespaceAccordingToFileLocationPartsReversed = array_reverse(explode('\\', $namespaceAccordingToFileLocation));
+        $namespacePartsReversed = array_reverse(explode('\\', $namespace));
+
+        foreach ($namespacePartsReversed as $key => $namespaceParte) {
+            if (!isset($namespaceAccordingToFileLocationPartsReversed[$key])) {
+                break;
+            }
+
+            if (strtolower($namespaceParte) !== strtolower($namespaceAccordingToFileLocationPartsReversed[$key])) {
+                break;
+            }
+
+            unset($namespaceAccordingToFileLocationPartsReversed[$key]);
+        }
+
+        return implode('\\', array_reverse($namespaceAccordingToFileLocationPartsReversed));
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Basic/SingleLineEmptyBodyFixer.php

@@ -0,0 +1,83 @@
+<?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\Fixer\Basic;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class SingleLineEmptyBodyFixer extends AbstractFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Empty body of class, interface, trait, enum or function must be abbreviated as `{}` and placed on the same line as the previous symbol, separated by a single space.',
+            [new CodeSample('<?php function foo(
+    int $x
+)
+{
+}
+')],
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after BracesPositionFixer, ClassDefinitionFixer, CurlyBracesPositionFixer, NoUselessReturnFixer.
+     */
+    public function getPriority(): int
+    {
+        return -19;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        if (\defined('T_ENUM') && $tokens->isTokenKindFound(T_ENUM)) { // @TODO: drop condition when PHP 8.1+ is required
+            return true;
+        }
+
+        return $tokens->isAnyTokenKindsFound([T_INTERFACE, T_CLASS, T_FUNCTION, T_TRAIT]);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        for ($index = $tokens->count() - 1; $index > 0; --$index) {
+            if (!$tokens[$index]->isGivenKind([...Token::getClassyTokenKinds(), T_FUNCTION])) {
+                continue;
+            }
+
+            $openBraceIndex = $tokens->getNextTokenOfKind($index, ['{', ';']);
+            if (!$tokens[$openBraceIndex]->equals('{')) {
+                continue;
+            }
+
+            $closeBraceIndex = $tokens->getNextNonWhitespace($openBraceIndex);
+            if (!$tokens[$closeBraceIndex]->equals('}')) {
+                continue;
+            }
+
+            $tokens->ensureWhitespaceAtIndex($openBraceIndex + 1, 0, '');
+
+            $beforeOpenBraceIndex = $tokens->getPrevNonWhitespace($openBraceIndex);
+            if (!$tokens[$beforeOpenBraceIndex]->isGivenKind([T_COMMENT, T_DOC_COMMENT])) {
+                $tokens->ensureWhitespaceAtIndex($openBraceIndex - 1, 1, ' ');
+            }
+        }
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Fixer/Casing/ClassReferenceNameCasingFixer.php

@@ -0,0 +1,168 @@
+<?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\Fixer\Casing;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceAnalysis;
+use PhpCsFixer\Tokenizer\Analyzer\NamespaceUsesAnalyzer;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class ClassReferenceNameCasingFixer extends AbstractFixer
+{
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'When referencing an internal class it must be written using the correct casing.',
+            [
+                new CodeSample("<?php\nthrow new \\exception();\n"),
+            ]
+        );
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isTokenKindFound(T_STRING);
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        $namespaceUsesAnalyzer = new NamespaceUsesAnalyzer();
+        $classNames = $this->getClassNames();
+
+        foreach ($tokens->getNamespaceDeclarations() as $namespace) {
+            $uses = [];
+
+            foreach ($namespaceUsesAnalyzer->getDeclarationsInNamespace($tokens, $namespace) as $use) {
+                $uses[strtolower($use->getShortName())] = true;
+            }
+
+            foreach ($this->getClassReference($tokens, $namespace) as $reference) {
+                $currentContent = $tokens[$reference]->getContent();
+                $lowerCurrentContent = strtolower($currentContent);
+
+                if (isset($classNames[$lowerCurrentContent]) && $currentContent !== $classNames[$lowerCurrentContent] && !isset($uses[$lowerCurrentContent])) {
+                    $tokens[$reference] = new Token([T_STRING, $classNames[$lowerCurrentContent]]);
+                }
+            }
+        }
+    }
+
+    private function getClassReference(Tokens $tokens, NamespaceAnalysis $namespace): \Generator
+    {
+        static $notBeforeKinds;
+        static $blockKinds;
+
+        if (null === $notBeforeKinds) {
+            $notBeforeKinds = [
+                CT::T_USE_TRAIT,
+                T_AS,
+                T_CASE, // PHP 8.1 trait enum-case
+                T_CLASS,
+                T_CONST,
+                T_DOUBLE_ARROW,
+                T_DOUBLE_COLON,
+                T_FUNCTION,
+                T_INTERFACE,
+                T_OBJECT_OPERATOR,
+                T_TRAIT,
+            ];
+
+            if (\defined('T_NULLSAFE_OBJECT_OPERATOR')) {  // @TODO: drop condition when PHP 8.0+ is required
+                $notBeforeKinds[] = T_NULLSAFE_OBJECT_OPERATOR;
+            }
+
+            if (\defined('T_ENUM')) { // @TODO: drop condition when PHP 8.1+ is required
+                $notBeforeKinds[] = T_ENUM;
+            }
+        }
+
+        if (null === $blockKinds) {
+            $blockKinds = ['before' => [','], 'after' => [',']];
+
+            foreach (Tokens::getBlockEdgeDefinitions() as $definition) {
+                $blockKinds['before'][] = $definition['start'];
+                $blockKinds['after'][] = $definition['end'];
+            }
+        }
+
+        $namespaceIsGlobal = $namespace->isGlobalNamespace();
+
+        for ($index = $namespace->getScopeStartIndex(); $index < $namespace->getScopeEndIndex(); ++$index) {
+            if (!$tokens[$index]->isGivenKind(T_STRING)) {
+                continue;
+            }
+
+            $nextIndex = $tokens->getNextMeaningfulToken($index);
+
+            if ($tokens[$nextIndex]->isGivenKind(T_NS_SEPARATOR)) {
+                continue;
+            }
+
+            $prevIndex = $tokens->getPrevMeaningfulToken($index);
+            $nextIndex = $tokens->getNextMeaningfulToken($index);
+
+            $isNamespaceSeparator = $tokens[$prevIndex]->isGivenKind(T_NS_SEPARATOR);
+
+            if (!$isNamespaceSeparator && !$namespaceIsGlobal) {
+                continue;
+            }
+
+            if ($isNamespaceSeparator) {
+                $prevIndex = $tokens->getPrevMeaningfulToken($prevIndex);
+
+                if ($tokens[$prevIndex]->isGivenKind(T_STRING)) {
+                    continue;
+                }
+            } elseif ($tokens[$prevIndex]->isGivenKind($notBeforeKinds)) {
+                continue;
+            }
+
+            if ($tokens[$prevIndex]->equalsAny($blockKinds['before']) && $tokens[$nextIndex]->equalsAny($blockKinds['after'])) {
+                continue;
+            }
+
+            if (!$tokens[$prevIndex]->isGivenKind(T_NEW) && $tokens[$nextIndex]->equalsAny(['(', ';', [T_CLOSE_TAG]])) {
+                continue;
+            }
+
+            yield $index;
+        }
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    private function getClassNames(): array
+    {
+        static $classes = null;
+
+        if (null === $classes) {
+            $classes = [];
+
+            foreach (get_declared_classes() as $class) {
+                if ((new \ReflectionClass($class))->isInternal()) {
+                    $classes[strtolower($class)] = $class;
+                }
+            }
+        }
+
+        return $classes;
+    }
+}