dependabot-composer 0.118.13 → 0.119.0.beta1

data/helpers/vendor/friendsofphp/php-cs-fixer/src/AbstractDoctrineAnnotationFixer.php

@@ -0,0 +1,221 @@
+<?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;
+
+use PhpCsFixer\Doctrine\Annotation\Tokens as DoctrineAnnotationTokens;
+use PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolver;
+use PhpCsFixer\FixerConfiguration\FixerOptionBuilder;
+use PhpCsFixer\Tokenizer\Token as PhpToken;
+use PhpCsFixer\Tokenizer\Tokens as PhpTokens;
+use PhpCsFixer\Tokenizer\TokensAnalyzer;
+
+/**
+ * @internal
+ */
+abstract class AbstractDoctrineAnnotationFixer extends AbstractFixer implements ConfigurationDefinitionFixerInterface
+{
+    /**
+     * @var array
+     */
+    private $classyElements;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isCandidate(PhpTokens $tokens)
+    {
+        return $tokens->isTokenKindFound(T_DOC_COMMENT);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function applyFix(\SplFileInfo $file, PhpTokens $phpTokens)
+    {
+        // fetch indexes one time, this is safe as we never add or remove a token during fixing
+        $analyzer = new TokensAnalyzer($phpTokens);
+        $this->classyElements = $analyzer->getClassyElements();
+
+        /** @var PhpToken $docCommentToken */
+        foreach ($phpTokens->findGivenKind(T_DOC_COMMENT) as $index => $docCommentToken) {
+            if (!$this->nextElementAcceptsDoctrineAnnotations($phpTokens, $index)) {
+                continue;
+            }
+
+            $tokens = DoctrineAnnotationTokens::createFromDocComment(
+                $docCommentToken,
+                $this->configuration['ignored_tags']
+            );
+            $this->fixAnnotations($tokens);
+            $phpTokens[$index] = new PhpToken([T_DOC_COMMENT, $tokens->getCode()]);
+        }
+    }
+
+    /**
+     * Fixes Doctrine annotations from the given PHPDoc style comment.
+     */
+    abstract protected function fixAnnotations(DoctrineAnnotationTokens $doctrineAnnotationTokens);
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function createConfigurationDefinition()
+    {
+        return new FixerConfigurationResolver([
+            (new FixerOptionBuilder('ignored_tags', 'List of tags that must not be treated as Doctrine Annotations.'))
+                ->setAllowedTypes(['array'])
+                ->setAllowedValues([static function ($values) {
+                    foreach ($values as $value) {
+                        if (!\is_string($value)) {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                }])
+                ->setDefault([
+                    // PHPDocumentor 1
+                    'abstract',
+                    'access',
+                    'code',
+                    'deprec',
+                    'encode',
+                    'exception',
+                    'final',
+                    'ingroup',
+                    'inheritdoc',
+                    'inheritDoc',
+                    'magic',
+                    'name',
+                    'toc',
+                    'tutorial',
+                    'private',
+                    'static',
+                    'staticvar',
+                    'staticVar',
+                    'throw',
+
+                    // PHPDocumentor 2
+                    'api',
+                    'author',
+                    'category',
+                    'copyright',
+                    'deprecated',
+                    'example',
+                    'filesource',
+                    'global',
+                    'ignore',
+                    'internal',
+                    'license',
+                    'link',
+                    'method',
+                    'package',
+                    'param',
+                    'property',
+                    'property-read',
+                    'property-write',
+                    'return',
+                    'see',
+                    'since',
+                    'source',
+                    'subpackage',
+                    'throws',
+                    'todo',
+                    'TODO',
+                    'usedBy',
+                    'uses',
+                    'var',
+                    'version',
+
+                    // PHPUnit
+                    'after',
+                    'afterClass',
+                    'backupGlobals',
+                    'backupStaticAttributes',
+                    'before',
+                    'beforeClass',
+                    'codeCoverageIgnore',
+                    'codeCoverageIgnoreStart',
+                    'codeCoverageIgnoreEnd',
+                    'covers',
+                    'coversDefaultClass',
+                    'coversNothing',
+                    'dataProvider',
+                    'depends',
+                    'expectedException',
+                    'expectedExceptionCode',
+                    'expectedExceptionMessage',
+                    'expectedExceptionMessageRegExp',
+                    'group',
+                    'large',
+                    'medium',
+                    'preserveGlobalState',
+                    'requires',
+                    'runTestsInSeparateProcesses',
+                    'runInSeparateProcess',
+                    'small',
+                    'test',
+                    'testdox',
+                    'ticket',
+                    'uses',
+
+                    // PHPCheckStyle
+                    'SuppressWarnings',
+
+                    // PHPStorm
+                    'noinspection',
+
+                    // PEAR
+                    'package_version',
+
+                    // PlantUML
+                    'enduml',
+                    'startuml',
+
+                    // other
+                    'fix',
+                    'FIXME',
+                    'fixme',
+                    'override',
+                ])
+                ->getOption(),
+        ]);
+    }
+
+    /**
+     * @param int $index
+     *
+     * @return bool
+     */
+    private function nextElementAcceptsDoctrineAnnotations(PhpTokens $tokens, $index)
+    {
+        do {
+            $index = $tokens->getNextMeaningfulToken($index);
+
+            if (null === $index) {
+                return false;
+            }
+        } while ($tokens[$index]->isGivenKind([T_ABSTRACT, T_FINAL]));
+
+        if ($tokens[$index]->isClassy()) {
+            return true;
+        }
+
+        while ($tokens[$index]->isGivenKind([T_PUBLIC, T_PROTECTED, T_PRIVATE, T_FINAL, T_ABSTRACT])) {
+            $index = $tokens->getNextMeaningfulToken($index);
+        }
+
+        return isset($this->classyElements[$index]);
+    }
+}

data/helpers/vendor/friendsofphp/php-cs-fixer/src/AbstractFixer.php

@@ -0,0 +1,227 @@
+<?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;
+
+use PhpCsFixer\ConfigurationException\InvalidFixerConfigurationException;
+use PhpCsFixer\ConfigurationException\InvalidForEnvFixerConfigurationException;
+use PhpCsFixer\ConfigurationException\RequiredFixerConfigurationException;
+use PhpCsFixer\Console\Application;
+use PhpCsFixer\Fixer\ConfigurableFixerInterface;
+use PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface;
+use PhpCsFixer\Fixer\DefinedFixerInterface;
+use PhpCsFixer\Fixer\FixerInterface;
+use PhpCsFixer\Fixer\WhitespacesAwareFixerInterface;
+use PhpCsFixer\FixerConfiguration\DeprecatedFixerOption;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\InvalidOptionsForEnvException;
+use PhpCsFixer\Tokenizer\Tokens;
+use Symfony\Component\OptionsResolver\Exception\ExceptionInterface;
+use Symfony\Component\OptionsResolver\Exception\MissingOptionsException;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @internal
+ */
+abstract class AbstractFixer implements FixerInterface, DefinedFixerInterface
+{
+    /**
+     * @var null|array<string, mixed>
+     */
+    protected $configuration;
+
+    /**
+     * @var WhitespacesFixerConfig
+     */
+    protected $whitespacesConfig;
+
+    /**
+     * @var null|FixerConfigurationResolverInterface
+     */
+    private $configurationDefinition;
+
+    public function __construct()
+    {
+        if ($this instanceof ConfigurableFixerInterface) {
+            try {
+                $this->configure([]);
+            } catch (RequiredFixerConfigurationException $e) {
+                // ignore
+            }
+        }
+
+        if ($this instanceof WhitespacesAwareFixerInterface) {
+            $this->whitespacesConfig = $this->getDefaultWhitespacesFixerConfig();
+        }
+    }
+
+    final public function fix(\SplFileInfo $file, Tokens $tokens)
+    {
+        if ($this instanceof ConfigurableFixerInterface && null === $this->configuration) {
+            throw new RequiredFixerConfigurationException($this->getName(), 'Configuration is required.');
+        }
+
+        if (0 < $tokens->count() && $this->isCandidate($tokens) && $this->supports($file)) {
+            $this->applyFix($file, $tokens);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isRisky()
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        $nameParts = explode('\\', static::class);
+        $name = substr(end($nameParts), 0, -\strlen('Fixer'));
+
+        return Utils::camelCaseToUnderscore($name);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPriority()
+    {
+        return 0;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports(\SplFileInfo $file)
+    {
+        return true;
+    }
+
+    public function configure(array $configuration = null)
+    {
+        if (!$this instanceof ConfigurationDefinitionFixerInterface) {
+            throw new \LogicException('Cannot configure using Abstract parent, child not implementing "PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface".');
+        }
+
+        if (null === $configuration) {
+            $message = 'Passing NULL to set default configuration is deprecated and will not be supported in 3.0, use an empty array instead.';
+
+            if (getenv('PHP_CS_FIXER_FUTURE_MODE')) {
+                throw new \InvalidArgumentException("{$message} This check was performed as `PHP_CS_FIXER_FUTURE_MODE` env var is set.");
+            }
+
+            @trigger_error($message, E_USER_DEPRECATED);
+
+            $configuration = [];
+        }
+
+        foreach ($this->getConfigurationDefinition()->getOptions() as $option) {
+            if (!$option instanceof DeprecatedFixerOption) {
+                continue;
+            }
+
+            $name = $option->getName();
+            if (\array_key_exists($name, $configuration)) {
+                $message = sprintf(
+                    'Option "%s" for rule "%s" is deprecated and will be removed in version %d.0. %s',
+                    $name,
+                    $this->getName(),
+                    Application::getMajorVersion() + 1,
+                    str_replace('`', '"', $option->getDeprecationMessage())
+                );
+
+                if (getenv('PHP_CS_FIXER_FUTURE_MODE')) {
+                    throw new \InvalidArgumentException("{$message} This check was performed as `PHP_CS_FIXER_FUTURE_MODE` env var is set.");
+                }
+
+                @trigger_error($message, E_USER_DEPRECATED);
+            }
+        }
+
+        try {
+            $this->configuration = $this->getConfigurationDefinition()->resolve($configuration);
+        } catch (MissingOptionsException $exception) {
+            throw new RequiredFixerConfigurationException(
+                $this->getName(),
+                sprintf('Missing required configuration: %s', $exception->getMessage()),
+                $exception
+            );
+        } catch (InvalidOptionsForEnvException $exception) {
+            throw new InvalidForEnvFixerConfigurationException(
+                $this->getName(),
+                sprintf('Invalid configuration for env: %s', $exception->getMessage()),
+                $exception
+            );
+        } catch (ExceptionInterface $exception) {
+            throw new InvalidFixerConfigurationException(
+                $this->getName(),
+                sprintf('Invalid configuration: %s', $exception->getMessage()),
+                $exception
+            );
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConfigurationDefinition()
+    {
+        if (!$this instanceof ConfigurationDefinitionFixerInterface) {
+            throw new \LogicException('Cannot get configuration definition using Abstract parent, child not implementing "PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface".');
+        }
+
+        if (null === $this->configurationDefinition) {
+            $this->configurationDefinition = $this->createConfigurationDefinition();
+        }
+
+        return $this->configurationDefinition;
+    }
+
+    public function setWhitespacesConfig(WhitespacesFixerConfig $config)
+    {
+        if (!$this instanceof WhitespacesAwareFixerInterface) {
+            throw new \LogicException('Cannot run method for class not implementing "PhpCsFixer\Fixer\WhitespacesAwareFixerInterface".');
+        }
+
+        $this->whitespacesConfig = $config;
+    }
+
+    abstract protected function applyFix(\SplFileInfo $file, Tokens $tokens);
+
+    /**
+     * @return FixerConfigurationResolverInterface
+     */
+    protected function createConfigurationDefinition()
+    {
+        if (!$this instanceof ConfigurationDefinitionFixerInterface) {
+            throw new \LogicException('Cannot create configuration definition using Abstract parent, child not implementing "PhpCsFixer\Fixer\ConfigurationDefinitionFixerInterface".');
+        }
+
+        throw new \LogicException('Not implemented.');
+    }
+
+    private function getDefaultWhitespacesFixerConfig()
+    {
+        static $defaultWhitespacesFixerConfig = null;
+
+        if (null === $defaultWhitespacesFixerConfig) {
+            $defaultWhitespacesFixerConfig = new WhitespacesFixerConfig('    ', "\n");
+        }
+
+        return $defaultWhitespacesFixerConfig;
+    }
+}

data/helpers/vendor/friendsofphp/php-cs-fixer/src/AbstractFopenFlagFixer.php

@@ -0,0 +1,127 @@
+<?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;
+
+use PhpCsFixer\Tokenizer\Analyzer\ArgumentsAnalyzer;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @internal
+ *
+ * @author SpacePossum
+ */
+abstract class AbstractFopenFlagFixer extends AbstractFunctionReferenceFixer
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function isCandidate(Tokens $tokens)
+    {
+        return $tokens->isAllTokenKindsFound([T_STRING, T_CONSTANT_ENCAPSED_STRING]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens)
+    {
+        $argumentsAnalyzer = new ArgumentsAnalyzer();
+
+        $index = 0;
+        $end = $tokens->count() - 1;
+        while (true) {
+            $candidate = $this->find('fopen', $tokens, $index, $end);
+
+            if (null === $candidate) {
+                break;
+            }
+
+            $index = $candidate[1]; // proceed to '(' of `fopen`
+
+            // fetch arguments
+            $arguments = $argumentsAnalyzer->getArguments(
+                $tokens,
+                $index,
+                $candidate[2]
+            );
+
+            $argumentsCount = \count($arguments); // argument count sanity check
+
+            if ($argumentsCount < 2 || $argumentsCount > 4) {
+                continue;
+            }
+
+            $argumentStartIndex = array_keys($arguments)[1]; // get second argument index
+
+            $this->fixFopenFlagToken(
+                $tokens,
+                $argumentStartIndex,
+                $arguments[$argumentStartIndex]
+            );
+        }
+    }
+
+    abstract protected function fixFopenFlagToken(Tokens $tokens, $argumentStartIndex, $argumentEndIndex);
+
+    /**
+     * @param string $mode
+     *
+     * @return bool
+     */
+    protected function isValidModeString($mode)
+    {
+        $modeLength = \strlen($mode);
+        if ($modeLength < 1 || $modeLength > 13) { // 13 === length 'r+w+a+x+c+etb'
+            return false;
+        }
+
+        $validFlags = [
+            'a' => true,
+            'b' => true,
+            'c' => true,
+            'e' => true,
+            'r' => true,
+            't' => true,
+            'w' => true,
+            'x' => true,
+        ];
+
+        if (!isset($validFlags[$mode[0]])) {
+            return false;
+        }
+
+        unset($validFlags[$mode[0]]);
+
+        for ($i = 1; $i < $modeLength; ++$i) {
+            if (isset($validFlags[$mode[$i]])) {
+                unset($validFlags[$mode[$i]]);
+
+                continue;
+            }
+
+            if ('+' !== $mode[$i]
+                || (
+                    'a' !== $mode[$i - 1] // 'a+','c+','r+','w+','x+'
+                    && 'c' !== $mode[$i - 1]
+                    && 'r' !== $mode[$i - 1]
+                    && 'w' !== $mode[$i - 1]
+                    && 'x' !== $mode[$i - 1]
+                )
+            ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}