dependabot-composer 0.118.13 → 0.119.0.beta1

data/helpers/vendor/friendsofphp/php-cs-fixer/src/Fixer/LanguageConstruct/IsNullFixer.php

@@ -0,0 +1,203 @@
+<?php
+
+/*
+ * 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\LanguageConstruct;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\Tokenizer\Analyzer\FunctionsAnalyzer;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Vladimir Reznichenko <kalessil@gmail.com>
+ */
+final class IsNullFixer extends AbstractFixer implements ConfigurationDefinitionFixerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefinition()
+    {
+        return new FixerDefinition(
+            'Replaces `is_null($var)` expression with `null === $var`.',
+            [
+                new CodeSample("<?php\n\$a = is_null(\$b);\n"),
+            ],
+            null,
+            'Risky when the function `is_null` is overridden.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before YodaStyleFixer.
+     */
+    public function getPriority()
+    {
+        return 1;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isCandidate(Tokens $tokens)
+    {
+        return $tokens->isTokenKindFound(T_STRING);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isRisky()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens)
+    {
+        static $sequenceNeeded = [[T_STRING, 'is_null'], '('];
+        $functionsAnalyzer = new FunctionsAnalyzer();
+
+        $currIndex = 0;
+        while (null !== $currIndex) {
+            $matches = $tokens->findSequence($sequenceNeeded, $currIndex, $tokens->count() - 1, false);
+
+            // stop looping if didn't find any new matches
+            if (null === $matches) {
+                break;
+            }
+
+            // 0 and 1 accordingly are "is_null", "(" tokens
+            $matches = array_keys($matches);
+
+            // move the cursor just after the sequence
+            list($isNullIndex, $currIndex) = $matches;
+
+            if (!$functionsAnalyzer->isGlobalFunctionCall($tokens, $matches[0])) {
+                continue;
+            }
+
+            $next = $tokens->getNextMeaningfulToken($currIndex);
+            if ($tokens[$next]->equals(')')) {
+                continue;
+            }
+
+            $prevTokenIndex = $tokens->getPrevMeaningfulToken($matches[0]);
+
+            // handle function references with namespaces
+            if ($tokens[$prevTokenIndex]->isGivenKind(T_NS_SEPARATOR)) {
+                $tokens->removeTrailingWhitespace($prevTokenIndex);
+                $tokens->clearAt($prevTokenIndex);
+
+                $prevTokenIndex = $tokens->getPrevMeaningfulToken($prevTokenIndex);
+            }
+
+            // check if inversion being used, text comparison is due to not existing constant
+            $isInvertedNullCheck = false;
+            if ($tokens[$prevTokenIndex]->equals('!')) {
+                $isInvertedNullCheck = true;
+
+                // get rid of inverting for proper transformations
+                $tokens->removeTrailingWhitespace($prevTokenIndex);
+                $tokens->clearAt($prevTokenIndex);
+            }
+
+            // before getting rind of `()` around a parameter, ensure it's not assignment/ternary invariant
+            $referenceEnd = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $matches[1]);
+            $isContainingDangerousConstructs = false;
+            for ($paramTokenIndex = $matches[1]; $paramTokenIndex <= $referenceEnd; ++$paramTokenIndex) {
+                if (\in_array($tokens[$paramTokenIndex]->getContent(), ['?', '?:', '=', '??'], true)) {
+                    $isContainingDangerousConstructs = true;
+
+                    break;
+                }
+            }
+
+            // edge cases: is_null() followed/preceded by ==, ===, !=, !==, <>
+            $parentLeftToken = $tokens[$tokens->getPrevMeaningfulToken($isNullIndex)];
+            $parentRightToken = $tokens[$tokens->getNextMeaningfulToken($referenceEnd)];
+            $parentOperations = [T_IS_EQUAL, T_IS_NOT_EQUAL, T_IS_IDENTICAL, T_IS_NOT_IDENTICAL];
+            $wrapIntoParentheses = $parentLeftToken->isGivenKind($parentOperations) || $parentRightToken->isGivenKind($parentOperations);
+
+            // possible trailing comma removed
+            $prevIndex = $tokens->getPrevMeaningfulToken($referenceEnd);
+            if ($tokens[$prevIndex]->equals(',')) {
+                $tokens->clearTokenAndMergeSurroundingWhitespace($prevIndex);
+            }
+
+            if (!$isContainingDangerousConstructs) {
+                // closing parenthesis removed with leading spaces
+                $tokens->removeLeadingWhitespace($referenceEnd);
+                $tokens->clearAt($referenceEnd);
+
+                // opening parenthesis removed with trailing spaces
+                $tokens->removeLeadingWhitespace($matches[1]);
+                $tokens->removeTrailingWhitespace($matches[1]);
+                $tokens->clearAt($matches[1]);
+            }
+
+            // sequence which we'll use as a replacement
+            $replacement = [
+                new Token([T_STRING, 'null']),
+                new Token([T_WHITESPACE, ' ']),
+                new Token($isInvertedNullCheck ? [T_IS_NOT_IDENTICAL, '!=='] : [T_IS_IDENTICAL, '===']),
+                new Token([T_WHITESPACE, ' ']),
+            ];
+
+            if (true === $this->configuration['use_yoda_style']) {
+                if ($wrapIntoParentheses) {
+                    array_unshift($replacement, new Token('('));
+                    $tokens->insertAt($referenceEnd + 1, new Token(')'));
+                }
+
+                $tokens->overrideRange($isNullIndex, $isNullIndex, $replacement);
+            } else {
+                $replacement = array_reverse($replacement);
+                if ($wrapIntoParentheses) {
+                    $replacement[] = new Token(')');
+                    $tokens[$isNullIndex] = new Token('(');
+                } else {
+                    $tokens->clearAt($isNullIndex);
+                }
+
+                $tokens->insertAt($referenceEnd + 1, $replacement);
+            }
+
+            // nested is_null calls support
+            $currIndex = $isNullIndex;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function createConfigurationDefinition()
+    {
+        // @todo 3.0 drop `ConfigurationDefinitionFixerInterface`
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('use_yoda_style', 'Whether Yoda style conditions should be used.'))
+                ->setAllowedTypes(['bool'])
+                ->setDefault(true)
+                ->setDeprecationMessage('Use `yoda_style` fixer instead.')
+                ->getOption(),
+        ]);
+    }
+}

