dependabot-composer 0.119.0.beta1 → 0.119.0

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

data/helpers/vendor/composer/composer/src/Composer/DependencyResolver/RuleWatchNode.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;
-
-/**
- * Wrapper around a Rule which keeps track of the two literals it watches
- *
- * Used by RuleWatchGraph to store rules in two RuleWatchChains.
- *
- * @author Nils Adermann <naderman@naderman.de>
- */
-class RuleWatchNode
-{
-    public $watch1;
-    public $watch2;
-
-    protected $rule;
-
-    /**
-     * Creates a new node watching the first and second literals of the rule.
-     *
-     * @param Rule $rule The rule to wrap
-     */
-    public function __construct($rule)
-    {
-        $this->rule = $rule;
-
-        $literals = $rule->getLiterals();
-
-        $literalCount = count($literals);
-        $this->watch1 = $literalCount > 0 ? $literals[0] : 0;
-        $this->watch2 = $literalCount > 1 ? $literals[1] : 0;
-    }
-
-    /**
-     * Places the second watch on the rule's literal, decided at the highest level
-     *
-     * Useful for learned rules where the literal for the highest rule is most
-     * likely to quickly lead to further decisions.
-     *
-     * @param Decisions $decisions The decisions made so far by the solver
-     */
-    public function watch2OnHighest(Decisions $decisions)
-    {
-        $literals = $this->rule->getLiterals();
-
-        // if there are only 2 elements, both are being watched anyway
-        if (count($literals) < 3) {
-            return;
-        }
-
-        $watchLevel = 0;
-
-        foreach ($literals as $literal) {
-            $level = $decisions->decisionLevel($literal);
-
-            if ($level > $watchLevel) {
-                $this->watch2 = $literal;
-                $watchLevel = $level;
-            }
-        }
-    }
-
-    /**
-     * Returns the rule this node wraps
-     *
-     * @return Rule
-     */
-    public function getRule()
-    {
-        return $this->rule;
-    }
-
-    /**
-     * Given one watched literal, this method returns the other watched literal
-     *
-     * @param  int $literal The watched literal that should not be returned
-     * @return int A literal
-     */
-    public function getOtherWatch($literal)
-    {
-        if ($this->watch1 == $literal) {
-            return $this->watch2;
-        }
-
-        return $this->watch1;
-    }
-
-    /**
-     * Moves a watch from one literal to another
-     *
-     * @param int $from The previously watched literal
-     * @param int $to   The literal to be watched now
-     */
-    public function moveWatch($from, $to)
-    {
-        if ($this->watch1 == $from) {
-            $this->watch1 = $to;
-        } else {
-            $this->watch2 = $to;
-        }
-    }
-}

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

