dependabot-composer 0.90.0 → 0.90.1

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

@@ -1,113 +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\Link;
-
-/**
- * @author Nils Adermann <naderman@naderman.de>
- */
-class Rule2Literals extends Rule
-{
-    protected $literal1;
-    protected $literal2;
-
-    /**
-     * @param int                   $literal1
-     * @param int                   $literal2
-     * @param int                   $reason     A RULE_* constant describing the reason for generating this rule
-     * @param Link|PackageInterface $reasonData
-     * @param array                 $job        The job this rule was created from
-     */
-    public function __construct($literal1, $literal2, $reason, $reasonData, $job = null)
-    {
-        parent::__construct($reason, $reasonData, $job);
-
-        if ($literal1 < $literal2) {
-            $this->literal1 = $literal1;
-            $this->literal2 = $literal2;
-        } else {
-            $this->literal1 = $literal2;
-            $this->literal2 = $literal1;
-        }
-    }
-
-    public function getLiterals()
-    {
-        return array($this->literal1, $this->literal2);
-    }
-
-    public function getHash()
-    {
-        return $this->literal1.','.$this->literal2;
-    }
-
-    /**
-     * Checks if this rule is equal to another one
-     *
-     * Ignores whether either of the rules is disabled.
-     *
-     * @param  Rule $rule The rule to check against
-     * @return bool Whether the rules are equal
-     */
-    public function equals(Rule $rule)
-    {
-        // specialized fast-case
-        if ($rule instanceof self) {
-            if ($this->literal1 !== $rule->literal1) {
-                return false;
-            }
-
-            if ($this->literal2 !== $rule->literal2) {
-                return false;
-            }
-
-            return true;
-        }
-
-        $literals = $rule->getLiterals();
-        if (2 != count($literals)) {
-            return false;
-        }
-
-        if ($this->literal1 !== $literals[0]) {
-            return false;
-        }
-
-        if ($this->literal2 !== $literals[1]) {
-            return false;
-        }
-
-        return true;
-    }
-
-    public function isAssertion()
-    {
-        return false;
-    }
-
-    /**
-     * Formats a rule as a string of the format (Literal1|Literal2|...)
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        $result = $this->isDisabled() ? 'disabled(' : '(';
-
-        $result .= $this->literal1 . '|' . $this->literal2 . ')';
-
-        return $result;
-    }
-}

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

@@ -1,176 +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;
-
-/**
- * @author Nils Adermann <naderman@naderman.de>
- */
-class RuleSet implements \IteratorAggregate, \Countable
-{
-    // highest priority => lowest number
-    const TYPE_PACKAGE = 0;
-    const TYPE_JOB = 1;
-    const TYPE_LEARNED = 4;
-
-    /**
-     * READ-ONLY: Lookup table for rule id to rule object
-     *
-     * @var Rule[]
-     */
-    public $ruleById;
-
-    protected static $types = array(
-        255 => 'UNKNOWN',
-        self::TYPE_PACKAGE => 'PACKAGE',
-        self::TYPE_JOB => 'JOB',
-        self::TYPE_LEARNED => 'LEARNED',
-    );
-
-    protected $rules;
-    protected $nextRuleId;
-
-    protected $rulesByHash;
-
-    public function __construct()
-    {
-        $this->nextRuleId = 0;
-
-        foreach ($this->getTypes() as $type) {
-            $this->rules[$type] = array();
-        }
-
-        $this->rulesByHash = array();
-    }
-
-    public function add(Rule $rule, $type)
-    {
-        if (!isset(self::$types[$type])) {
-            throw new \OutOfBoundsException('Unknown rule type: ' . $type);
-        }
-
-        $hash = $rule->getHash();
-
-        // Do not add if rule already exists
-        if (isset($this->rulesByHash[$hash])) {
-            $potentialDuplicates = $this->rulesByHash[$hash];
-            if (is_array($potentialDuplicates)) {
-                foreach ($potentialDuplicates as $potentialDuplicate) {
-                    if ($rule->equals($potentialDuplicate)) {
-                        return;
-                    }
-                }
-            } else {
-                if ($rule->equals($potentialDuplicates)) {
-                    return;
-                }
-            }
-        }
-
-        if (!isset($this->rules[$type])) {
-            $this->rules[$type] = array();
-        }
-
-        $this->rules[$type][] = $rule;
-        $this->ruleById[$this->nextRuleId] = $rule;
-        $rule->setType($type);
-
-        $this->nextRuleId++;
-
-        if (!isset($this->rulesByHash[$hash])) {
-            $this->rulesByHash[$hash] = $rule;
-        } elseif (is_array($this->rulesByHash[$hash])) {
-            $this->rulesByHash[$hash][] = $rule;
-        } else {
-            $originalRule = $this->rulesByHash[$hash];
-            $this->rulesByHash[$hash] = array($originalRule, $rule);
-        }
-    }
-
-    public function count()
-    {
-        return $this->nextRuleId;
-    }
-
-    public function ruleById($id)
-    {
-        return $this->ruleById[$id];
-    }
-
-    public function getRules()
-    {
-        return $this->rules;
-    }
-
-    public function getIterator()
-    {
-        return new RuleSetIterator($this->getRules());
-    }
-
-    public function getIteratorFor($types)
-    {
-        if (!is_array($types)) {
-            $types = array($types);
-        }
-
-        $allRules = $this->getRules();
-        $rules = array();
-
-        foreach ($types as $type) {
-            $rules[$type] = $allRules[$type];
-        }
-
-        return new RuleSetIterator($rules);
-    }
-
-    public function getIteratorWithout($types)
-    {
-        if (!is_array($types)) {
-            $types = array($types);
-        }
-
-        $rules = $this->getRules();
-
-        foreach ($types as $type) {
-            unset($rules[$type]);
-        }
-
-        return new RuleSetIterator($rules);
-    }
-
-    public function getTypes()
-    {
-        $types = self::$types;
-        unset($types[255]);
-
-        return array_keys($types);
-    }
-
-    public function getPrettyString(Pool $pool = null)
-    {
-        $string = "\n";
-        foreach ($this->rules as $type => $rules) {
-            $string .= str_pad(self::$types[$type], 8, ' ') . ": ";
-            foreach ($rules as $rule) {
-                $string .= ($pool ? $rule->getPrettyString($pool) : $rule)."\n";
-            }
-            $string .= "\n\n";
-        }
-
-        return $string;
-    }
-
-    public function __toString()
-    {
-        return $this->getPrettyString(null);
-    }
-}

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

@@ -1,372 +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\Repository\PlatformRepository;
-
-/**
- * @author Nils Adermann <naderman@naderman.de>
- */
-class RuleSetGenerator
-{
-    protected $policy;
-    protected $pool;
-    protected $rules;
-    protected $jobs;
-    protected $installedMap;
-    protected $whitelistedMap;
-    protected $addedMap;
-    protected $conflictAddedMap;
-    protected $addedPackages;
-    protected $addedPackagesByNames;
-
-    public function __construct(PolicyInterface $policy, Pool $pool)
-    {
-        $this->policy = $policy;
-        $this->pool = $pool;
-    }
-
-    /**
-     * Creates a new rule for the requirements of a package
-     *
-     * This rule is of the form (-A|B|C), where B and C are the providers of
-     * one requirement of the package A.
-     *
-     * @param  PackageInterface $package    The package with a requirement
-     * @param  array            $providers  The providers of the requirement
-     * @param  int              $reason     A RULE_* constant describing the
-     *                                      reason for generating this rule
-     * @param  mixed            $reasonData Any data, e.g. the requirement name,
-     *                                      that goes with the reason
-     * @return Rule|null             The generated rule or null if tautological
-     */
-    protected function createRequireRule(PackageInterface $package, array $providers, $reason, $reasonData = null)
-    {
-        $literals = array(-$package->id);
-
-        foreach ($providers as $provider) {
-            // self fulfilling rule?
-            if ($provider === $package) {
-                return null;
-            }
-            $literals[] = $provider->id;
-        }
-
-        return new GenericRule($literals, $reason, $reasonData);
-    }
-
-    /**
-     * Creates a rule to install at least one of a set of packages
-     *
-     * The rule is (A|B|C) with A, B and C different packages. If the given
-     * set of packages is empty an impossible rule is generated.
-     *
-     * @param  array $packages The set of packages to choose from
-     * @param  int   $reason   A RULE_* constant describing the reason for
-     *                         generating this rule
-     * @param  array $job      The job this rule was created from
-     * @return Rule  The generated rule
-     */
-    protected function createInstallOneOfRule(array $packages, $reason, $job)
-    {
-        $literals = array();
-        foreach ($packages as $package) {
-            $literals[] = $package->id;
-        }
-
-        return new GenericRule($literals, $reason, $job['packageName'], $job);
-    }
-
-    /**
-     * Creates a rule to remove a package
-     *
-     * The rule for a package A is (-A).
-     *
-     * @param  PackageInterface $package The package to be removed
-     * @param  int              $reason  A RULE_* constant describing the
-     *                                   reason for generating this rule
-     * @param  array            $job     The job this rule was created from
-     * @return Rule             The generated rule
-     */
-    protected function createRemoveRule(PackageInterface $package, $reason, $job)
-    {
-        return new GenericRule(array(-$package->id), $reason, $job['packageName'], $job);
-    }
-
-    /**
-     * Creates a rule for two conflicting packages
-     *
-     * The rule for conflicting packages A and B is (-A|-B). A is called the issuer
-     * and B the provider.
-     *
-     * @param  PackageInterface $issuer     The package declaring the conflict
-     * @param  PackageInterface $provider   The package causing the conflict
-     * @param  int              $reason     A RULE_* constant describing the
-     *                                      reason for generating this rule
-     * @param  mixed            $reasonData Any data, e.g. the package name, that
-     *                                      goes with the reason
-     * @return Rule|null             The generated rule
-     */
-    protected function createRule2Literals(PackageInterface $issuer, PackageInterface $provider, $reason, $reasonData = null)
-    {
-        // ignore self conflict
-        if ($issuer === $provider) {
-            return null;
-        }
-
-        return new Rule2Literals(-$issuer->id, -$provider->id, $reason, $reasonData);
-    }
-
-    /**
-     * Adds a rule unless it duplicates an existing one of any type
-     *
-     * To be able to directly pass in the result of one of the rule creation
-     * methods null is allowed which will not insert a rule.
-     *
-     * @param int  $type    A TYPE_* constant defining the rule type
-     * @param Rule $newRule The rule about to be added
-     */
-    private function addRule($type, Rule $newRule = null)
-    {
-        if (!$newRule) {
-            return;
-        }
-
-        $this->rules->add($newRule, $type);
-    }
-
-    protected function whitelistFromPackage(PackageInterface $package)
-    {
-        $workQueue = new \SplQueue;
-        $workQueue->enqueue($package);
-
-        while (!$workQueue->isEmpty()) {
-            $package = $workQueue->dequeue();
-            if (isset($this->whitelistedMap[$package->id])) {
-                continue;
-            }
-
-            $this->whitelistedMap[$package->id] = true;
-
-            foreach ($package->getRequires() as $link) {
-                $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint(), true);
-
-                foreach ($possibleRequires as $require) {
-                    $workQueue->enqueue($require);
-                }
-            }
-
-            $obsoleteProviders = $this->pool->whatProvides($package->getName(), null, true);
-
-            foreach ($obsoleteProviders as $provider) {
-                if ($provider === $package) {
-                    continue;
-                }
-
-                if (($package instanceof AliasPackage) && $package->getAliasOf() === $provider) {
-                    $workQueue->enqueue($provider);
-                }
-            }
-        }
-    }
-
-    protected function addRulesForPackage(PackageInterface $package, $ignorePlatformReqs)
-    {
-        $workQueue = new \SplQueue;
-        $workQueue->enqueue($package);
-
-        while (!$workQueue->isEmpty()) {
-            /** @var PackageInterface $package */
-            $package = $workQueue->dequeue();
-            if (isset($this->addedMap[$package->id])) {
-                continue;
-            }
-
-            $this->addedMap[$package->id] = true;
-
-            $this->addedPackages[] = $package;
-            foreach ($package->getNames() as $name) {
-                $this->addedPackagesByNames[$name][] = $package;
-            }
-
-            foreach ($package->getRequires() as $link) {
-                if ($ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $link->getTarget())) {
-                    continue;
-                }
-
-                $possibleRequires = $this->pool->whatProvides($link->getTarget(), $link->getConstraint());
-
-                $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRequireRule($package, $possibleRequires, Rule::RULE_PACKAGE_REQUIRES, $link));
-
-                foreach ($possibleRequires as $require) {
-                    $workQueue->enqueue($require);
-                }
-            }
-
-            $packageName = $package->getName();
-            $obsoleteProviders = $this->pool->whatProvides($packageName, null);
-
-            foreach ($obsoleteProviders as $provider) {
-                if ($provider === $package) {
-                    continue;
-                }
-
-                if (($package instanceof AliasPackage) && $package->getAliasOf() === $provider) {
-                    $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRequireRule($package, array($provider), Rule::RULE_PACKAGE_ALIAS, $package));
-                } elseif (!$this->obsoleteImpossibleForAlias($package, $provider)) {
-                    $reason = ($packageName == $provider->getName()) ? Rule::RULE_PACKAGE_SAME_NAME : Rule::RULE_PACKAGE_IMPLICIT_OBSOLETES;
-                    $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRule2Literals($package, $provider, $reason, $package));
-                }
-            }
-        }
-    }
-
-    protected function addConflictRules()
-    {
-        /** @var PackageInterface $package */
-        foreach ($this->addedPackages as $package) {
-            foreach ($package->getConflicts() as $link) {
-                if (!isset($this->addedPackagesByNames[$link->getTarget()])) {
-                    continue;
-                }
-
-                /** @var PackageInterface $possibleConflict */
-                foreach ($this->addedPackagesByNames[$link->getTarget()] as $possibleConflict) {
-                    $conflictMatch = $this->pool->match($possibleConflict, $link->getTarget(), $link->getConstraint(), true);
-
-                    if ($conflictMatch === Pool::MATCH || $conflictMatch === Pool::MATCH_REPLACE) {
-                        $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRule2Literals($package, $possibleConflict, Rule::RULE_PACKAGE_CONFLICT, $link));
-                    }
-
-                }
-            }
-
-            // check obsoletes and implicit obsoletes of a package
-            $isInstalled = isset($this->installedMap[$package->id]);
-
-            foreach ($package->getReplaces() as $link) {
-                if (!isset($this->addedPackagesByNames[$link->getTarget()])) {
-                    continue;
-                }
-
-                /** @var PackageInterface $possibleConflict */
-                foreach ($this->addedPackagesByNames[$link->getTarget()] as $provider) {
-                    if ($provider === $package) {
-                        continue;
-                    }
-
-                    if (!$this->obsoleteImpossibleForAlias($package, $provider)) {
-                        $reason = $isInstalled ? Rule::RULE_INSTALLED_PACKAGE_OBSOLETES : Rule::RULE_PACKAGE_OBSOLETES;
-                        $this->addRule(RuleSet::TYPE_PACKAGE, $this->createRule2Literals($package, $provider, $reason, $link));
-                    }
-                }
-            }
-        }
-    }
-
-    protected function obsoleteImpossibleForAlias($package, $provider)
-    {
-        $packageIsAlias = $package instanceof AliasPackage;
-        $providerIsAlias = $provider instanceof AliasPackage;
-
-        $impossible = (
-            ($packageIsAlias && $package->getAliasOf() === $provider) ||
-            ($providerIsAlias && $provider->getAliasOf() === $package) ||
-            ($packageIsAlias && $providerIsAlias && $provider->getAliasOf() === $package->getAliasOf())
-        );
-
-        return $impossible;
-    }
-
-    protected function whitelistFromJobs()
-    {
-        foreach ($this->jobs as $job) {
-            switch ($job['cmd']) {
-                case 'install':
-                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint'], true);
-                    foreach ($packages as $package) {
-                        $this->whitelistFromPackage($package);
-                    }
-                    break;
-            }
-        }
-    }
-
-    protected function addRulesForJobs($ignorePlatformReqs)
-    {
-        foreach ($this->jobs as $job) {
-            switch ($job['cmd']) {
-                case 'install':
-                    if (!$job['fixed'] && $ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $job['packageName'])) {
-                        break;
-                    }
-
-                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
-                    if ($packages) {
-                        foreach ($packages as $package) {
-                            if (!isset($this->installedMap[$package->id])) {
-                                $this->addRulesForPackage($package, $ignorePlatformReqs);
-                            }
-                        }
-
-                        $rule = $this->createInstallOneOfRule($packages, Rule::RULE_JOB_INSTALL, $job);
-                        $this->addRule(RuleSet::TYPE_JOB, $rule);
-                    }
-                    break;
-                case 'remove':
-                    // remove all packages with this name including uninstalled
-                    // ones to make sure none of them are picked as replacements
-                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
-                    foreach ($packages as $package) {
-                        $rule = $this->createRemoveRule($package, Rule::RULE_JOB_REMOVE, $job);
-                        $this->addRule(RuleSet::TYPE_JOB, $rule);
-                    }
-                    break;
-            }
-        }
-    }
-
-    public function getRulesFor($jobs, $installedMap, $ignorePlatformReqs = false)
-    {
-        $this->jobs = $jobs;
-        $this->rules = new RuleSet;
-        $this->installedMap = $installedMap;
-
-        $this->whitelistedMap = array();
-        foreach ($this->installedMap as $package) {
-            $this->whitelistFromPackage($package);
-        }
-        $this->whitelistFromJobs();
-
-        $this->pool->setWhitelist($this->whitelistedMap);
-
-        $this->addedMap = array();
-        $this->conflictAddedMap = array();
-        $this->addedPackages = array();
-        $this->addedPackagesByNames = array();
-        foreach ($this->installedMap as $package) {
-            $this->addRulesForPackage($package, $ignorePlatformReqs);
-        }
-
-        $this->addRulesForJobs($ignorePlatformReqs);
-
-        $this->addConflictRules();
-
-        // Remove references to packages
-        $this->addedPackages = $this->addedPackagesByNames = null;
-
-        return $this->rules;
-    }
-}