dependabot-composer 0.107.36 → 0.107.37

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

@@ -1,90 +0,0 @@
-<?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

@@ -1,211 +0,0 @@
-<?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

@@ -1,285 +0,0 @@
-<?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;
-    }
-}