dependabot-composer 0.95.47 → 0.95.48

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;
-    }
-}

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

@@ -1,94 +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 RuleSetIterator implements \Iterator
-{
-    protected $rules;
-    protected $types;
-
-    protected $currentOffset;
-    protected $currentType;
-    protected $currentTypeOffset;
-
-    public function __construct(array $rules)
-    {
-        $this->rules = $rules;
-        $this->types = array_keys($rules);
-        sort($this->types);
-
-        $this->rewind();
-    }
-
-    public function current()
-    {
-        return $this->rules[$this->currentType][$this->currentOffset];
-    }
-
-    public function key()
-    {
-        return $this->currentType;
-    }
-
-    public function next()
-    {
-        $this->currentOffset++;
-
-        if (!isset($this->rules[$this->currentType])) {
-            return;
-        }
-
-        if ($this->currentOffset >= count($this->rules[$this->currentType])) {
-            $this->currentOffset = 0;
-
-            do {
-                $this->currentTypeOffset++;
-
-                if (!isset($this->types[$this->currentTypeOffset])) {
-                    $this->currentType = -1;
-                    break;
-                }
-
-                $this->currentType = $this->types[$this->currentTypeOffset];
-            } while (isset($this->types[$this->currentTypeOffset]) && !count($this->rules[$this->currentType]));
-        }
-    }
-
-    public function rewind()
-    {
-        $this->currentOffset = 0;
-
-        $this->currentTypeOffset = -1;
-        $this->currentType = -1;
-
-        do {
-            $this->currentTypeOffset++;
-
-            if (!isset($this->types[$this->currentTypeOffset])) {
-                $this->currentType = -1;
-                break;
-            }
-
-            $this->currentType = $this->types[$this->currentTypeOffset];
-        } while (isset($this->types[$this->currentTypeOffset]) && !count($this->rules[$this->currentType]));
-    }
-
-    public function valid()
-    {
-        return isset($this->rules[$this->currentType])
-               && isset($this->rules[$this->currentType][$this->currentOffset]);
-    }
-}

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

@@ -1,52 +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;
-
-/**
- * An extension of SplDoublyLinkedList with seek and removal of current element
- *
- * SplDoublyLinkedList only allows deleting a particular offset and has no
- * method to set the internal iterator to a particular offset.
- *
- * @author Nils Adermann <naderman@naderman.de>
- */
-class RuleWatchChain extends \SplDoublyLinkedList
-{
-    protected $offset = 0;
-
-    /**
-     * Moves the internal iterator to the specified offset
-     *
-     * @param int $offset The offset to seek to.
-     */
-    public function seek($offset)
-    {
-        $this->rewind();
-        for ($i = 0; $i < $offset; $i++, $this->next());
-    }
-
-    /**
-     * Removes the current element from the list
-     *
-     * As SplDoublyLinkedList only allows deleting a particular offset and
-     * incorrectly sets the internal iterator if you delete the current value
-     * this method sets the internal iterator back to the following element
-     * using the seek method.
-     */
-    public function remove()
-    {
-        $offset = $this->key();
-        $this->offsetUnset($offset);
-        $this->seek($offset);
-    }
-}

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