@@ -1,872 +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\IO\IOInterface;
-use Composer\Repository\RepositoryInterface;
-use Composer\Repository\PlatformRepository;
-
-/**
- * @author Nils Adermann <naderman@naderman.de>
- */
-class Solver
-{
-    const BRANCH_LITERALS = 0;
-    const BRANCH_LEVEL = 1;
-
-    /** @var PolicyInterface */
-    protected $policy;
-    /** @var Pool */
-    protected $pool;
-    /** @var RepositoryInterface */
-    protected $installed;
-    /** @var RuleSet */
-    protected $rules;
-    /** @var RuleSetGenerator */
-    protected $ruleSetGenerator;
-    /** @var array */
-    protected $jobs;
-
-    /** @var int[] */
-    protected $updateMap = array();
-    /** @var RuleWatchGraph */
-    protected $watchGraph;
-    /** @var Decisions */
-    protected $decisions;
-    /** @var int[] */
-    protected $installedMap;
-
-    /** @var int */
-    protected $propagateIndex;
-    /** @var array[] */
-    protected $branches = array();
-    /** @var Problem[] */
-    protected $problems = array();
-    /** @var array */
-    protected $learnedPool = array();
-    /** @var array */
-    protected $learnedWhy = array();
-
-    /** @var bool */
-    public $testFlagLearnedPositiveLiteral = false;
-
-    /** @var IOInterface */
-    protected $io;
-
-    /**
-     * @param PolicyInterface     $policy
-     * @param Pool                $pool
-     * @param RepositoryInterface $installed
-     * @param IOInterface         $io
-     */
-    public function __construct(PolicyInterface $policy, Pool $pool, RepositoryInterface $installed, IOInterface $io)
-    {
-        $this->io = $io;
-        $this->policy = $policy;
-        $this->pool = $pool;
-        $this->installed = $installed;
-        $this->ruleSetGenerator = new RuleSetGenerator($policy, $pool);
-    }
-
-    /**
-     * @return int
-     */
-    public function getRuleSetSize()
-    {
-        return count($this->rules);
-    }
-
-    // aka solver_makeruledecisions
-
-    private function makeAssertionRuleDecisions()
-    {
-        $decisionStart = count($this->decisions) - 1;
-
-        $rulesCount = count($this->rules);
-        for ($ruleIndex = 0; $ruleIndex < $rulesCount; $ruleIndex++) {
-            $rule = $this->rules->ruleById[$ruleIndex];
-
-            if (!$rule->isAssertion() || $rule->isDisabled()) {
-                continue;
-            }
-
-            $literals = $rule->getLiterals();
-            $literal = $literals[0];
-
-            if (!$this->decisions->decided($literal)) {
-                $this->decisions->decide($literal, 1, $rule);
-                continue;
-            }
-
-            if ($this->decisions->satisfy($literal)) {
-                continue;
-            }
-
-            // found a conflict
-            if (RuleSet::TYPE_LEARNED === $rule->getType()) {
-                $rule->disable();
-                continue;
-            }
-
-            $conflict = $this->decisions->decisionRule($literal);
-
-            if ($conflict && RuleSet::TYPE_PACKAGE === $conflict->getType()) {
-                $problem = new Problem($this->pool);
-
-                $problem->addRule($rule);
-                $problem->addRule($conflict);
-                $this->disableProblem($rule);
-                $this->problems[] = $problem;
-                continue;
-            }
-
-            // conflict with another job
-            $problem = new Problem($this->pool);
-            $problem->addRule($rule);
-            $problem->addRule($conflict);
-
-            // push all of our rules (can only be job rules)
-            // asserting this literal on the problem stack
-            foreach ($this->rules->getIteratorFor(RuleSet::TYPE_JOB) as $assertRule) {
-                if ($assertRule->isDisabled() || !$assertRule->isAssertion()) {
-                    continue;
-                }
-
-                $assertRuleLiterals = $assertRule->getLiterals();
-                $assertRuleLiteral = $assertRuleLiterals[0];
-
-                if (abs($literal) !== abs($assertRuleLiteral)) {
-                    continue;
-                }
-
-                $problem->addRule($assertRule);
-                $this->disableProblem($assertRule);
-            }
-            $this->problems[] = $problem;
-
-            $this->decisions->resetToOffset($decisionStart);
-            $ruleIndex = -1;
-        }
-    }
-
-    protected function setupInstalledMap()
-    {
-        $this->installedMap = array();
-        foreach ($this->installed->getPackages() as $package) {
-            $this->installedMap[$package->id] = $package;
-        }
-    }
-
-    /**
-     * @param bool $ignorePlatformReqs
-     */
-    protected function checkForRootRequireProblems($ignorePlatformReqs)
-    {
-        foreach ($this->jobs as $job) {
-            switch ($job['cmd']) {
-                case 'update':
-                    $packages = $this->pool->whatProvides($job['packageName'], $job['constraint']);
-                    foreach ($packages as $package) {
-                        if (isset($this->installedMap[$package->id])) {
-                            $this->updateMap[$package->id] = true;
-                        }
-                    }
-                    break;
-
-                case 'update-all':
-                    foreach ($this->installedMap as $package) {
-                        $this->updateMap[$package->id] = true;
-                    }
-                    break;
-
-                case 'install':
-                    if ($ignorePlatformReqs && preg_match(PlatformRepository::PLATFORM_PACKAGE_REGEX, $job['packageName'])) {
-                        break;
-                    }
-
-                    if (!$this->pool->whatProvides($job['packageName'], $job['constraint'])) {
-                        $problem = new Problem($this->pool);
-                        $problem->addRule(new GenericRule(array(), null, null, $job));
-                        $this->problems[] = $problem;
-                    }
-                    break;
-            }
-        }
-    }
-
-    /**
-     * @param  Request $request
-     * @param  bool    $ignorePlatformReqs
-     * @return array
-     */
-    public function solve(Request $request, $ignorePlatformReqs = false)
-    {
-        $this->jobs = $request->getJobs();
-
-        $this->setupInstalledMap();
-        $this->rules = $this->ruleSetGenerator->getRulesFor($this->jobs, $this->installedMap, $ignorePlatformReqs);
-        $this->checkForRootRequireProblems($ignorePlatformReqs);
-        $this->decisions = new Decisions($this->pool);
-        $this->watchGraph = new RuleWatchGraph;
-
-        foreach ($this->rules as $rule) {
-            $this->watchGraph->insert(new RuleWatchNode($rule));
-        }
-
-        /* make decisions based on job/update assertions */
-        $this->makeAssertionRuleDecisions();
-
-        $this->io->writeError('Resolving dependencies through SAT', true, IOInterface::DEBUG);
-        $before = microtime(true);
-        $this->runSat(true);
-        $this->io->writeError('', true, IOInterface::DEBUG);
-        $this->io->writeError(sprintf('Dependency resolution completed in %.3f seconds', microtime(true) - $before), true, IOInterface::VERBOSE);
-
-        // decide to remove everything that's installed and undecided
-        foreach ($this->installedMap as $packageId => $void) {
-            if ($this->decisions->undecided($packageId)) {
-                $this->decisions->decide(-$packageId, 1, null);
-            }
-        }
-
-        if ($this->problems) {
-            throw new SolverProblemsException($this->problems, $this->installedMap);
-        }
-
-        $transaction = new Transaction($this->policy, $this->pool, $this->installedMap, $this->decisions);
-
-        return $transaction->getOperations();
-    }
-
-    /**
-     * Makes a decision and propagates it to all rules.
-     *
-     * Evaluates each term affected by the decision (linked through watches)
-     * If we find unit rules we make new decisions based on them
-     *
-     * @param  int       $level
-     * @return Rule|null A rule on conflict, otherwise null.
-     */
-    protected function propagate($level)
-    {
-        while ($this->decisions->validOffset($this->propagateIndex)) {
-            $decision = $this->decisions->atOffset($this->propagateIndex);
-
-            $conflict = $this->watchGraph->propagateLiteral(
-                $decision[Decisions::DECISION_LITERAL],
-                $level,
-                $this->decisions
-            );
-
-            $this->propagateIndex++;
-
-            if ($conflict) {
-                return $conflict;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Reverts a decision at the given level.
-     *
-     * @param int $level
-     */
-    private function revert($level)
-    {
-        while (!$this->decisions->isEmpty()) {
-            $literal = $this->decisions->lastLiteral();
-
-            if ($this->decisions->undecided($literal)) {
-                break;
-            }
-
-            $decisionLevel = $this->decisions->decisionLevel($literal);
-
-            if ($decisionLevel <= $level) {
-                break;
-            }
-
-            $this->decisions->revertLast();
-            $this->propagateIndex = count($this->decisions);
-        }
-
-        while (!empty($this->branches) && $this->branches[count($this->branches) - 1][self::BRANCH_LEVEL] >= $level) {
-            array_pop($this->branches);
-        }
-    }
-
-    /**
-     * setpropagatelearn
-     *
-     * add free decision (a positive literal) to decision queue
-     * increase level and propagate decision
-     * return if no conflict.
-     *
-     * in conflict case, analyze conflict rule, add resulting
-     * rule to learnt rule set, make decision from learnt
-     * rule (always unit) and re-propagate.
-     *
-     * returns the new solver level or 0 if unsolvable
-     *
-     * @param  int        $level
-     * @param  string|int $literal
-     * @param  bool       $disableRules
-     * @param  Rule       $rule
-     * @return int
-     */
-    private function setPropagateLearn($level, $literal, $disableRules, Rule $rule)
-    {
-        $level++;
-
-        $this->decisions->decide($literal, $level, $rule);
-
-        while (true) {
-            $rule = $this->propagate($level);
-
-            if (!$rule) {
-                break;
-            }
-
-            if ($level == 1) {
-                return $this->analyzeUnsolvable($rule, $disableRules);
-            }
-
-            // conflict
-            list($learnLiteral, $newLevel, $newRule, $why) = $this->analyze($level, $rule);
-
-            if ($newLevel <= 0 || $newLevel >= $level) {
-                throw new SolverBugException(
-                    "Trying to revert to invalid level ".(int) $newLevel." from level ".(int) $level."."
-                );
-            } elseif (!$newRule) {
-                throw new SolverBugException(
-                    "No rule was learned from analyzing $rule at level $level."
-                );
-            }
-
-            $level = $newLevel;
-
-            $this->revert($level);
-
-            $this->rules->add($newRule, RuleSet::TYPE_LEARNED);
-
-            $this->learnedWhy[spl_object_hash($newRule)] = $why;
-
-            $ruleNode = new RuleWatchNode($newRule);
-            $ruleNode->watch2OnHighest($this->decisions);
-            $this->watchGraph->insert($ruleNode);
-
-            $this->decisions->decide($learnLiteral, $level, $newRule);
-        }
-
-        return $level;
-    }
-
-    /**
-     * @param  int   $level
-     * @param  array $decisionQueue
-     * @param  bool  $disableRules
-     * @param  Rule  $rule
-     * @return int
-     */
-    private function selectAndInstall($level, array $decisionQueue, $disableRules, Rule $rule)
-    {
-        // choose best package to install from decisionQueue
-        $literals = $this->policy->selectPreferredPackages($this->pool, $this->installedMap, $decisionQueue, $rule->getRequiredPackage());
-
-        $selectedLiteral = array_shift($literals);
-
-        // if there are multiple candidates, then branch
-        if (count($literals)) {
-            $this->branches[] = array($literals, $level);
-        }
-
-        return $this->setPropagateLearn($level, $selectedLiteral, $disableRules, $rule);
-    }
-
-    /**
-     * @param  int   $level
-     * @param  Rule  $rule
-     * @return array
-     */
-    protected function analyze($level, Rule $rule)
-    {
-        $analyzedRule = $rule;
-        $ruleLevel = 1;
-        $num = 0;
-        $l1num = 0;
-        $seen = array();
-        $learnedLiterals = array(null);
-
-        $decisionId = count($this->decisions);
-
-        $this->learnedPool[] = array();
-
-        while (true) {
-            $this->learnedPool[count($this->learnedPool) - 1][] = $rule;
-
-            foreach ($rule->getLiterals() as $literal) {
-                // skip the one true literal
-                if ($this->decisions->satisfy($literal)) {
-                    continue;
-                }
-
-                if (isset($seen[abs($literal)])) {
-                    continue;
-                }
-                $seen[abs($literal)] = true;
-
-                $l = $this->decisions->decisionLevel($literal);
-
-                if (1 === $l) {
-                    $l1num++;
-                } elseif ($level === $l) {
-                    $num++;
-                } else {
-                    // not level1 or conflict level, add to new rule
-                    $learnedLiterals[] = $literal;
-
-                    if ($l > $ruleLevel) {
-                        $ruleLevel = $l;
-                    }
-                }
-            }
-
-            $l1retry = true;
-            while ($l1retry) {
-                $l1retry = false;
-
-                if (!$num && !--$l1num) {
-                    // all level 1 literals done
-                    break 2;
-                }
-
-                while (true) {
-                    if ($decisionId <= 0) {
-                        throw new SolverBugException(
-                            "Reached invalid decision id $decisionId while looking through $rule for a literal present in the analyzed rule $analyzedRule."
-                        );
-                    }
-
-                    $decisionId--;
-
-                    $decision = $this->decisions->atOffset($decisionId);
-                    $literal = $decision[Decisions::DECISION_LITERAL];
-
-                    if (isset($seen[abs($literal)])) {
-                        break;
-                    }
-                }
-
-                unset($seen[abs($literal)]);
-
-                if ($num && 0 === --$num) {
-                    if ($literal < 0) {
-                        $this->testFlagLearnedPositiveLiteral = true;
-                    }
-                    $learnedLiterals[0] = -$literal;
-
-                    if (!$l1num) {
-                        break 2;
-                    }
-
-                    foreach ($learnedLiterals as $i => $learnedLiteral) {
-                        if ($i !== 0) {
-                            unset($seen[abs($learnedLiteral)]);
-                        }
-                    }
-                    // only level 1 marks left
-                    $l1num++;
-                    $l1retry = true;
-                }
-            }
-
-            $decision = $this->decisions->atOffset($decisionId);
-            $rule = $decision[Decisions::DECISION_REASON];
-        }
-
-        $why = count($this->learnedPool) - 1;
-
-        if (!$learnedLiterals[0]) {
-            throw new SolverBugException(
-                "Did not find a learnable literal in analyzed rule $analyzedRule."
-            );
-        }
-
-        $newRule = new GenericRule($learnedLiterals, Rule::RULE_LEARNED, $why);
-
-        return array($learnedLiterals[0], $ruleLevel, $newRule, $why);
-    }
-
-    /**
-     * @param Problem $problem
-     * @param Rule    $conflictRule
-     */
-    private function analyzeUnsolvableRule(Problem $problem, Rule $conflictRule)
-    {
-        if ($conflictRule->getType() == RuleSet::TYPE_LEARNED) {
-            $why = spl_object_hash($conflictRule);
-            $learnedWhy = $this->learnedWhy[$why];
-            $problemRules = $this->learnedPool[$learnedWhy];
-
-            foreach ($problemRules as $problemRule) {
-                $this->analyzeUnsolvableRule($problem, $problemRule);
-            }
-
-            return;
-        }
-
-        if ($conflictRule->getType() == RuleSet::TYPE_PACKAGE) {
-            // package rules cannot be part of a problem
-            return;
-        }
-
-        $problem->nextSection();
-        $problem->addRule($conflictRule);
-    }
-
-    /**
-     * @param  Rule $conflictRule
-     * @param  bool $disableRules
-     * @return int
-     */
-    private function analyzeUnsolvable(Rule $conflictRule, $disableRules)
-    {
-        $problem = new Problem($this->pool);
-        $problem->addRule($conflictRule);
-
-        $this->analyzeUnsolvableRule($problem, $conflictRule);
-
-        $this->problems[] = $problem;
-
-        $seen = array();
-        $literals = $conflictRule->getLiterals();
-
-        foreach ($literals as $literal) {
-            // skip the one true literal
-            if ($this->decisions->satisfy($literal)) {
-                continue;
-            }
-            $seen[abs($literal)] = true;
-        }
-
-        foreach ($this->decisions as $decision) {
-            $literal = $decision[Decisions::DECISION_LITERAL];
-
-            // skip literals that are not in this rule
-            if (!isset($seen[abs($literal)])) {
-                continue;
-            }
-
-            $why = $decision[Decisions::DECISION_REASON];
-
-            $problem->addRule($why);
-            $this->analyzeUnsolvableRule($problem, $why);
-
-            $literals = $why->getLiterals();
-
-            foreach ($literals as $literal) {
-                // skip the one true literal
-                if ($this->decisions->satisfy($literal)) {
-                    continue;
-                }
-                $seen[abs($literal)] = true;
-            }
-        }
-
-        if ($disableRules) {
-            foreach ($this->problems[count($this->problems) - 1] as $reason) {
-                $this->disableProblem($reason['rule']);
-            }
-
-            $this->resetSolver();
-
-            return 1;
-        }
-
-        return 0;
-    }
-
-    /**
-     * @param Rule $why
-     */
-    private function disableProblem(Rule $why)
-    {
-        $job = $why->getJob();
-
-        if (!$job) {
-            $why->disable();
-
-            return;
-        }
-
-        // disable all rules of this job
-        foreach ($this->rules as $rule) {
-            /** @var Rule $rule */
-            if ($job === $rule->getJob()) {
-                $rule->disable();
-            }
-        }
-    }
-
-    private function resetSolver()
-    {
-        $this->decisions->reset();
-
-        $this->propagateIndex = 0;
-        $this->branches = array();
-
-        $this->enableDisableLearnedRules();
-        $this->makeAssertionRuleDecisions();
-    }
-
-    /**
-     * enable/disable learnt rules
-     *
-     * we have enabled or disabled some of our rules. We now re-enable all
-     * of our learnt rules except the ones that were learnt from rules that
-     * are now disabled.
-     */
-    private function enableDisableLearnedRules()
-    {
-        foreach ($this->rules->getIteratorFor(RuleSet::TYPE_LEARNED) as $rule) {
-            $why = $this->learnedWhy[spl_object_hash($rule)];
-            $problemRules = $this->learnedPool[$why];
-
-            $foundDisabled = false;
-            foreach ($problemRules as $problemRule) {
-                if ($problemRule->isDisabled()) {
-                    $foundDisabled = true;
-                    break;
-                }
-            }
-
-            if ($foundDisabled && $rule->isEnabled()) {
-                $rule->disable();
-            } elseif (!$foundDisabled && $rule->isDisabled()) {
-                $rule->enable();
-            }
-        }
-    }
-
-    /**
-     * @param bool $disableRules
-     */
-    private function runSat($disableRules = true)
-    {
-        $this->propagateIndex = 0;
-
-        /*
-         * here's the main loop:
-         * 1) propagate new decisions (only needed once)
-         * 2) fulfill jobs
-         * 3) fulfill all unresolved rules
-         * 4) minimalize solution if we had choices
-         * if we encounter a problem, we rewind to a safe level and restart
-         * with step 1
-         */
-
-        $decisionQueue = array();
-        /**
-         * @todo this makes $disableRules always false; determine the rationale and possibly remove dead code?
-         */
-        $disableRules = array();
-
-        $level = 1;
-        $systemLevel = $level + 1;
-
-        while (true) {
-            if (1 === $level) {
-                $conflictRule = $this->propagate($level);
-                if (null !== $conflictRule) {
-                    if ($this->analyzeUnsolvable($conflictRule, $disableRules)) {
-                        continue;
-                    }
-
-                    return;
-                }
-            }
-
-            // handle job rules
-            if ($level < $systemLevel) {
-                $iterator = $this->rules->getIteratorFor(RuleSet::TYPE_JOB);
-                foreach ($iterator as $rule) {
-                    if ($rule->isEnabled()) {
-                        $decisionQueue = array();
-                        $noneSatisfied = true;
-
-                        foreach ($rule->getLiterals() as $literal) {
-                            if ($this->decisions->satisfy($literal)) {
-                                $noneSatisfied = false;
-                                break;
-                            }
-                            if ($literal > 0 && $this->decisions->undecided($literal)) {
-                                $decisionQueue[] = $literal;
-                            }
-                        }
-
-                        if ($noneSatisfied && count($decisionQueue)) {
-                            // prune all update packages until installed version
-                            // except for requested updates
-                            if (count($this->installed) != count($this->updateMap)) {
-                                $prunedQueue = array();
-                                foreach ($decisionQueue as $literal) {
-                                    if (isset($this->installedMap[abs($literal)])) {
-                                        $prunedQueue[] = $literal;
-                                        if (isset($this->updateMap[abs($literal)])) {
-                                            $prunedQueue = $decisionQueue;
-                                            break;
-                                        }
-                                    }
-                                }
-                                $decisionQueue = $prunedQueue;
-                            }
-                        }
-
-                        if ($noneSatisfied && count($decisionQueue)) {
-                            $oLevel = $level;
-                            $level = $this->selectAndInstall($level, $decisionQueue, $disableRules, $rule);
-
-                            if (0 === $level) {
-                                return;
-                            }
-                            if ($level <= $oLevel) {
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                $systemLevel = $level + 1;
-
-                // jobs left
-                $iterator->next();
-                if ($iterator->valid()) {
-                    continue;
-                }
-            }
-
-            if ($level < $systemLevel) {
-                $systemLevel = $level;
-            }
-
-            $rulesCount = count($this->rules);
-            $pass = 1;
-
-            $this->io->writeError('Looking at all rules.', true, IOInterface::DEBUG);
-            for ($i = 0, $n = 0; $n < $rulesCount; $i++, $n++) {
-                if ($i == $rulesCount) {
-                    if (1 === $pass) {
-                        $this->io->writeError("Something's changed, looking at all rules again (pass #$pass)", false, IOInterface::DEBUG);
-                    } else {
-                        $this->io->overwriteError("Something's changed, looking at all rules again (pass #$pass)", false, null, IOInterface::DEBUG);
-                    }
-
-                    $i = 0;
-                    $pass++;
-                }
-
-                $rule = $this->rules->ruleById[$i];
-                $literals = $rule->getLiterals();
-
-                if ($rule->isDisabled()) {
-                    continue;
-                }
-
-                $decisionQueue = array();
-
-                // make sure that
-                // * all negative literals are installed
-                // * no positive literal is installed
-                // i.e. the rule is not fulfilled and we
-                // just need to decide on the positive literals
-                //
-                foreach ($literals as $literal) {
-                    if ($literal <= 0) {
-                        if (!$this->decisions->decidedInstall($literal)) {
-                            continue 2; // next rule
-                        }
-                    } else {
-                        if ($this->decisions->decidedInstall($literal)) {
-                            continue 2; // next rule
-                        }
-                        if ($this->decisions->undecided($literal)) {
-                            $decisionQueue[] = $literal;
-                        }
-                    }
-                }
-
-                // need to have at least 2 item to pick from
-                if (count($decisionQueue) < 2) {
-                    continue;
-                }
-
-                $level = $this->selectAndInstall($level, $decisionQueue, $disableRules, $rule);
-
-                if (0 === $level) {
-                    return;
-                }
-
-                // something changed, so look at all rules again
-                $rulesCount = count($this->rules);
-                $n = -1;
-            }
-
-            if ($level < $systemLevel) {
-                continue;
-            }
-
-            // minimization step
-            if (count($this->branches)) {
-                $lastLiteral = null;
-                $lastLevel = null;
-                $lastBranchIndex = 0;
-                $lastBranchOffset = 0;
-
-                for ($i = count($this->branches) - 1; $i >= 0; $i--) {
-                    list($literals, $l) = $this->branches[$i];
-
-                    foreach ($literals as $offset => $literal) {
-                        if ($literal && $literal > 0 && $this->decisions->decisionLevel($literal) > $l + 1) {
-                            $lastLiteral = $literal;
-                            $lastBranchIndex = $i;
-                            $lastBranchOffset = $offset;
-                            $lastLevel = $l;
-                        }
-                    }
-                }
-
-                if ($lastLiteral) {
-                    unset($this->branches[$lastBranchIndex][self::BRANCH_LITERALS][$lastBranchOffset]);
-
-                    $level = $lastLevel;
-                    $this->revert($level);
-
-                    $why = $this->decisions->lastReason();
-
-                    $level = $this->setPropagateLearn($level, $lastLiteral, $disableRules, $why);
-
-                    if ($level == 0) {
-                        return;
-                    }
-
-                    continue;
-                }
-            }
-
-            break;
-        }
-    }
-}