@averay/codeformat 0.2.1 → 0.2.2

package/vendor/friendsofphp/php-cs-fixer/src/Linter/TokenizerLintingResult.php

@@ -0,0 +1,48 @@
+<?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\Linter;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @readonly
+ *
+ * @internal
+ */
+final class TokenizerLintingResult implements LintingResultInterface
+{
+    private ?\Error $error;
+
+    public function __construct(?\Error $error = null)
+    {
+        $this->error = $error;
+    }
+
+    public function check(): void
+    {
+        if (null !== $this->error) {
+            throw new LintingException(
+                \sprintf('%s: %s on line %d.', $this->getMessagePrefix(), $this->error->getMessage(), $this->error->getLine()),
+                $this->error->getCode(),
+                $this->error
+            );
+        }
+    }
+
+    private function getMessagePrefix(): string
+    {
+        return $this->error instanceof \ParseError ? 'Parse error' : 'Fatal error';
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/Linter/UnavailableLinterException.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\Linter;
+
+/**
+ * Exception that is thrown when the chosen linter is not available on the environment.
+ *
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @final
+ *
+ * @TODO 4.0 make class "final"
+ */
+class UnavailableLinterException extends \RuntimeException {}

package/vendor/friendsofphp/php-cs-fixer/src/ParallelAwareConfigInterface.php

@@ -0,0 +1,29 @@
+<?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;
+
+use PhpCsFixer\Runner\Parallel\ParallelConfig;
+
+/**
+ * @author Greg Korba <greg@codito.dev>
+ *
+ * @TODO 4.0 Include parallel runner config in main ConfigInterface
+ */
+interface ParallelAwareConfigInterface extends ConfigInterface
+{
+    public function getParallelConfig(): ParallelConfig;
+
+    public function setParallelConfig(ParallelConfig $config): ConfigInterface;
+}

package/vendor/friendsofphp/php-cs-fixer/src/PharChecker.php

@@ -0,0 +1,38 @@
+<?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;
+
+/**
+ * @internal
+ */
+final class PharChecker implements PharCheckerInterface
+{
+    public function checkFileValidity(string $filename): ?string
+    {
+        try {
+            $phar = new \Phar($filename);
+            // free the variable to unlock the file
+            unset($phar);
+        } catch (\Exception $e) {
+            if (!$e instanceof \UnexpectedValueException && !$e instanceof \PharException) {
+                throw $e;
+            }
+
+            return 'Failed to create Phar instance. '.$e->getMessage();
+        }
+
+        return null;
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/PharCheckerInterface.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;
+
+/**
+ * @internal
+ */
+interface PharCheckerInterface
+{
+    /**
+     * @return null|string the invalidity reason if any, null otherwise
+     */
+    public function checkFileValidity(string $filename): ?string;
+}

package/vendor/friendsofphp/php-cs-fixer/src/Preg.php

@@ -0,0 +1,215 @@
+<?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;
+
+/**
+ * This class replaces preg_* functions to better handling UTF8 strings,
+ * ensuring no matter "u" modifier is present or absent subject will be handled correctly.
+ *
+ * @author Kuba Werłos <werlos@gmail.com>
+ *
+ * @internal
+ */
+final class Preg
+{
+    /**
+     * @param array<array-key, mixed>                               $matches
+     * @param int-mask<PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL> $flags
+     *
+     * @param-out ($flags is PREG_OFFSET_CAPTURE
+     *     ? array<array-key, array{string, 0|positive-int}|array{'', -1}>
+     *     : ($flags is PREG_UNMATCHED_AS_NULL
+     *         ? array<array-key, string|null>
+     *         : ($flags is int-mask<PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL>&768
+     *             ? array<array-key, array{string, 0|positive-int}|array{null, -1}>
+     *             : array<array-key, string>
+     *         )
+     *     )
+     * ) $matches
+     *
+     * @throws PregException
+     */
+    public static function match(string $pattern, string $subject, ?array &$matches = null, int $flags = 0, int $offset = 0): bool
+    {
+        $result = @preg_match(self::addUtf8Modifier($pattern), $subject, $matches, $flags, $offset);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return 1 === $result;
+        }
+
+        $result = @preg_match(self::removeUtf8Modifier($pattern), $subject, $matches, $flags, $offset);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return 1 === $result;
+        }
+
+        throw self::newPregException(preg_last_error(), preg_last_error_msg(), __METHOD__, $pattern);
+    }
+
+    /**
+     * @param array<array-key, mixed>                                                                   $matches
+     * @param int-mask<PREG_PATTERN_ORDER, PREG_SET_ORDER, PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL> $flags
+     *
+     * @param-out ($flags is PREG_PATTERN_ORDER
+     *     ? array<list<string>>
+     *     : ($flags is PREG_SET_ORDER
+     *         ? list<array<string>>
+     *         : ($flags is int-mask<PREG_PATTERN_ORDER, PREG_OFFSET_CAPTURE>&(256|257)
+     *             ? array<list<array{string, int}>>
+     *             : ($flags is int-mask<PREG_SET_ORDER, PREG_OFFSET_CAPTURE>&258
+     *                 ? list<array<array{string, int}>>
+     *                 : ($flags is int-mask<PREG_PATTERN_ORDER, PREG_UNMATCHED_AS_NULL>&(512|513)
+     *                     ? array<list<?string>>
+     *                     : ($flags is int-mask<PREG_SET_ORDER, PREG_UNMATCHED_AS_NULL>&514
+     *                         ? list<array<?string>>
+     *                         : ($flags is int-mask<PREG_SET_ORDER, PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL>&770
+     *                             ? list<array<array{?string, int}>>
+     *                             : ($flags is 0 ? array<list<string>> : array<mixed>)
+     *                         )
+     *                     )
+     *                 )
+     *             )
+     *         )
+     *     )
+     * ) $matches
+     *
+     * @throws PregException
+     */
+    public static function matchAll(string $pattern, string $subject, ?array &$matches = null, int $flags = PREG_PATTERN_ORDER, int $offset = 0): int
+    {
+        $result = @preg_match_all(self::addUtf8Modifier($pattern), $subject, $matches, $flags, $offset);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        $result = @preg_match_all(self::removeUtf8Modifier($pattern), $subject, $matches, $flags, $offset);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        throw self::newPregException(preg_last_error(), preg_last_error_msg(), __METHOD__, $pattern);
+    }
+
+    /**
+     * @param-out int $count
+     *
+     * @return ($subject is non-empty-string ? ($replacement is non-empty-string ? non-empty-string : string) : string)
+     *
+     * @throws PregException
+     */
+    public static function replace(string $pattern, string $replacement, string $subject, int $limit = -1, ?int &$count = null): string
+    {
+        $result = @preg_replace(self::addUtf8Modifier($pattern), $replacement, $subject, $limit, $count);
+        if (null !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        $result = @preg_replace(self::removeUtf8Modifier($pattern), $replacement, $subject, $limit, $count);
+        if (null !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        throw self::newPregException(preg_last_error(), preg_last_error_msg(), __METHOD__, $pattern);
+    }
+
+    /**
+     * @param-out int $count
+     *
+     * @throws PregException
+     */
+    public static function replaceCallback(string $pattern, callable $callback, string $subject, int $limit = -1, ?int &$count = null): string
+    {
+        $result = @preg_replace_callback(self::addUtf8Modifier($pattern), $callback, $subject, $limit, $count);
+        if (null !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        $result = @preg_replace_callback(self::removeUtf8Modifier($pattern), $callback, $subject, $limit, $count);
+        if (null !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        throw self::newPregException(preg_last_error(), preg_last_error_msg(), __METHOD__, $pattern);
+    }
+
+    /**
+     * @return list<string>
+     *
+     * @throws PregException
+     */
+    public static function split(string $pattern, string $subject, int $limit = -1, int $flags = 0): array
+    {
+        $result = @preg_split(self::addUtf8Modifier($pattern), $subject, $limit, $flags);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        $result = @preg_split(self::removeUtf8Modifier($pattern), $subject, $limit, $flags);
+        if (false !== $result && PREG_NO_ERROR === preg_last_error()) {
+            return $result;
+        }
+
+        throw self::newPregException(preg_last_error(), preg_last_error_msg(), __METHOD__, $pattern);
+    }
+
+    private static function addUtf8Modifier(string $pattern): string
+    {
+        return $pattern.'u';
+    }
+
+    private static function removeUtf8Modifier(string $pattern): string
+    {
+        if ('' === $pattern) {
+            return '';
+        }
+
+        $delimiter = $pattern[0];
+
+        $endDelimiterPosition = strrpos($pattern, $delimiter);
+
+        return substr($pattern, 0, $endDelimiterPosition).str_replace('u', '', substr($pattern, $endDelimiterPosition));
+    }
+
+    /**
+     * Create the generic PregException message and tell more about such kind of error in the message.
+     */
+    private static function newPregException(int $error, string $errorMsg, string $method, string $pattern): PregException
+    {
+        $result = null;
+        $errorMessage = null;
+
+        try {
+            $result = ExecutorWithoutErrorHandler::execute(static fn () => preg_match($pattern, ''));
+        } catch (ExecutorWithoutErrorHandlerException $e) {
+            $result = false;
+            $errorMessage = $e->getMessage();
+        }
+
+        if (false !== $result) {
+            return new PregException(\sprintf('Unknown error occurred when calling %s: %s.', $method, $errorMsg), $error);
+        }
+
+        $code = preg_last_error();
+
+        $message = \sprintf(
+            '(code: %d) %s',
+            $code,
+            preg_replace('~preg_[a-z_]+[()]{2}: ~', '', $errorMessage)
+        );
+
+        return new PregException(
+            \sprintf('%s(): Invalid PCRE pattern "%s": %s (version: %s)', $method, $pattern, $message, PCRE_VERSION),
+            $code
+        );
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/PregException.php

@@ -0,0 +1,24 @@
+<?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;
+
+/**
+ * Exception that is thrown when PCRE function encounters an error.
+ *
+ * @author Kuba Werłos <werlos@gmail.com>
+ *
+ * @internal
+ */
+final class PregException extends \RuntimeException {}

package/vendor/friendsofphp/php-cs-fixer/src/RuleSet/AbstractMigrationSetDescription.php

@@ -0,0 +1,38 @@
+<?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\RuleSet;
+
+use PhpCsFixer\Preg;
+
+/**
+ * @internal
+ */
+abstract class AbstractMigrationSetDescription extends AbstractRuleSetDescription
+{
+    public function getDescription(): string
+    {
+        $name = $this->getName();
+
+        if (Preg::match('#^@PHPUnit(\d+)(\d)Migration.*$#', $name, $matches)) {
+            return \sprintf('Rules to improve tests code for PHPUnit %d.%d compatibility.', $matches[1], $matches[2]);
+        }
+
+        if (Preg::match('#^@PHP([\d]{2})Migration.*$#', $name, $matches)) {
+            return \sprintf('Rules to improve code for PHP %d.%d compatibility.', $matches[1][0], $matches[1][1]);
+        }
+
+        throw new \RuntimeException(\sprintf('Cannot generate description for "%s" "%s".', static::class, $name));
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/RuleSet/AbstractRuleSetDescription.php

@@ -0,0 +1,35 @@
+<?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\RuleSet;
+
+/**
+ * @internal
+ */
+abstract class AbstractRuleSetDescription implements RuleSetDescriptionInterface
+{
+    public function __construct() {}
+
+    public function getName(): string
+    {
+        $name = substr(static::class, 1 + strrpos(static::class, '\\'), -3);
+
+        return '@'.str_replace('Risky', ':risky', $name);
+    }
+
+    public function isRisky(): bool
+    {
+        return str_contains(static::class, 'Risky');
+    }
+}

package/vendor/friendsofphp/php-cs-fixer/src/RuleSet/DeprecatedRuleSetDescriptionInterface.php

@@ -0,0 +1,28 @@
+<?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\RuleSet;
+
+/**
+ * @author Greg Korba <greg@codito.dev>
+ */
+interface DeprecatedRuleSetDescriptionInterface extends RuleSetDescriptionInterface
+{
+    /**
+     * Returns names of rule sets to use instead, if any.
+     *
+     * @return list<string>
+     */
+    public function getSuccessorsNames(): array;
+}

package/vendor/friendsofphp/php-cs-fixer/src/RuleSet/RuleSet.php

@@ -0,0 +1,159 @@
+<?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\RuleSet;
+
+use PhpCsFixer\ConfigurationException\InvalidFixerConfigurationException;
+use PhpCsFixer\Utils;
+
+/**
+ * Set of rules to be used by fixer.
+ *
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @readonly
+ *
+ * @internal
+ */
+final class RuleSet implements RuleSetInterface
+{
+    /**
+     * Group of rules generated from input set.
+     *
+     * The key is name of rule, value is configuration array or true.
+     * The key must not point to any set.
+     *
+     * @var array<string, array<string, mixed>|true>
+     */
+    private array $rules;
+
+    public function __construct(array $set = [])
+    {
+        foreach ($set as $name => $value) {
+            if ('' === $name) {
+                throw new \InvalidArgumentException('Rule/set name must not be empty.');
+            }
+
+            if (\is_int($name)) {
+                throw new \InvalidArgumentException(\sprintf('Missing value for "%s" rule/set.', $value));
+            }
+
+            if (!\is_bool($value) && !\is_array($value)) {
+                $message = str_starts_with($name, '@') ? 'Set must be enabled (true) or disabled (false). Other values are not allowed.' : 'Rule must be enabled (true), disabled (false) or configured (non-empty, assoc array). Other values are not allowed.';
+
+                if (null === $value) {
+                    $message .= ' To disable the '.(str_starts_with($name, '@') ? 'set' : 'rule').', use "FALSE" instead of "NULL".';
+                }
+
+                throw new InvalidFixerConfigurationException($name, $message);
+            }
+        }
+
+        $this->rules = $this->resolveSet($set);
+    }
+
+    public function hasRule(string $rule): bool
+    {
+        return \array_key_exists($rule, $this->rules);
+    }
+
+    public function getRuleConfiguration(string $rule): ?array
+    {
+        if (!$this->hasRule($rule)) {
+            throw new \InvalidArgumentException(\sprintf('Rule "%s" is not in the set.', $rule));
+        }
+
+        if (true === $this->rules[$rule]) {
+            return null;
+        }
+
+        return $this->rules[$rule];
+    }
+
+    public function getRules(): array
+    {
+        return $this->rules;
+    }
+
+    /**
+     * Resolve input set into group of rules.
+     *
+     * @param array<string, array<string, mixed>|bool> $rules
+     *
+     * @return array<string, array<string, mixed>|true>
+     */
+    private function resolveSet(array $rules): array
+    {
+        $resolvedRules = [];
+
+        // expand sets
+        foreach ($rules as $name => $value) {
+            if (str_starts_with($name, '@')) {
+                if (!\is_bool($value)) {
+                    throw new \UnexpectedValueException(\sprintf('Nested rule set "%s" configuration must be a boolean.', $name));
+                }
+
+                $set = $this->resolveSubset($name, $value);
+                $resolvedRules = array_merge($resolvedRules, $set);
+            } else {
+                $resolvedRules[$name] = $value;
+            }
+        }
+
+        // filter out all resolvedRules that are off
+        $resolvedRules = array_filter(
+            $resolvedRules,
+            static fn ($value): bool => false !== $value
+        );
+
+        return $resolvedRules;
+    }
+
+    /**
+     * Resolve set rules as part of another set.
+     *
+     * If set value is false then disable all fixers in set,
+     * if not then get value from set item.
+     *
+     * @return array<string, array<string, mixed>|bool>
+     */
+    private function resolveSubset(string $setName, bool $setValue): array
+    {
+        $ruleSet = RuleSets::getSetDefinition($setName);
+
+        if ($ruleSet instanceof DeprecatedRuleSetDescriptionInterface) {
+            $messageEnd = [] === $ruleSet->getSuccessorsNames()
+                ? 'No replacement available'
+                : \sprintf('Use %s instead', Utils::naturalLanguageJoin($ruleSet->getSuccessorsNames()));
+
+            Utils::triggerDeprecation(new \RuntimeException("Rule set \"{$setName}\" is deprecated. {$messageEnd}."));
+        }
+
+        $rules = $ruleSet->getRules();
+
+        foreach ($rules as $name => $value) {
+            if (str_starts_with($name, '@')) {
+                $set = $this->resolveSubset($name, $setValue);
+                unset($rules[$name]);
+                $rules = array_merge($rules, $set);
+            } elseif (!$setValue) {
+                $rules[$name] = false;
+            } else {
+                $rules[$name] = $value;
+            }
+        }
+
+        return $rules;
+    }
+}