dependabot-composer 0.118.13 → 0.119.0.beta1

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

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

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

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

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

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