dependabot-composer 0.107.13 → 0.107.14

data/helpers/vendor/composer/composer/src/Composer/Console/HtmlOutputFormatter.php

@@ -0,0 +1,90 @@
+<?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\Console;
+
+use Symfony\Component\Console\Formatter\OutputFormatter;
+
+/**
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class HtmlOutputFormatter extends OutputFormatter
+{
+    private static $availableForegroundColors = array(
+        30 => 'black',
+        31 => 'red',
+        32 => 'green',
+        33 => 'yellow',
+        34 => 'blue',
+        35 => 'magenta',
+        36 => 'cyan',
+        37 => 'white',
+    );
+    private static $availableBackgroundColors = array(
+        40 => 'black',
+        41 => 'red',
+        42 => 'green',
+        43 => 'yellow',
+        44 => 'blue',
+        45 => 'magenta',
+        46 => 'cyan',
+        47 => 'white',
+    );
+    private static $availableOptions = array(
+        1 => 'bold',
+        4 => 'underscore',
+        //5 => 'blink',
+        //7 => 'reverse',
+        //8 => 'conceal'
+    );
+
+    /**
+     * @param array $styles Array of "name => FormatterStyle" instances
+     */
+    public function __construct(array $styles = array())
+    {
+        parent::__construct(true, $styles);
+    }
+
+    public function format($message)
+    {
+        $formatted = parent::format($message);
+
+        $clearEscapeCodes = '(?:39|49|0|22|24|25|27|28)';
+
+        return preg_replace_callback("{\033\[([0-9;]+)m(.*?)\033\[(?:".$clearEscapeCodes.";)*?".$clearEscapeCodes."m}s", array($this, 'formatHtml'), $formatted);
+    }
+
+    private function formatHtml($matches)
+    {
+        $out = '<span style="';
+        foreach (explode(';', $matches[1]) as $code) {
+            if (isset(self::$availableForegroundColors[$code])) {
+                $out .= 'color:'.self::$availableForegroundColors[$code].';';
+            } elseif (isset(self::$availableBackgroundColors[$code])) {
+                $out .= 'background-color:'.self::$availableBackgroundColors[$code].';';
+            } elseif (isset(self::$availableOptions[$code])) {
+                switch (self::$availableOptions[$code]) {
+                    case 'bold':
+                        $out .= 'font-weight:bold;';
+                        break;
+
+                    case 'underscore':
+                        $out .= 'text-decoration:underline;';
+                        break;
+                }
+            }
+        }
+
+        return $out.'">'.$matches[2].'</span>';
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/DependencyResolver/Decisions.php

@@ -0,0 +1,211 @@
+<?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\DependencyResolver;
+
+/**
+ * Stores decisions on installing, removing or keeping packages
+ *
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class Decisions implements \Iterator, \Countable
+{
+    const DECISION_LITERAL = 0;
+    const DECISION_REASON = 1;
+
+    protected $pool;
+    protected $decisionMap;
+    protected $decisionQueue = array();
+
+    public function __construct($pool)
+    {
+        $this->pool = $pool;
+        $this->decisionMap = array();
+    }
+
+    public function decide($literal, $level, $why)
+    {
+        $this->addDecision($literal, $level);
+        $this->decisionQueue[] = array(
+            self::DECISION_LITERAL => $literal,
+            self::DECISION_REASON => $why,
+        );
+    }
+
+    public function satisfy($literal)
+    {
+        $packageId = abs($literal);
+
+        return (
+            $literal > 0 && isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0 ||
+            $literal < 0 && isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] < 0
+        );
+    }
+
+    public function conflict($literal)
+    {
+        $packageId = abs($literal);
+
+        return (
+            (isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0 && $literal < 0) ||
+            (isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] < 0 && $literal > 0)
+        );
+    }
+
+    public function decided($literalOrPackageId)
+    {
+        return !empty($this->decisionMap[abs($literalOrPackageId)]);
+    }
+
+    public function undecided($literalOrPackageId)
+    {
+        return empty($this->decisionMap[abs($literalOrPackageId)]);
+    }
+
+    public function decidedInstall($literalOrPackageId)
+    {
+        $packageId = abs($literalOrPackageId);
+
+        return isset($this->decisionMap[$packageId]) && $this->decisionMap[$packageId] > 0;
+    }
+
+    public function decisionLevel($literalOrPackageId)
+    {
+        $packageId = abs($literalOrPackageId);
+        if (isset($this->decisionMap[$packageId])) {
+            return abs($this->decisionMap[$packageId]);
+        }
+
+        return 0;
+    }
+
+    public function decisionRule($literalOrPackageId)
+    {
+        $packageId = abs($literalOrPackageId);
+
+        foreach ($this->decisionQueue as $i => $decision) {
+            if ($packageId === abs($decision[self::DECISION_LITERAL])) {
+                return $decision[self::DECISION_REASON];
+            }
+        }
+
+        return null;
+    }
+
+    public function atOffset($queueOffset)
+    {
+        return $this->decisionQueue[$queueOffset];
+    }
+
+    public function validOffset($queueOffset)
+    {
+        return $queueOffset >= 0 && $queueOffset < count($this->decisionQueue);
+    }
+
+    public function lastReason()
+    {
+        return $this->decisionQueue[count($this->decisionQueue) - 1][self::DECISION_REASON];
+    }
+
+    public function lastLiteral()
+    {
+        return $this->decisionQueue[count($this->decisionQueue) - 1][self::DECISION_LITERAL];
+    }
+
+    public function reset()
+    {
+        while ($decision = array_pop($this->decisionQueue)) {
+            $this->decisionMap[abs($decision[self::DECISION_LITERAL])] = 0;
+        }
+    }
+
+    public function resetToOffset($offset)
+    {
+        while (count($this->decisionQueue) > $offset + 1) {
+            $decision = array_pop($this->decisionQueue);
+            $this->decisionMap[abs($decision[self::DECISION_LITERAL])] = 0;
+        }
+    }
+
+    public function revertLast()
+    {
+        $this->decisionMap[abs($this->lastLiteral())] = 0;
+        array_pop($this->decisionQueue);
+    }
+
+    public function count()
+    {
+        return count($this->decisionQueue);
+    }
+
+    public function rewind()
+    {
+        end($this->decisionQueue);
+    }
+
+    public function current()
+    {
+        return current($this->decisionQueue);
+    }
+
+    public function key()
+    {
+        return key($this->decisionQueue);
+    }
+
+    public function next()
+    {
+        return prev($this->decisionQueue);
+    }
+
+    public function valid()
+    {
+        return false !== current($this->decisionQueue);
+    }
+
+    public function isEmpty()
+    {
+        return count($this->decisionQueue) === 0;
+    }
+
+    protected function addDecision($literal, $level)
+    {
+        $packageId = abs($literal);
+
+        $previousDecision = isset($this->decisionMap[$packageId]) ? $this->decisionMap[$packageId] : null;
+        if ($previousDecision != 0) {
+            $literalString = $this->pool->literalToString($literal);
+            $package = $this->pool->literalToPackage($literal);
+            throw new SolverBugException(
+                "Trying to decide $literalString on level $level, even though $package was previously decided as ".(int) $previousDecision."."
+            );
+        }
+
+        if ($literal > 0) {
+            $this->decisionMap[$packageId] = $level;
+        } else {
+            $this->decisionMap[$packageId] = -$level;
+        }
+    }
+
+    public function __toString()
+    {
+        $decisionMap = $this->decisionMap;
+        ksort($decisionMap);
+        $str = '[';
+        foreach ($decisionMap as $packageId => $level) {
+            $str .= $packageId.':'.$level.',';
+        }
+        $str .= ']';
+        return $str;
+    }
+}

data/helpers/vendor/composer/composer/src/Composer/DependencyResolver/DefaultPolicy.php

@@ -0,0 +1,285 @@
+<?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\DependencyResolver;
+
+use Composer\Package\PackageInterface;
+use Composer\Package\AliasPackage;
+use Composer\Package\BasePackage;
+use Composer\Semver\Constraint\Constraint;
+
+/**
+ * @author Nils Adermann <naderman@naderman.de>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ */
+class DefaultPolicy implements PolicyInterface
+{
+    private $preferStable;
+    private $preferLowest;
+
+    public function __construct($preferStable = false, $preferLowest = false)
+    {
+        $this->preferStable = $preferStable;
+        $this->preferLowest = $preferLowest;
+    }
+
+    public function versionCompare(PackageInterface $a, PackageInterface $b, $operator)
+    {
+        if ($this->preferStable && ($stabA = $a->getStability()) !== ($stabB = $b->getStability())) {
+            return BasePackage::$stabilities[$stabA] < BasePackage::$stabilities[$stabB];
+        }
+
+        $constraint = new Constraint($operator, $b->getVersion());
+        $version = new Constraint('==', $a->getVersion());
+
+        return $constraint->matchSpecific($version, true);
+    }
+
+    public function findUpdatePackages(Pool $pool, array $installedMap, PackageInterface $package, $mustMatchName = false)
+    {
+        $packages = array();
+
+        foreach ($pool->whatProvides($package->getName(), null, $mustMatchName) as $candidate) {
+            if ($candidate !== $package) {
+                $packages[] = $candidate;
+            }
+        }
+
+        return $packages;
+    }
+
+    public function getPriority(Pool $pool, PackageInterface $package)
+    {
+        return $pool->getPriority($package->getRepository());
+    }
+
+    public function selectPreferredPackages(Pool $pool, array $installedMap, array $literals, $requiredPackage = null)
+    {
+        $packages = $this->groupLiteralsByNamePreferInstalled($pool, $installedMap, $literals);
+
+        foreach ($packages as &$literals) {
+            $policy = $this;
+            usort($literals, function ($a, $b) use ($policy, $pool, $installedMap, $requiredPackage) {
+                return $policy->compareByPriorityPreferInstalled($pool, $installedMap, $pool->literalToPackage($a), $pool->literalToPackage($b), $requiredPackage, true);
+            });
+        }
+
+        foreach ($packages as &$literals) {
+            $literals = $this->pruneToHighestPriorityOrInstalled($pool, $installedMap, $literals);
+
+            $literals = $this->pruneToBestVersion($pool, $literals);
+
+            $literals = $this->pruneRemoteAliases($pool, $literals);
+        }
+
+        $selected = call_user_func_array('array_merge', $packages);
+
+        // now sort the result across all packages to respect replaces across packages
+        usort($selected, function ($a, $b) use ($policy, $pool, $installedMap, $requiredPackage) {
+            return $policy->compareByPriorityPreferInstalled($pool, $installedMap, $pool->literalToPackage($a), $pool->literalToPackage($b), $requiredPackage);
+        });
+
+        return $selected;
+    }
+
+    protected function groupLiteralsByNamePreferInstalled(Pool $pool, array $installedMap, $literals)
+    {
+        $packages = array();
+        foreach ($literals as $literal) {
+            $packageName = $pool->literalToPackage($literal)->getName();
+
+            if (!isset($packages[$packageName])) {
+                $packages[$packageName] = array();
+            }
+
+            if (isset($installedMap[abs($literal)])) {
+                array_unshift($packages[$packageName], $literal);
+            } else {
+                $packages[$packageName][] = $literal;
+            }
+        }
+
+        return $packages;
+    }
+
+    /**
+     * @protected
+     */
+    public function compareByPriorityPreferInstalled(Pool $pool, array $installedMap, PackageInterface $a, PackageInterface $b, $requiredPackage = null, $ignoreReplace = false)
+    {
+        if ($a->getRepository() === $b->getRepository()) {
+            // prefer aliases to the original package
+            if ($a->getName() === $b->getName()) {
+                $aAliased = $a instanceof AliasPackage;
+                $bAliased = $b instanceof AliasPackage;
+                if ($aAliased && !$bAliased) {
+                    return -1; // use a
+                }
+                if (!$aAliased && $bAliased) {
+                    return 1; // use b
+                }
+            }
+
+            if (!$ignoreReplace) {
+                // return original, not replaced
+                if ($this->replaces($a, $b)) {
+                    return 1; // use b
+                }
+                if ($this->replaces($b, $a)) {
+                    return -1; // use a
+                }
+
+                // for replacers not replacing each other, put a higher prio on replacing
+                // packages with the same vendor as the required package
+                if ($requiredPackage && false !== ($pos = strpos($requiredPackage, '/'))) {
+                    $requiredVendor = substr($requiredPackage, 0, $pos);
+
+                    $aIsSameVendor = substr($a->getName(), 0, $pos) === $requiredVendor;
+                    $bIsSameVendor = substr($b->getName(), 0, $pos) === $requiredVendor;
+
+                    if ($bIsSameVendor !== $aIsSameVendor) {
+                        return $aIsSameVendor ? -1 : 1;
+                    }
+                }
+            }
+
+            // priority equal, sort by package id to make reproducible
+            if ($a->id === $b->id) {
+                return 0;
+            }
+
+            return ($a->id < $b->id) ? -1 : 1;
+        }
+
+        if (isset($installedMap[$a->id])) {
+            return -1;
+        }
+
+        if (isset($installedMap[$b->id])) {
+            return 1;
+        }
+
+        return ($this->getPriority($pool, $a) > $this->getPriority($pool, $b)) ? -1 : 1;
+    }
+
+    /**
+     * Checks if source replaces a package with the same name as target.
+     *
+     * Replace constraints are ignored. This method should only be used for
+     * prioritisation, not for actual constraint verification.
+     *
+     * @param  PackageInterface $source
+     * @param  PackageInterface $target
+     * @return bool
+     */
+    protected function replaces(PackageInterface $source, PackageInterface $target)
+    {
+        foreach ($source->getReplaces() as $link) {
+            if ($link->getTarget() === $target->getName()
+//                && (null === $link->getConstraint() ||
+//                $link->getConstraint()->matches(new Constraint('==', $target->getVersion())))) {
+                ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    protected function pruneToBestVersion(Pool $pool, $literals)
+    {
+        $operator = $this->preferLowest ? '<' : '>';
+        $bestLiterals = array($literals[0]);
+        $bestPackage = $pool->literalToPackage($literals[0]);
+        foreach ($literals as $i => $literal) {
+            if (0 === $i) {
+                continue;
+            }
+
+            $package = $pool->literalToPackage($literal);
+
+            if ($this->versionCompare($package, $bestPackage, $operator)) {
+                $bestPackage = $package;
+                $bestLiterals = array($literal);
+            } elseif ($this->versionCompare($package, $bestPackage, '==')) {
+                $bestLiterals[] = $literal;
+            }
+        }
+
+        return $bestLiterals;
+    }
+
+    /**
+     * Assumes that installed packages come first and then all highest priority packages
+     */
+    protected function pruneToHighestPriorityOrInstalled(Pool $pool, array $installedMap, array $literals)
+    {
+        $selected = array();
+
+        $priority = null;
+
+        foreach ($literals as $literal) {
+            $package = $pool->literalToPackage($literal);
+
+            if (isset($installedMap[$package->id])) {
+                $selected[] = $literal;
+                continue;
+            }
+
+            if (null === $priority) {
+                $priority = $this->getPriority($pool, $package);
+            }
+
+            if ($this->getPriority($pool, $package) != $priority) {
+                break;
+            }
+
+            $selected[] = $literal;
+        }
+
+        return $selected;
+    }
+
+    /**
+     * Assumes that locally aliased (in root package requires) packages take priority over branch-alias ones
+     *
+     * If no package is a local alias, nothing happens
+     */
+    protected function pruneRemoteAliases(Pool $pool, array $literals)
+    {
+        $hasLocalAlias = false;
+
+        foreach ($literals as $literal) {
+            $package = $pool->literalToPackage($literal);
+
+            if ($package instanceof AliasPackage && $package->isRootPackageAlias()) {
+                $hasLocalAlias = true;
+                break;
+            }
+        }
+
+        if (!$hasLocalAlias) {
+            return $literals;
+        }
+
+        $selected = array();
+        foreach ($literals as $literal) {
+            $package = $pool->literalToPackage($literal);
+
+            if ($package instanceof AliasPackage && $package->isRootPackageAlias()) {
+                $selected[] = $literal;
+            }
+        }
+
+        return $selected;
+    }
+}