dependabot-composer 0.95.59 → 0.95.60

data/helpers/vendor/composer/composer/src/Composer/Package/Version/VersionParser.php

@@ -0,0 +1,81 @@
+<?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\Package\Version;
+
+use Composer\Repository\PlatformRepository;
+use Composer\Semver\VersionParser as SemverVersionParser;
+use Composer\Semver\Semver;
+
+class VersionParser extends SemverVersionParser
+{
+    private static $constraints = array();
+
+    /**
+     * {@inheritDoc}
+     */
+    public function parseConstraints($constraints)
+    {
+        if (!isset(self::$constraints[$constraints])) {
+            self::$constraints[$constraints] = parent::parseConstraints($constraints);
+        }
+
+        return self::$constraints[$constraints];
+    }
+
+    /**
+     * Parses an array of strings representing package/version pairs.
+     *
+     * The parsing results in an array of arrays, each of which
+     * contain a 'name' key with value and optionally a 'version' key with value.
+     *
+     * @param array $pairs a set of package/version pairs separated by ":", "=" or " "
+     *
+     * @return array[] array of arrays containing a name and (if provided) a version
+     */
+    public function parseNameVersionPairs(array $pairs)
+    {
+        $pairs = array_values($pairs);
+        $result = array();
+
+        for ($i = 0, $count = count($pairs); $i < $count; $i++) {
+            $pair = preg_replace('{^([^=: ]+)[=: ](.*)$}', '$1 $2', trim($pairs[$i]));
+            if (false === strpos($pair, ' ') && isset($pairs[$i + 1]) && false === strpos($pairs[$i + 1], '/') && !preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $pairs[$i + 1])) {
+                $pair .= ' '.$pairs[$i + 1];
+                $i++;
+            }
+
+            if (strpos($pair, ' ')) {
+                list($name, $version) = explode(' ', $pair, 2);
+                $result[] = array('name' => $name, 'version' => $version);
+            } else {
+                $result[] = array('name' => $pair);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @return bool
+     */
+    public static function isUpgrade($normalizedFrom, $normalizedTo)
+    {
+        if (substr($normalizedFrom, 0, 4) === 'dev-' || substr($normalizedTo, 0, 4) === 'dev-') {
+            return true;
+        }
+
+        $sorted = Semver::sort(array($normalizedTo, $normalizedFrom));
+
+        return $sorted[0] === $normalizedFrom;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Package/Version/VersionSelector.php

@@ -0,0 +1,176 @@
+<?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\Package\Version;
+
+use Composer\DependencyResolver\Pool;
+use Composer\Package\BasePackage;
+use Composer\Package\PackageInterface;
+use Composer\Package\Loader\ArrayLoader;
+use Composer\Package\Dumper\ArrayDumper;
+use Composer\Semver\Constraint\Constraint;
+
+/**
+ * Selects the best possible version for a package
+ *
+ * @author Ryan Weaver <ryan@knpuniversity.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class VersionSelector
+{
+    private $pool;
+
+    private $parser;
+
+    public function __construct(Pool $pool)
+    {
+        $this->pool = $pool;
+    }
+
+    /**
+     * Given a package name and optional version, returns the latest PackageInterface
+     * that matches.
+     *
+     * @param  string                $packageName
+     * @param  string                $targetPackageVersion
+     * @param  string                $targetPhpVersion
+     * @param  string                $preferredStability
+     * @return PackageInterface|bool
+     */
+    public function findBestCandidate($packageName, $targetPackageVersion = null, $targetPhpVersion = null, $preferredStability = 'stable')
+    {
+        $constraint = $targetPackageVersion ? $this->getParser()->parseConstraints($targetPackageVersion) : null;
+        $candidates = $this->pool->whatProvides(strtolower($packageName), $constraint, true);
+
+        if ($targetPhpVersion) {
+            $phpConstraint = new Constraint('==', $this->getParser()->normalize($targetPhpVersion));
+            $candidates = array_filter($candidates, function ($pkg) use ($phpConstraint) {
+                $reqs = $pkg->getRequires();
+
+                return !isset($reqs['php']) || $reqs['php']->getConstraint()->matches($phpConstraint);
+            });
+        }
+
+        if (!$candidates) {
+            return false;
+        }
+
+        // select highest version if we have many
+        $package = reset($candidates);
+        $minPriority = BasePackage::$stabilities[$preferredStability];
+        foreach ($candidates as $candidate) {
+            $candidatePriority = $candidate->getStabilityPriority();
+            $currentPriority = $package->getStabilityPriority();
+
+            // candidate is less stable than our preferred stability,
+            // and current package is more stable than candidate, skip it
+            if ($minPriority < $candidatePriority && $currentPriority < $candidatePriority) {
+                continue;
+            }
+
+            // candidate is less stable than our preferred stability,
+            // and current package is less stable than candidate, select candidate
+            if ($minPriority < $candidatePriority && $candidatePriority < $currentPriority) {
+                $package = $candidate;
+                continue;
+            }
+
+            // candidate is more stable than our preferred stability,
+            // and current package is less stable than preferred stability, select candidate
+            if ($minPriority >= $candidatePriority && $minPriority < $currentPriority) {
+                $package = $candidate;
+                continue;
+            }
+
+            // select highest version of the two
+            if (version_compare($package->getVersion(), $candidate->getVersion(), '<')) {
+                $package = $candidate;
+            }
+        }
+
+        return $package;
+    }
+
+    /**
+     * Given a concrete version, this returns a ~ constraint (when possible)
+     * that should be used, for example, in composer.json.
+     *
+     * For example:
+     *  * 1.2.1         -> ^1.2
+     *  * 1.2           -> ^1.2
+     *  * v3.2.1        -> ^3.2
+     *  * 2.0-beta.1    -> ^2.0@beta
+     *  * dev-master    -> ^2.1@dev      (dev version with alias)
+     *  * dev-master    -> dev-master    (dev versions are untouched)
+     *
+     * @param  PackageInterface $package
+     * @return string
+     */
+    public function findRecommendedRequireVersion(PackageInterface $package)
+    {
+        $version = $package->getVersion();
+        if (!$package->isDev()) {
+            return $this->transformVersion($version, $package->getPrettyVersion(), $package->getStability());
+        }
+
+        $loader = new ArrayLoader($this->getParser());
+        $dumper = new ArrayDumper();
+        $extra = $loader->getBranchAlias($dumper->dump($package));
+        if ($extra) {
+            $extra = preg_replace('{^(\d+\.\d+\.\d+)(\.9999999)-dev$}', '$1.0', $extra, -1, $count);
+            if ($count) {
+                $extra = str_replace('.9999999', '.0', $extra);
+
+                return $this->transformVersion($extra, $extra, 'dev');
+            }
+        }
+
+        return $package->getPrettyVersion();
+    }
+
+    private function transformVersion($version, $prettyVersion, $stability)
+    {
+        // attempt to transform 2.1.1 to 2.1
+        // this allows you to upgrade through minor versions
+        $semanticVersionParts = explode('.', $version);
+
+        // check to see if we have a semver-looking version
+        if (count($semanticVersionParts) == 4 && preg_match('{^0\D?}', $semanticVersionParts[3])) {
+            // remove the last parts (i.e. the patch version number and any extra)
+            if ($semanticVersionParts[0] === '0') {
+                unset($semanticVersionParts[3]);
+            } else {
+                unset($semanticVersionParts[2], $semanticVersionParts[3]);
+            }
+            $version = implode('.', $semanticVersionParts);
+        } else {
+            return $prettyVersion;
+        }
+
+        // append stability flag if not default
+        if ($stability != 'stable') {
+            $version .= '@'.$stability;
+        }
+
+        // 2.1 -> ^2.1
+        return '^' . $version;
+    }
+
+    private function getParser()
+    {
+        if ($this->parser === null) {
+            $this->parser = new VersionParser();
+        }
+
+        return $this->parser;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/Plugin/Capability/Capability.php

@@ -0,0 +1,23 @@
+<?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\Plugin\Capability;
+
+/**
+ * Marker interface for Plugin capabilities.
+ * Every new Capability which is added to the Plugin API must implement this interface.
+ *
+ * @api
+ */
+interface Capability
+{
+}

data/helpers/vendor/composer/composer/src/Composer/Plugin/Capability/CommandProvider.php

@@ -0,0 +1,33 @@
+<?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\Plugin\Capability;
+
+/**
+ * Commands Provider Interface
+ *
+ * This capability will receive an array with 'composer' and 'io' keys as
+ * constructor argument. Those contain Composer\Composer and Composer\IO\IOInterface
+ * instances. It also contains a 'plugin' key containing the plugin instance that
+ * created the capability.
+ *
+ * @author Jérémy Derussé <jeremy@derusse.com>
+ */
+interface CommandProvider extends Capability
+{
+    /**
+     * Retrieves an array of commands
+     *
+     * @return \Composer\Command\BaseCommand[]
+     */
+    public function getCommands();
+}

data/helpers/vendor/composer/composer/src/Composer/Plugin/Capable.php

@@ -0,0 +1,43 @@
+<?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\Plugin;
+
+/**
+ * Plugins which need to expose various implementations
+ * of the Composer Plugin Capabilities must have their
+ * declared Plugin class implementing this interface.
+ *
+ * @api
+ */
+interface Capable
+{
+    /**
+     * Method by which a Plugin announces its API implementations, through an array
+     * with a special structure.
+     *
+     * The key must be a string, representing a fully qualified class/interface name
+     * which Composer Plugin API exposes.
+     * The value must be a string as well, representing the fully qualified class name
+     * of the implementing class.
+     *
+     * @tutorial
+     *
+     * return array(
+     *     'Composer\Plugin\Capability\CommandProvider' => 'My\CommandProvider',
+     *     'Composer\Plugin\Capability\Validator'       => 'My\Validator',
+     * );
+     *
+     * @return string[]
+     */
+    public function getCapabilities();
+}

data/helpers/vendor/composer/composer/src/Composer/Plugin/CommandEvent.php

@@ -0,0 +1,88 @@
+<?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\Plugin;
+
+use Composer\EventDispatcher\Event;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * An event for all commands.
+ *
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class CommandEvent extends Event
+{
+    /**
+     * @var string
+     */
+    private $commandName;
+
+    /**
+     * @var InputInterface
+     */
+    private $input;
+
+    /**
+     * @var OutputInterface
+     */
+    private $output;
+
+    /**
+     * Constructor.
+     *
+     * @param string          $name        The event name
+     * @param string          $commandName The command name
+     * @param InputInterface  $input
+     * @param OutputInterface $output
+     * @param array           $args        Arguments passed by the user
+     * @param array           $flags       Optional flags to pass data not as argument
+     */
+    public function __construct($name, $commandName, $input, $output, array $args = array(), array $flags = array())
+    {
+        parent::__construct($name, $args, $flags);
+        $this->commandName = $commandName;
+        $this->input = $input;
+        $this->output = $output;
+    }
+
+    /**
+     * Returns the command input interface
+     *
+     * @return InputInterface
+     */
+    public function getInput()
+    {
+        return $this->input;
+    }
+
+    /**
+     * Retrieves the command output interface
+     *
+     * @return OutputInterface
+     */
+    public function getOutput()
+    {
+        return $this->output;
+    }
+
+    /**
+     * Retrieves the name of the command being run
+     *
+     * @return string
+     */
+    public function getCommandName()
+    {
+        return $this->commandName;
+    }
+}