dependabot-composer 0.111.24 → 0.111.25

data/helpers/vendor/composer/composer/src/Composer/Command/StatusCommand.php

@@ -0,0 +1,214 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Command;
+
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Composer\Downloader\ChangeReportInterface;
+use Composer\Downloader\DvcsDownloaderInterface;
+use Composer\Downloader\VcsCapableDownloaderInterface;
+use Composer\Package\Dumper\ArrayDumper;
+use Composer\Package\Version\VersionGuesser;
+use Composer\Package\Version\VersionParser;
+use Composer\Plugin\CommandEvent;
+use Composer\Plugin\PluginEvents;
+use Composer\Script\ScriptEvents;
+use Composer\Util\ProcessExecutor;
+
+/**
+ * @author Tiago Ribeiro <tiago.ribeiro@seegno.com>
+ * @author Rui Marinho <rui.marinho@seegno.com>
+ */
+class StatusCommand extends BaseCommand
+{
+    const EXIT_CODE_ERRORS = 1;
+    const EXIT_CODE_UNPUSHED_CHANGES = 2;
+    const EXIT_CODE_VERSION_CHANGES = 4;
+
+    /**
+     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
+     */
+    protected function configure()
+    {
+        $this
+            ->setName('status')
+            ->setDescription('Shows a list of locally modified packages, for packages installed from source.')
+            ->setDefinition(array(
+                new InputOption('verbose', 'v|vv|vvv', InputOption::VALUE_NONE, 'Show modified files for each directory that contains changes.'),
+            ))
+            ->setHelp(
+                <<<EOT
+The status command displays a list of dependencies that have
+been modified locally.
+
+Read more at https://getcomposer.org/doc/03-cli.md#status
+EOT
+            )
+        ;
+    }
+
+    /**
+     * @param  InputInterface  $input
+     * @param  OutputInterface $output
+     * @return int|null
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        // init repos
+        $composer = $this->getComposer();
+
+        $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'status', $input, $output);
+        $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
+
+        $installedRepo = $composer->getRepositoryManager()->getLocalRepository();
+
+        $dm = $composer->getDownloadManager();
+        $im = $composer->getInstallationManager();
+
+        // Dispatch pre-status-command
+        $composer->getEventDispatcher()->dispatchScript(ScriptEvents::PRE_STATUS_CMD, true);
+
+        $errors = array();
+        $io = $this->getIO();
+        $unpushedChanges = array();
+        $vcsVersionChanges = array();
+
+        $parser = new VersionParser;
+        $guesser = new VersionGuesser($composer->getConfig(), new ProcessExecutor($io), $parser);
+        $dumper = new ArrayDumper;
+
+        // list packages
+        foreach ($installedRepo->getCanonicalPackages() as $package) {
+            $downloader = $dm->getDownloaderForInstalledPackage($package);
+            $targetDir = $im->getInstallPath($package);
+
+            if ($downloader instanceof ChangeReportInterface) {
+                if (is_link($targetDir)) {
+                    $errors[$targetDir] = $targetDir . ' is a symbolic link.';
+                }
+
+                if ($changes = $downloader->getLocalChanges($package, $targetDir)) {
+                    $errors[$targetDir] = $changes;
+                }
+            }
+
+            if ($downloader instanceof VcsCapableDownloaderInterface) {
+                if ($currentRef = $downloader->getVcsReference($package, $targetDir)) {
+                    switch ($package->getInstallationSource()) {
+                        case 'source':
+                            $previousRef = $package->getSourceReference();
+                            break;
+                        case 'dist':
+                            $previousRef = $package->getDistReference();
+                            break;
+                        default:
+                            $previousRef = null;
+                    }
+
+                    $currentVersion = $guesser->guessVersion($dumper->dump($package), $targetDir);
+
+                    if ($previousRef && $currentVersion && $currentVersion['commit'] !== $previousRef) {
+                        $vcsVersionChanges[$targetDir] = array(
+                            'previous' => array(
+                                'version' => $package->getPrettyVersion(),
+                                'ref' => $previousRef,
+                            ),
+                            'current' => array(
+                                'version' => $currentVersion['pretty_version'],
+                                'ref' => $currentVersion['commit'],
+                            ),
+                        );
+                    }
+                }
+            }
+
+            if ($downloader instanceof DvcsDownloaderInterface) {
+                if ($unpushed = $downloader->getUnpushedChanges($package, $targetDir)) {
+                    $unpushedChanges[$targetDir] = $unpushed;
+                }
+            }
+        }
+
+        // output errors/warnings
+        if (!$errors && !$unpushedChanges && !$vcsVersionChanges) {
+            $io->writeError('<info>No local changes</info>');
+
+            return 0;
+        }
+
+        if ($errors) {
+            $io->writeError('<error>You have changes in the following dependencies:</error>');
+
+            foreach ($errors as $path => $changes) {
+                if ($input->getOption('verbose')) {
+                    $indentedChanges = implode("\n", array_map(function ($line) {
+                        return '    ' . ltrim($line);
+                    }, explode("\n", $changes)));
+                    $io->write('<info>'.$path.'</info>:');
+                    $io->write($indentedChanges);
+                } else {
+                    $io->write($path);
+                }
+            }
+        }
+
+        if ($unpushedChanges) {
+            $io->writeError('<warning>You have unpushed changes on the current branch in the following dependencies:</warning>');
+
+            foreach ($unpushedChanges as $path => $changes) {
+                if ($input->getOption('verbose')) {
+                    $indentedChanges = implode("\n", array_map(function ($line) {
+                        return '    ' . ltrim($line);
+                    }, explode("\n", $changes)));
+                    $io->write('<info>'.$path.'</info>:');
+                    $io->write($indentedChanges);
+                } else {
+                    $io->write($path);
+                }
+            }
+        }
+
+        if ($vcsVersionChanges) {
+            $io->writeError('<warning>You have version variations in the following dependencies:</warning>');
+
+            foreach ($vcsVersionChanges as $path => $changes) {
+                if ($input->getOption('verbose')) {
+                    // If we don't can't find a version, use the ref instead.
+                    $currentVersion = $changes['current']['version'] ?: $changes['current']['ref'];
+                    $previousVersion = $changes['previous']['version'] ?: $changes['previous']['ref'];
+
+                    if ($io->isVeryVerbose()) {
+                        // Output the ref regardless of whether or not it's being used as the version
+                        $currentVersion .= sprintf(' (%s)', $changes['current']['ref']);
+                        $previousVersion .= sprintf(' (%s)', $changes['previous']['ref']);
+                    }
+
+                    $io->write('<info>'.$path.'</info>:');
+                    $io->write(sprintf('    From <comment>%s</comment> to <comment>%s</comment>', $previousVersion, $currentVersion));
+                } else {
+                    $io->write($path);
+                }
+            }
+        }
+
+        if (($errors || $unpushedChanges || $vcsVersionChanges) && !$input->getOption('verbose')) {
+            $io->writeError('Use --verbose (-v) to see a list of files');
+        }
+
+        // Dispatch post-status-command
+        $composer->getEventDispatcher()->dispatchScript(ScriptEvents::POST_STATUS_CMD, true);
+
+        return ($errors ? self::EXIT_CODE_ERRORS : 0) + ($unpushedChanges ? self::EXIT_CODE_UNPUSHED_CHANGES : 0) + ($vcsVersionChanges ? self::EXIT_CODE_VERSION_CHANGES : 0);
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Command/SuggestsCommand.php

@@ -0,0 +1,152 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Command;
+
+use Composer\Repository\PlatformRepository;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class SuggestsCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this
+            ->setName('suggests')
+            ->setDescription('Shows package suggestions.')
+            ->setDefinition(array(
+                new InputOption('by-package', null, InputOption::VALUE_NONE, 'Groups output by suggesting package'),
+                new InputOption('by-suggestion', null, InputOption::VALUE_NONE, 'Groups output by suggested package'),
+                new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Exclude suggestions from require-dev packages'),
+                new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Packages that you want to list suggestions from.'),
+            ))
+            ->setHelp(
+                <<<EOT
+
+The <info>%command.name%</info> command shows a sorted list of suggested packages.
+
+Enabling <info>-v</info> implies <info>--by-package --by-suggestion</info>, showing both lists.
+
+Read more at https://getcomposer.org/doc/03-cli.md#suggests
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $lock = $this->getComposer()->getLocker()->getLockData();
+
+        if (empty($lock)) {
+            throw new \RuntimeException('Lockfile seems to be empty?');
+        }
+
+        $packages = $lock['packages'];
+
+        if (!$input->getOption('no-dev')) {
+            $packages += $lock['packages-dev'];
+        }
+
+        $filter = $input->getArgument('packages');
+
+        // First assemble lookup list of packages that are installed, replaced or provided
+        $installed = array();
+        foreach ($packages as $package) {
+            $installed[] = $package['name'];
+
+            if (!empty($package['provide'])) {
+                $installed = array_merge($installed, array_keys($package['provide']));
+            }
+
+            if (!empty($package['replace'])) {
+                $installed = array_merge($installed, array_keys($package['replace']));
+            }
+        }
+
+        // Undub and sort the install list into a sorted lookup array
+        $installed = array_flip($installed);
+        ksort($installed);
+
+        // Init platform repo
+        $platform = new PlatformRepository(array(), $this->getComposer()->getConfig()->get('platform') ?: array());
+
+        // Next gather all suggestions that are not in that list
+        $suggesters = array();
+        $suggested = array();
+        foreach ($packages as $package) {
+            $packageName = $package['name'];
+            if ((!empty($filter) && !in_array($packageName, $filter)) || empty($package['suggest'])) {
+                continue;
+            }
+            foreach ($package['suggest'] as $suggestion => $reason) {
+                if (false === strpos('/', $suggestion) && null !== $platform->findPackage($suggestion, '*')) {
+                    continue;
+                }
+                if (!isset($installed[$suggestion])) {
+                    $suggesters[$packageName][$suggestion] = $reason;
+                    $suggested[$suggestion][$packageName] = $reason;
+                }
+            }
+        }
+        ksort($suggesters);
+        ksort($suggested);
+
+        // Determine output mode
+        $mode = 0;
+        $io = $this->getIO();
+        if ($input->getOption('by-package') || $io->isVerbose()) {
+            $mode |= 1;
+        }
+        if ($input->getOption('by-suggestion')) {
+            $mode |= 2;
+        }
+
+        // Simple mode
+        if ($mode === 0) {
+            foreach (array_keys($suggested) as $suggestion) {
+                $io->write(sprintf('<info>%s</info>', $suggestion));
+            }
+
+            return;
+        }
+
+        // Grouped by package
+        if ($mode & 1) {
+            foreach ($suggesters as $suggester => $suggestions) {
+                $io->write(sprintf('<comment>%s</comment> suggests:', $suggester));
+
+                foreach ($suggestions as $suggestion => $reason) {
+                    $io->write(sprintf(' - <info>%s</info>: %s', $suggestion, $reason ?: '*'));
+                }
+                $io->write('');
+            }
+        }
+
+        // Grouped by suggestion
+        if ($mode & 2) {
+            // Improve readability in full mode
+            if ($mode & 1) {
+                $io->write(str_repeat('-', 78));
+            }
+            foreach ($suggested as $suggestion => $suggesters) {
+                $io->write(sprintf('<comment>%s</comment> is suggested by:', $suggestion));
+
+                foreach ($suggesters as $suggester => $reason) {
+                    $io->write(sprintf(' - <info>%s</info>: %s', $suggester, $reason ?: '*'));
+                }
+                $io->write('');
+            }
+        }
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Command/UpdateCommand.php

@@ -0,0 +1,228 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Command;
+
+use Composer\Composer;
+use Composer\Installer;
+use Composer\IO\IOInterface;
+use Composer\Plugin\CommandEvent;
+use Composer\Plugin\PluginEvents;
+use Symfony\Component\Console\Helper\Table;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\Question;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class UpdateCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this
+            ->setName('update')
+            ->setAliases(array('u', 'upgrade'))
+            ->setDescription('Upgrades your dependencies to the latest version according to composer.json, and updates the composer.lock file.')
+            ->setDefinition(array(
+                new InputArgument('packages', InputArgument::IS_ARRAY | InputArgument::OPTIONAL, 'Packages that should be updated, if not provided all packages are.'),
+                new InputOption('prefer-source', null, InputOption::VALUE_NONE, 'Forces installation from package sources when possible, including VCS information.'),
+                new InputOption('prefer-dist', null, InputOption::VALUE_NONE, 'Forces installation from package dist even for dev versions.'),
+                new InputOption('dry-run', null, InputOption::VALUE_NONE, 'Outputs the operations but will not execute anything (implicitly enables --verbose).'),
+                new InputOption('dev', null, InputOption::VALUE_NONE, 'Enables installation of require-dev packages (enabled by default, only present for BC).'),
+                new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables installation of require-dev packages.'),
+                new InputOption('lock', null, InputOption::VALUE_NONE, 'Only updates the lock file hash to suppress warning about the lock file being out of date.'),
+                new InputOption('no-custom-installers', null, InputOption::VALUE_NONE, 'DEPRECATED: Use no-plugins instead.'),
+                new InputOption('no-autoloader', null, InputOption::VALUE_NONE, 'Skips autoloader generation'),
+                new InputOption('no-scripts', null, InputOption::VALUE_NONE, 'Skips the execution of all scripts defined in composer.json file.'),
+                new InputOption('no-progress', null, InputOption::VALUE_NONE, 'Do not output download progress.'),
+                new InputOption('no-suggest', null, InputOption::VALUE_NONE, 'Do not show package suggestions.'),
+                new InputOption('with-dependencies', null, InputOption::VALUE_NONE, 'Add also dependencies of whitelisted packages to the whitelist, except those defined in root package.'),
+                new InputOption('with-all-dependencies', null, InputOption::VALUE_NONE, 'Add also all dependencies of whitelisted packages to the whitelist, including those defined in root package.'),
+                new InputOption('verbose', 'v|vv|vvv', InputOption::VALUE_NONE, 'Shows more details including new commits pulled in when updating packages.'),
+                new InputOption('optimize-autoloader', 'o', InputOption::VALUE_NONE, 'Optimize autoloader during autoloader dump.'),
+                new InputOption('classmap-authoritative', 'a', InputOption::VALUE_NONE, 'Autoload classes from the classmap only. Implicitly enables `--optimize-autoloader`.'),
+                new InputOption('apcu-autoloader', null, InputOption::VALUE_NONE, 'Use APCu to cache found/not-found classes.'),
+                new InputOption('ignore-platform-reqs', null, InputOption::VALUE_NONE, 'Ignore platform requirements (php & ext- packages).'),
+                new InputOption('prefer-stable', null, InputOption::VALUE_NONE, 'Prefer stable versions of dependencies.'),
+                new InputOption('prefer-lowest', null, InputOption::VALUE_NONE, 'Prefer lowest versions of dependencies.'),
+                new InputOption('interactive', 'i', InputOption::VALUE_NONE, 'Interactive interface with autocompletion to select the packages to update.'),
+                new InputOption('root-reqs', null, InputOption::VALUE_NONE, 'Restricts the update to your first degree dependencies.'),
+            ))
+            ->setHelp(
+                <<<EOT
+The <info>update</info> command reads the composer.json file from the
+current directory, processes it, and updates, removes or installs all the
+dependencies.
+
+<info>php composer.phar update</info>
+
+To limit the update operation to a few packages, you can list the package(s)
+you want to update as such:
+
+<info>php composer.phar update vendor/package1 foo/mypackage [...]</info>
+
+You may also use an asterisk (*) pattern to limit the update operation to package(s)
+from a specific vendor:
+
+<info>php composer.phar update vendor/package1 foo/* [...]</info>
+
+To select packages names interactively with auto-completion use <info>-i</info>.
+
+Read more at https://getcomposer.org/doc/03-cli.md#update-u
+EOT
+            )
+        ;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $io = $this->getIO();
+        if ($input->getOption('no-custom-installers')) {
+            $io->writeError('<warning>You are using the deprecated option "no-custom-installers". Use "no-plugins" instead.</warning>');
+            $input->setOption('no-plugins', true);
+        }
+
+        if ($input->getOption('dev')) {
+            $io->writeError('<warning>You are using the deprecated option "dev". Dev packages are installed by default now.</warning>');
+        }
+
+        $composer = $this->getComposer(true, $input->getOption('no-plugins'));
+
+        $packages = $input->getArgument('packages');
+
+        if ($input->getOption('interactive')) {
+            $packages = $this->getPackagesInteractively($io, $input, $output, $composer, $packages);
+        }
+
+        if ($input->getOption('root-reqs')) {
+            $require = array_keys($composer->getPackage()->getRequires());
+            if (!$input->getOption('no-dev')) {
+                $requireDev = array_keys($composer->getPackage()->getDevRequires());
+                $require = array_merge($require, $requireDev);
+            }
+
+            if (!empty($packages)) {
+                $packages = array_intersect($packages, $require);
+            } else {
+                $packages = $require;
+            }
+        }
+
+        $composer->getDownloadManager()->setOutputProgress(!$input->getOption('no-progress'));
+
+        $commandEvent = new CommandEvent(PluginEvents::COMMAND, 'update', $input, $output);
+        $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
+
+        $install = Installer::create($io, $composer);
+
+        $config = $composer->getConfig();
+        list($preferSource, $preferDist) = $this->getPreferredInstallOptions($config, $input);
+
+        $optimize = $input->getOption('optimize-autoloader') || $config->get('optimize-autoloader');
+        $authoritative = $input->getOption('classmap-authoritative') || $config->get('classmap-authoritative');
+        $apcu = $input->getOption('apcu-autoloader') || $config->get('apcu-autoloader');
+
+        $install
+            ->setDryRun($input->getOption('dry-run'))
+            ->setVerbose($input->getOption('verbose'))
+            ->setPreferSource($preferSource)
+            ->setPreferDist($preferDist)
+            ->setDevMode(!$input->getOption('no-dev'))
+            ->setDumpAutoloader(!$input->getOption('no-autoloader'))
+            ->setRunScripts(!$input->getOption('no-scripts'))
+            ->setSkipSuggest($input->getOption('no-suggest'))
+            ->setOptimizeAutoloader($optimize)
+            ->setClassMapAuthoritative($authoritative)
+            ->setApcuAutoloader($apcu)
+            ->setUpdate(true)
+            ->setUpdateWhitelist($input->getOption('lock') ? array('lock') : $packages)
+            ->setWhitelistTransitiveDependencies($input->getOption('with-dependencies'))
+            ->setWhitelistAllDependencies($input->getOption('with-all-dependencies'))
+            ->setIgnorePlatformRequirements($input->getOption('ignore-platform-reqs'))
+            ->setPreferStable($input->getOption('prefer-stable'))
+            ->setPreferLowest($input->getOption('prefer-lowest'))
+        ;
+
+        if ($input->getOption('no-plugins')) {
+            $install->disablePlugins();
+        }
+
+        return $install->run();
+    }
+
+    private function getPackagesInteractively(IOInterface $io, InputInterface $input, OutputInterface $output, Composer $composer, array $packages)
+    {
+        if (!$input->isInteractive()) {
+            throw new \InvalidArgumentException('--interactive cannot be used in non-interactive terminals.');
+        }
+
+        $requires = array_merge(
+            $composer->getPackage()->getRequires(),
+            $composer->getPackage()->getDevRequires()
+        );
+        $autocompleterValues = array();
+        foreach ($requires as $require) {
+            $target = $require->getTarget();
+            $autocompleterValues[strtolower($target)] = $target;
+        }
+
+        $installedPackages = $composer->getRepositoryManager()->getLocalRepository()->getPackages();
+        foreach ($installedPackages as $package) {
+            $autocompleterValues[$package->getName()] = $package->getPrettyName();
+        }
+
+        $helper = $this->getHelper('question');
+        $question = new Question('<comment>Enter package name: </comment>', null);
+
+        $io->writeError('<info>Press enter without value to end submission</info>');
+
+        do {
+            $autocompleterValues = array_diff($autocompleterValues, $packages);
+            $question->setAutocompleterValues($autocompleterValues);
+            $addedPackage = $helper->ask($input, $output, $question);
+
+            if (!is_string($addedPackage) || empty($addedPackage)) {
+                break;
+            }
+
+            $addedPackage = strtolower($addedPackage);
+            if (!in_array($addedPackage, $packages)) {
+                $packages[] = $addedPackage;
+            }
+        } while (true);
+
+        $packages = array_filter($packages);
+        if (!$packages) {
+            throw new \InvalidArgumentException('You must enter minimum one package.');
+        }
+
+        $table = new Table($output);
+        $table->setHeaders(array('Selected packages'));
+        foreach ($packages as $package) {
+            $table->addRow(array($package));
+        }
+        $table->render();
+
+        if ($io->askConfirmation(sprintf(
+            'Would you like to continue and update the above package%s [<comment>yes</comment>]? ',
+            1 === count($packages) ? '' : 's'
+        ), true)) {
+            return $packages;
+        }
+
+        throw new \RuntimeException('Installation aborted.');
+    }
+}