dependabot-composer 0.106.4 → 0.106.5

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

@@ -0,0 +1,181 @@
+<?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\Config;
+use Composer\Console\Application;
+use Composer\Factory;
+use Composer\IO\IOInterface;
+use Composer\IO\NullIO;
+use Composer\Plugin\PreCommandRunEvent;
+use Composer\Plugin\PluginEvents;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Command\Command;
+
+/**
+ * Base class for Composer commands
+ *
+ * @author Ryan Weaver <ryan@knplabs.com>
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ */
+abstract class BaseCommand extends Command
+{
+    /**
+     * @var Composer|null
+     */
+    private $composer;
+
+    /**
+     * @var IOInterface
+     */
+    private $io;
+
+    /**
+     * @param  bool              $required
+     * @param  bool|null         $disablePlugins
+     * @throws \RuntimeException
+     * @return Composer
+     */
+    public function getComposer($required = true, $disablePlugins = null)
+    {
+        if (null === $this->composer) {
+            $application = $this->getApplication();
+            if ($application instanceof Application) {
+                /* @var $application    Application */
+                $this->composer = $application->getComposer($required, $disablePlugins);
+            } elseif ($required) {
+                throw new \RuntimeException(
+                    'Could not create a Composer\Composer instance, you must inject '.
+                    'one if this command is not used with a Composer\Console\Application instance'
+                );
+            }
+        }
+
+        return $this->composer;
+    }
+
+    /**
+     * @param Composer $composer
+     */
+    public function setComposer(Composer $composer)
+    {
+        $this->composer = $composer;
+    }
+
+    /**
+     * Removes the cached composer instance
+     */
+    public function resetComposer()
+    {
+        $this->composer = null;
+        $this->getApplication()->resetComposer();
+    }
+
+    /**
+     * Whether or not this command is meant to call another command.
+     *
+     * This is mainly needed to avoid duplicated warnings messages.
+     *
+     * @return bool
+     */
+    public function isProxyCommand()
+    {
+        return false;
+    }
+
+    /**
+     * @return IOInterface
+     */
+    public function getIO()
+    {
+        if (null === $this->io) {
+            $application = $this->getApplication();
+            if ($application instanceof Application) {
+                /* @var $application    Application */
+                $this->io = $application->getIO();
+            } else {
+                $this->io = new NullIO();
+            }
+        }
+
+        return $this->io;
+    }
+
+    /**
+     * @param IOInterface $io
+     */
+    public function setIO(IOInterface $io)
+    {
+        $this->io = $io;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function initialize(InputInterface $input, OutputInterface $output)
+    {
+        // initialize a plugin-enabled Composer instance, either local or global
+        $disablePlugins = $input->hasParameterOption('--no-plugins');
+        $composer = $this->getComposer(false, $disablePlugins);
+        if (null === $composer) {
+            $composer = Factory::createGlobal($this->getIO(), $disablePlugins);
+        }
+        if ($composer) {
+            $preCommandRunEvent = new PreCommandRunEvent(PluginEvents::PRE_COMMAND_RUN, $input, $this->getName());
+            $composer->getEventDispatcher()->dispatch($preCommandRunEvent->getName(), $preCommandRunEvent);
+        }
+
+        if (true === $input->hasParameterOption(array('--no-ansi')) && $input->hasOption('no-progress')) {
+            $input->setOption('no-progress', true);
+        }
+
+        parent::initialize($input, $output);
+    }
+
+    /**
+     * Returns preferSource and preferDist values based on the configuration.
+     *
+     * @param Config         $config
+     * @param InputInterface $input
+     * @param bool           $keepVcsRequiresPreferSource
+     *
+     * @return bool[] An array composed of the preferSource and preferDist values
+     */
+    protected function getPreferredInstallOptions(Config $config, InputInterface $input, $keepVcsRequiresPreferSource = false)
+    {
+        $preferSource = false;
+        $preferDist = false;
+
+        switch ($config->get('preferred-install')) {
+            case 'source':
+                $preferSource = true;
+                break;
+            case 'dist':
+                $preferDist = true;
+                break;
+            case 'auto':
+            default:
+                // noop
+                break;
+        }
+
+        if ($input->getOption('prefer-source') || $input->getOption('prefer-dist') || ($keepVcsRequiresPreferSource && $input->hasOption('keep-vcs') && $input->getOption('keep-vcs'))) {
+            $preferSource = $input->getOption('prefer-source') || ($keepVcsRequiresPreferSource && $input->hasOption('keep-vcs') && $input->getOption('keep-vcs'));
+            $preferDist = $input->getOption('prefer-dist');
+        }
+
+        return array($preferSource, $preferDist);
+    }
+}

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

@@ -0,0 +1,255 @@
+<?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\DependencyResolver\Pool;
+use Composer\Package\Link;
+use Composer\Package\PackageInterface;
+use Composer\Repository\ArrayRepository;
+use Composer\Repository\CompositeRepository;
+use Composer\Repository\PlatformRepository;
+use Composer\Repository\RepositoryFactory;
+use Composer\Plugin\CommandEvent;
+use Composer\Plugin\PluginEvents;
+use Symfony\Component\Console\Formatter\OutputFormatterStyle;
+use Composer\Package\Version\VersionParser;
+use Symfony\Component\Console\Helper\Table;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * Base implementation for commands mapping dependency relationships.
+ *
+ * @author Niels Keurentjes <niels.keurentjes@omines.com>
+ */
+class BaseDependencyCommand extends BaseCommand
+{
+    const ARGUMENT_PACKAGE = 'package';
+    const ARGUMENT_CONSTRAINT = 'constraint';
+    const OPTION_RECURSIVE = 'recursive';
+    const OPTION_TREE = 'tree';
+
+    protected $colors;
+
+    /**
+     * Set common options and arguments.
+     */
+    protected function configure()
+    {
+        $this->setDefinition(array(
+            new InputArgument(self::ARGUMENT_PACKAGE, InputArgument::REQUIRED, 'Package to inspect'),
+            new InputArgument(self::ARGUMENT_CONSTRAINT, InputArgument::OPTIONAL, 'Optional version constraint', '*'),
+            new InputOption(self::OPTION_RECURSIVE, 'r', InputOption::VALUE_NONE, 'Recursively resolves up to the root package'),
+            new InputOption(self::OPTION_TREE, 't', InputOption::VALUE_NONE, 'Prints the results as a nested tree'),
+        ));
+    }
+
+    /**
+     * Execute the command.
+     *
+     * @param  InputInterface  $input
+     * @param  OutputInterface $output
+     * @param  bool            $inverted Whether to invert matching process (why-not vs why behaviour)
+     * @return int|null        Exit code of the operation.
+     */
+    protected function doExecute(InputInterface $input, OutputInterface $output, $inverted = false)
+    {
+        // Emit command event on startup
+        $composer = $this->getComposer();
+        $commandEvent = new CommandEvent(PluginEvents::COMMAND, $this->getName(), $input, $output);
+        $composer->getEventDispatcher()->dispatch($commandEvent->getName(), $commandEvent);
+
+        // Prepare repositories and set up a pool
+        $platformOverrides = $composer->getConfig()->get('platform') ?: array();
+        $repository = new CompositeRepository(array(
+            new ArrayRepository(array($composer->getPackage())),
+            $composer->getRepositoryManager()->getLocalRepository(),
+            new PlatformRepository(array(), $platformOverrides),
+        ));
+        $pool = new Pool();
+        $pool->addRepository($repository);
+
+        // Parse package name and constraint
+        list($needle, $textConstraint) = array_pad(
+            explode(':', $input->getArgument(self::ARGUMENT_PACKAGE)),
+            2,
+            $input->getArgument(self::ARGUMENT_CONSTRAINT)
+        );
+
+        // Find packages that are or provide the requested package first
+        $packages = $pool->whatProvides(strtolower($needle));
+        if (empty($packages)) {
+            throw new \InvalidArgumentException(sprintf('Could not find package "%s" in your project', $needle));
+        }
+
+        // If the version we ask for is not installed then we need to locate it in remote repos and add it.
+        // This is needed for why-not to resolve conflicts from an uninstalled version against installed packages.
+        if (!$repository->findPackage($needle, $textConstraint)) {
+            $defaultRepos = new CompositeRepository(RepositoryFactory::defaultRepos($this->getIO()));
+            if ($match = $defaultRepos->findPackage($needle, $textConstraint)) {
+                $repository->addRepository(new ArrayRepository(array(clone $match)));
+            }
+        }
+
+        // Include replaced packages for inverted lookups as they are then the actual starting point to consider
+        $needles = array($needle);
+        if ($inverted) {
+            foreach ($packages as $package) {
+                $needles = array_merge($needles, array_map(function (Link $link) {
+                    return $link->getTarget();
+                }, $package->getReplaces()));
+            }
+        }
+
+        // Parse constraint if one was supplied
+        if ('*' !== $textConstraint) {
+            $versionParser = new VersionParser();
+            $constraint = $versionParser->parseConstraints($textConstraint);
+        } else {
+            $constraint = null;
+        }
+
+        // Parse rendering options
+        $renderTree = $input->getOption(self::OPTION_TREE);
+        $recursive = $renderTree || $input->getOption(self::OPTION_RECURSIVE);
+
+        // Resolve dependencies
+        $results = $repository->getDependents($needles, $constraint, $inverted, $recursive);
+        if (empty($results)) {
+            $extra = (null !== $constraint) ? sprintf(' in versions %smatching %s', $inverted ? 'not ' : '', $textConstraint) : '';
+            $this->getIO()->writeError(sprintf(
+                '<info>There is no installed package depending on "%s"%s</info>',
+                $needle,
+                $extra
+            ));
+        } elseif ($renderTree) {
+            $this->initStyles($output);
+            $root = $packages[0];
+            $this->getIO()->write(sprintf('<info>%s</info> %s %s', $root->getPrettyName(), $root->getPrettyVersion(), $root->getDescription()));
+            $this->printTree($results);
+        } else {
+            $this->printTable($output, $results);
+        }
+
+        return 0;
+    }
+
+    /**
+     * Assembles and prints a bottom-up table of the dependencies.
+     *
+     * @param OutputInterface $output
+     * @param array           $results
+     */
+    protected function printTable(OutputInterface $output, $results)
+    {
+        $table = array();
+        $doubles = array();
+        do {
+            $queue = array();
+            $rows = array();
+            foreach ($results as $result) {
+                /**
+                 * @var PackageInterface $package
+                 * @var Link             $link
+                 */
+                list($package, $link, $children) = $result;
+                $unique = (string) $link;
+                if (isset($doubles[$unique])) {
+                    continue;
+                }
+                $doubles[$unique] = true;
+                $version = (strpos($package->getPrettyVersion(), 'No version set') === 0) ? '-' : $package->getPrettyVersion();
+                $rows[] = array($package->getPrettyName(), $version, $link->getDescription(), sprintf('%s (%s)', $link->getTarget(), $link->getPrettyConstraint()));
+                if ($children) {
+                    $queue = array_merge($queue, $children);
+                }
+            }
+            $results = $queue;
+            $table = array_merge($rows, $table);
+        } while (!empty($results));
+
+        // Render table
+        $renderer = new Table($output);
+        $renderer->setStyle('compact');
+        $rendererStyle = $renderer->getStyle();
+        $rendererStyle->setVerticalBorderChar('');
+        $rendererStyle->setCellRowContentFormat('%s  ');
+        $renderer->setRows($table)->render();
+    }
+
+    /**
+     * Init styles for tree
+     *
+     * @param OutputInterface $output
+     */
+    protected function initStyles(OutputInterface $output)
+    {
+        $this->colors = array(
+            'green',
+            'yellow',
+            'cyan',
+            'magenta',
+            'blue',
+        );
+
+        foreach ($this->colors as $color) {
+            $style = new OutputFormatterStyle($color);
+            $output->getFormatter()->setStyle($color, $style);
+        }
+    }
+
+    /**
+     * Recursively prints a tree of the selected results.
+     *
+     * @param array  $results Results to be printed at this level.
+     * @param string $prefix  Prefix of the current tree level.
+     * @param int    $level   Current level of recursion.
+     */
+    protected function printTree($results, $prefix = '', $level = 1)
+    {
+        $count = count($results);
+        $idx = 0;
+        foreach ($results as $result) {
+            /**
+             * @var PackageInterface $package
+             * @var Link             $link
+             * @var array|bool       $children
+             */
+            list($package, $link, $children) = $result;
+
+            $color = $this->colors[$level % count($this->colors)];
+            $prevColor = $this->colors[($level - 1) % count($this->colors)];
+            $isLast = (++$idx == $count);
+            $versionText = (strpos($package->getPrettyVersion(), 'No version set') === 0) ? '' : $package->getPrettyVersion();
+            $packageText = rtrim(sprintf('<%s>%s</%1$s> %s', $color, $package->getPrettyName(), $versionText));
+            $linkText = sprintf('%s <%s>%s</%2$s> %s', $link->getDescription(), $prevColor, $link->getTarget(), $link->getPrettyConstraint());
+            $circularWarn = $children === false ? '(circular dependency aborted here)' : '';
+            $this->writeTreeLine(rtrim(sprintf("%s%s%s (%s) %s", $prefix, $isLast ? '└──' : '├──', $packageText, $linkText, $circularWarn)));
+            if ($children) {
+                $this->printTree($children, $prefix . ($isLast ? '   ' : '│  '), $level + 1);
+            }
+        }
+    }
+
+    private function writeTreeLine($line)
+    {
+        $io = $this->getIO();
+        if (!$io->isDecorated()) {
+            $line = str_replace(array('└', '├', '──', '│'), array('`-', '|-', '-', '|'), $line);
+        }
+
+        $io->write($line);
+    }
+}

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

@@ -0,0 +1,156 @@
+<?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\Package\Link;
+use Composer\Package\PackageInterface;
+use Composer\Semver\Constraint\Constraint;
+use Symfony\Component\Console\Helper\Table;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Composer\Repository\PlatformRepository;
+
+class CheckPlatformReqsCommand extends BaseCommand
+{
+    protected function configure()
+    {
+        $this->setName('check-platform-reqs')
+            ->setDescription('Check that platform requirements are satisfied.')
+            ->setDefinition(array(
+                new InputOption('no-dev', null, InputOption::VALUE_NONE, 'Disables checking of require-dev packages requirements.'),
+            ))
+            ->setHelp(
+                <<<EOT
+Checks that your PHP and extensions versions match the platform requirements of the installed packages.
+
+<info>php composer.phar check-platform-reqs</info>
+
+EOT
+            );
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $composer = $this->getComposer();
+
+        $requires = $composer->getPackage()->getRequires();
+        if ($input->getOption('no-dev')) {
+            $dependencies = $composer->getLocker()->getLockedRepository(!$input->getOption('no-dev'))->getPackages();
+        } else {
+            $dependencies = $composer->getRepositoryManager()->getLocalRepository()->getPackages();
+            $requires += $composer->getPackage()->getDevRequires();
+        }
+        foreach ($requires as $require => $link) {
+            $requires[$require] = array($link);
+        }
+
+        foreach ($dependencies as $package) {
+            foreach ($package->getRequires() as $require => $link) {
+                $requires[$require][] = $link;
+            }
+        }
+
+        ksort($requires);
+
+        $platformRepo = new PlatformRepository(array(), array());
+        $currentPlatformPackages = $platformRepo->getPackages();
+        $currentPlatformPackageMap = array();
+
+        /**
+         * @var PackageInterface $currentPlatformPackage
+         */
+        foreach ($currentPlatformPackages as $currentPlatformPackage) {
+            $currentPlatformPackageMap[$currentPlatformPackage->getName()] = $currentPlatformPackage;
+        }
+
+        $results = array();
+
+        $exitCode = 0;
+
+        /**
+         * @var Link[] $links
+         */
+        foreach ($requires as $require => $links) {
+            if (preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $require)) {
+                if (isset($currentPlatformPackageMap[$require])) {
+                    $pass = true;
+                    $version = $currentPlatformPackageMap[$require]->getVersion();
+
+                    foreach ($links as $link) {
+                        if (!$link->getConstraint()->matches(new Constraint('=', $version))) {
+                            $results[] = array(
+                                $currentPlatformPackageMap[$require]->getPrettyName(),
+                                $currentPlatformPackageMap[$require]->getPrettyVersion(),
+                                $link,
+                                '<error>failed</error>',
+                            );
+                            $pass = false;
+
+                            $exitCode = max($exitCode, 1);
+                        }
+                    }
+
+                    if ($pass) {
+                        $results[] = array(
+                            $currentPlatformPackageMap[$require]->getPrettyName(),
+                            $currentPlatformPackageMap[$require]->getPrettyVersion(),
+                            null,
+                            '<info>success</info>',
+                        );
+                    }
+                } else {
+                    $results[] = array(
+                        $require,
+                        'n/a',
+                        $links[0],
+                        '<error>missing</error>',
+                    );
+
+                    $exitCode = max($exitCode, 2);
+                }
+            }
+        }
+
+        $this->printTable($output, $results);
+
+        return $exitCode;
+    }
+
+    protected function printTable(OutputInterface $output, $results)
+    {
+        $table = array();
+        $rows = array();
+        foreach ($results as $result) {
+            /**
+             * @var Link|null $link
+             */
+            list($platformPackage, $version, $link, $status) = $result;
+            $rows[] = array(
+                $platformPackage,
+                $version,
+                $link ? sprintf('%s %s %s (%s)', $link->getSource(), $link->getDescription(), $link->getTarget(), $link->getPrettyConstraint()) : '',
+                $status,
+            );
+        }
+        $table = array_merge($rows, $table);
+
+        // Render table
+        $renderer = new Table($output);
+        $renderer->setStyle('compact');
+        $rendererStyle = $renderer->getStyle();
+        $rendererStyle->setVerticalBorderChar('');
+        $rendererStyle->setCellRowContentFormat('%s  ');
+        $renderer->setRows($table)->render();
+    }
+}