@@ -1,144 +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;
-
-/**
- * The RuleWatchGraph efficiently propagates decisions to other rules
- *
- * All rules generated for solving a SAT problem should be inserted into the
- * graph. When a decision on a literal is made, the graph can be used to
- * propagate the decision to all other rules involving the literal, leading to
- * other trivial decisions resulting from unit clauses.
- *
- * @author Nils Adermann <naderman@naderman.de>
- */
-class RuleWatchGraph
-{
-    protected $watchChains = array();
-
-    /**
-     * Inserts a rule node into the appropriate chains within the graph
-     *
-     * The node is prepended to the watch chains for each of the two literals it
-     * watches.
-     *
-     * Assertions are skipped because they only depend on a single package and
-     * have no alternative literal that could be true, so there is no need to
-     * watch changes in any literals.
-     *
-     * @param RuleWatchNode $node The rule node to be inserted into the graph
-     */
-    public function insert(RuleWatchNode $node)
-    {
-        if ($node->getRule()->isAssertion()) {
-            return;
-        }
-
-        foreach (array($node->watch1, $node->watch2) as $literal) {
-            if (!isset($this->watchChains[$literal])) {
-                $this->watchChains[$literal] = new RuleWatchChain;
-            }
-
-            $this->watchChains[$literal]->unshift($node);
-        }
-    }
-
-    /**
-     * Propagates a decision on a literal to all rules watching the literal
-     *
-     * If a decision, e.g. +A has been made, then all rules containing -A, e.g.
-     * (-A|+B|+C) now need to satisfy at least one of the other literals, so
-     * that the rule as a whole becomes true, since with +A applied the rule
-     * is now (false|+B|+C) so essentially (+B|+C).
-     *
-     * This means that all rules watching the literal -A need to be updated to
-     * watch 2 other literals which can still be satisfied instead. So literals
-     * that conflict with previously made decisions are not an option.
-     *
-     * Alternatively it can occur that a unit clause results: e.g. if in the
-     * above example the rule was (-A|+B), then A turning true means that
-     * B must now be decided true as well.
-     *
-     * @param  int       $decidedLiteral The literal which was decided (A in our example)
-     * @param  int       $level          The level at which the decision took place and at which
-     *                                   all resulting decisions should be made.
-     * @param  Decisions $decisions      Used to check previous decisions and to
-     *                                   register decisions resulting from propagation
-     * @return Rule|null If a conflict is found the conflicting rule is returned
-     */
-    public function propagateLiteral($decidedLiteral, $level, $decisions)
-    {
-        // we invert the decided literal here, example:
-        // A was decided => (-A|B) now requires B to be true, so we look for
-        // rules which are fulfilled by -A, rather than A.
-        $literal = -$decidedLiteral;
-
-        if (!isset($this->watchChains[$literal])) {
-            return null;
-        }
-
-        $chain = $this->watchChains[$literal];
-
-        $chain->rewind();
-        while ($chain->valid()) {
-            $node = $chain->current();
-            $otherWatch = $node->getOtherWatch($literal);
-
-            if (!$node->getRule()->isDisabled() && !$decisions->satisfy($otherWatch)) {
-                $ruleLiterals = $node->getRule()->getLiterals();
-
-                $alternativeLiterals = array_filter($ruleLiterals, function ($ruleLiteral) use ($literal, $otherWatch, $decisions) {
-                    return $literal !== $ruleLiteral &&
-                        $otherWatch !== $ruleLiteral &&
-                        !$decisions->conflict($ruleLiteral);
-                });
-
-                if ($alternativeLiterals) {
-                    reset($alternativeLiterals);
-                    $this->moveWatch($literal, current($alternativeLiterals), $node);
-                    continue;
-                }
-
-                if ($decisions->conflict($otherWatch)) {
-                    return $node->getRule();
-                }
-
-                $decisions->decide($otherWatch, $level, $node->getRule());
-            }
-
-            $chain->next();
-        }
-
-        return null;
-    }
-
-    /**
-     * Moves a rule node from one watch chain to another
-     *
-     * The rule node's watched literals are updated accordingly.
-     *
-     * @param int           $fromLiteral A literal the node used to watch
-     * @param int           $toLiteral A literal the node should watch now
-     * @param RuleWatchNode $node The rule node to be moved
-     */
-    protected function moveWatch($fromLiteral, $toLiteral, $node)
-    {
-        if (!isset($this->watchChains[$toLiteral])) {
-            $this->watchChains[$toLiteral] = new RuleWatchChain;
-        }
-
-        $node->moveWatch($fromLiteral, $toLiteral);
-        $this->watchChains[$fromLiteral]->remove();
-        $this->watchChains[$toLiteral]->unshift($node);
-    }
-}