data/helpers/vendor/friendsofphp/php-cs-fixer/src/Fixer/LanguageConstruct/NoUnsetOnPropertyFixer.php

@@ -0,0 +1,231 @@
+<?php
+
+/*
+ * 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\LanguageConstruct;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\Tokenizer\Analyzer\ArgumentsAnalyzer;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Gert de Pagter <BackEndTea@gmail.com>
+ */
+final class NoUnsetOnPropertyFixer extends AbstractFixer
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefinition()
+    {
+        return new FixerDefinition(
+            'Properties should be set to `null` instead of using `unset`.',
+            [new CodeSample("<?php\nunset(\$this->a);\n")],
+            null,
+            'Changing variables to `null` instead of unsetting them will mean they still show up '.
+            'when looping over class variables. With PHP 7.4, this rule might introduce `null` assignments to '.
+            'property whose type declaration does not allow it.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isRisky()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isCandidate(Tokens $tokens)
+    {
+        return $tokens->isTokenKindFound(T_UNSET)
+            && $tokens->isAnyTokenKindsFound([T_OBJECT_OPERATOR, T_PAAMAYIM_NEKUDOTAYIM]);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run before CombineConsecutiveUnsetsFixer.
+     */
+    public function getPriority()
+    {
+        return 25;
+    }
+
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens)
+    {
+        for ($index = $tokens->count() - 1; $index >= 0; --$index) {
+            if (!$tokens[$index]->isGivenKind(T_UNSET)) {
+                continue;
+            }
+
+            $unsetsInfo = $this->getUnsetsInfo($tokens, $index);
+
+            if (!$this->isAnyUnsetToTransform($unsetsInfo)) {
+                continue;
+            }
+
+            $isLastUnset = true; // yes, last - we reverse the array below
+            foreach (array_reverse($unsetsInfo) as $unsetInfo) {
+                $this->updateTokens($tokens, $unsetInfo, $isLastUnset);
+                $isLastUnset = false;
+            }
+        }
+    }
+
+    /**
+     * @param int $index
+     *
+     * @return array<array<string, bool|int>>
+     */
+    private function getUnsetsInfo(Tokens $tokens, $index)
+    {
+        $argumentsAnalyzer = new ArgumentsAnalyzer();
+
+        $unsetStart = $tokens->getNextTokenOfKind($index, ['(']);
+        $unsetEnd = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_PARENTHESIS_BRACE, $unsetStart);
+        $isFirst = true;
+
+        $unsets = [];
+        foreach ($argumentsAnalyzer->getArguments($tokens, $unsetStart, $unsetEnd) as $startIndex => $endIndex) {
+            $startIndex = $tokens->getNextMeaningfulToken($startIndex - 1);
+            $endIndex = $tokens->getPrevMeaningfulToken($endIndex + 1);
+            $unsets[] = [
+                'startIndex' => $startIndex,
+                'endIndex' => $endIndex,
+                'isToTransform' => $this->isProperty($tokens, $startIndex, $endIndex),
+                'isFirst' => $isFirst,
+            ];
+            $isFirst = false;
+        }
+
+        return $unsets;
+    }
+
+    /**
+     * @param int $index
+     * @param int $endIndex
+     *
+     * @return bool
+     */
+    private function isProperty(Tokens $tokens, $index, $endIndex)
+    {
+        if ($tokens[$index]->isGivenKind(T_VARIABLE)) {
+            $nextIndex = $tokens->getNextMeaningfulToken($index);
+            if (null === $nextIndex || !$tokens[$nextIndex]->isGivenKind(T_OBJECT_OPERATOR)) {
+                return false;
+            }
+            $nextIndex = $tokens->getNextMeaningfulToken($nextIndex);
+            $nextNextIndex = $tokens->getNextMeaningfulToken($nextIndex);
+            if (null !== $nextNextIndex && $nextNextIndex < $endIndex) {
+                return false;
+            }
+
+            return null !== $nextIndex && $tokens[$nextIndex]->isGivenKind(T_STRING);
+        }
+
+        if ($tokens[$index]->isGivenKind([T_NS_SEPARATOR, T_STRING])) {
+            $nextIndex = $tokens->getTokenNotOfKindSibling($index, 1, [[T_DOUBLE_COLON], [T_NS_SEPARATOR], [T_STRING]]);
+            $nextNextIndex = $tokens->getNextMeaningfulToken($nextIndex);
+            if (null !== $nextNextIndex && $nextNextIndex < $endIndex) {
+                return false;
+            }
+
+            return null !== $nextIndex && $tokens[$nextIndex]->isGivenKind(T_VARIABLE);
+        }
+
+        return false;
+    }
+
+    /**
+     * @param array<array<string, bool|int>> $unsetsInfo
+     *
+     * @return bool
+     */
+    private function isAnyUnsetToTransform(array $unsetsInfo)
+    {
+        foreach ($unsetsInfo as $unsetInfo) {
+            if ($unsetInfo['isToTransform']) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param array<string, bool|int> $unsetInfo
+     * @param bool                    $isLastUnset
+     */
+    private function updateTokens(Tokens $tokens, array $unsetInfo, $isLastUnset)
+    {
+        // if entry is first and to be transform we remove leading "unset("
+        if ($unsetInfo['isFirst'] && $unsetInfo['isToTransform']) {
+            $braceIndex = $tokens->getPrevTokenOfKind($unsetInfo['startIndex'], ['(']);
+            $unsetIndex = $tokens->getPrevTokenOfKind($braceIndex, [[T_UNSET]]);
+            $tokens->clearTokenAndMergeSurroundingWhitespace($braceIndex);
+            $tokens->clearTokenAndMergeSurroundingWhitespace($unsetIndex);
+        }
+
+        // if entry is last and to be transformed we remove trailing ")"
+        if ($isLastUnset && $unsetInfo['isToTransform']) {
+            $braceIndex = $tokens->getNextTokenOfKind($unsetInfo['endIndex'], [')']);
+            $previousIndex = $tokens->getPrevMeaningfulToken($braceIndex);
+            if ($tokens[$previousIndex]->equals(',')) {
+                $tokens->clearTokenAndMergeSurroundingWhitespace($previousIndex); // trailing ',' in function call (PHP 7.3)
+            }
+
+            $tokens->clearTokenAndMergeSurroundingWhitespace($braceIndex);
+        }
+
+        // if entry is not last we replace comma with semicolon (last entry already has semicolon - from original unset)
+        if (!$isLastUnset) {
+            $commaIndex = $tokens->getNextTokenOfKind($unsetInfo['endIndex'], [',']);
+            $tokens[$commaIndex] = new Token(';');
+        }
+
+        // if entry is to be unset and is not last we add trailing ")"
+        if (!$unsetInfo['isToTransform'] && !$isLastUnset) {
+            $tokens->insertAt($unsetInfo['endIndex'] + 1, new Token(')'));
+        }
+
+        // if entry is to be unset and is not first we add leading "unset("
+        if (!$unsetInfo['isToTransform'] && !$unsetInfo['isFirst']) {
+            $tokens->insertAt(
+                $unsetInfo['startIndex'],
+                [
+                    new Token([T_UNSET, 'unset']),
+                    new Token('('),
+                ]
+            );
+        }
+
+        // and finally
+        // if entry is to be transformed we add trailing " = null"
+        if ($unsetInfo['isToTransform']) {
+            $tokens->insertAt(
+                $unsetInfo['endIndex'] + 1,
+                [
+                    new Token([T_WHITESPACE, ' ']),
+                    new Token('='),
+                    new Token([T_WHITESPACE, ' ']),
+                    new Token([T_STRING, 'null']),
+                ]
+            );
+        }
+    }
+}

data/helpers/vendor/friendsofphp/php-cs-fixer/src/Fixer/LanguageConstruct/SilencedDeprecationErrorFixer.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * 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\LanguageConstruct;
+
+use PhpCsFixer\AbstractProxyFixer;
+use PhpCsFixer\Fixer\DeprecatedFixerInterface;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+
+/**
+ * @author Jules Pietri <jules@heahprod.com>
+ *
+ * @deprecated
+ */
+final class SilencedDeprecationErrorFixer extends AbstractProxyFixer implements DeprecatedFixerInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefinition()
+    {
+        return new FixerDefinition(
+            'Ensures deprecation notices are silenced.',
+            [new CodeSample("<?php\ntrigger_error('Warning.', E_USER_DEPRECATED);\n")],
+            null,
+            'Silencing of deprecation errors might cause changes to code behaviour.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSuccessorsNames()
+    {
+        return array_keys($this->proxyFixers);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function createProxyFixers()
+    {
+        return [new ErrorSuppressionFixer()];
+    }
+}