pub_grub 0.1.0

data/lib/pub_grub/incompatibility.rb

@@ -0,0 +1,109 @@
+module PubGrub
+  class Incompatibility
+    ConflictCause = Struct.new(:incompatibility, :satisfier) do
+      alias_method :conflict, :incompatibility
+      alias_method :other, :satisfier
+    end
+
+    attr_reader :terms, :cause
+
+    def initialize(terms, cause:)
+      @cause = cause
+      @terms = cleanup_terms(terms)
+    end
+
+    def failure?
+      terms.empty? || (terms.length == 1 && terms[0].package == Package.root && terms[0].positive?)
+    end
+
+    def conflict?
+      ConflictCause === cause
+    end
+
+    # Returns all external incompatibilities in this incompatibility's
+    # derivation graph
+    def external_incompatibilities
+      if conflict?
+        [
+          cause.conflict,
+          cause.other
+        ].flat_map(&:external_incompatibilities)
+      else
+        [this]
+      end
+    end
+
+    def to_s
+      case cause
+      when :dependency
+        raise unless terms.length == 2
+        "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
+      else
+        if failure?
+          "version solving has failed"
+        elsif terms.length == 1
+          term = terms[0]
+          if term.positive?
+            "#{terms[0].to_s(allow_every: true)} is forbidden"
+          else
+            "#{terms[0].invert} is required"
+          end
+        else
+          if terms.all?(&:positive?)
+            if terms.length == 2
+              "#{terms[0].to_s(allow_every: true)} is incompatible with #{terms[1]}"
+            else
+              "one of #{terms.map(&:to_s).join(" or ")} must be false"
+            end
+          elsif terms.all?(&:negative?)
+            if terms.length == 2
+              "either #{terms[0].invert} or #{terms[1].invert}"
+            else
+              "one of #{terms.map(&:invert).join(" or ")} must be true";
+            end
+          else
+            positive = terms.select(&:positive?)
+            negative = terms.select(&:negative?).map(&:invert)
+
+            if positive.length == 1
+              "#{positive[0].to_s(allow_every: true)} requires #{negative.join(" or ")}"
+            else
+              "if #{positive.join(" and ")} then #{negative.join(" or ")}"
+            end
+          end
+        end
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    private
+
+    def cleanup_terms(terms)
+      terms.each do |term|
+        raise "#{term.inspect} must be a term" unless term.is_a?(Term)
+      end
+
+      if terms.length != 1 && ConflictCause === cause
+        terms = terms.reject do |term|
+          term.positive? && term.package == Package.root
+        end
+      end
+
+      # Optimized simple cases
+      return terms if terms.length <= 1
+      return terms if terms.length == 2 && terms[0].package != terms[1].package
+
+      terms.group_by(&:package).map do |package, common_terms|
+        term =
+          common_terms.inject do |acc, term|
+          acc.intersect(term)
+        end
+
+        term
+      end
+    end
+  end
+end

data/lib/pub_grub/package.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PubGrub
+  class Package
+    class Version
+      attr_reader :package, :id, :name
+
+      def initialize(package, id, name)
+        @package = package
+        @id = id
+        @name = name
+      end
+
+      def to_s
+        name
+      end
+
+      def inspect
+        "#<#{self.class} #{package.name} #{name} (#{id})>"
+      end
+
+      def <=>(other)
+        [package, id] <=> [other.package, other.id]
+      end
+    end
+
+    attr_reader :name, :versions
+
+    def initialize(name)
+      @name = name
+      @versions = []
+      yield self if block_given?
+    end
+
+    def version(version)
+      @versions.detect { |v| v.name == version } ||
+        raise("No such version of #{name.inspect}: #{version.inspect}")
+    end
+    alias_method :[], :version
+
+    def add_version(name)
+      Version.new(self, @versions.length, name).tap do |version|
+        @versions << version
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{name.inspect} (#{versions.count} versions)>"
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    class RootPackage < Package
+      class Version < Package::Version
+        def to_s
+          "(root)"
+        end
+      end
+
+      attr_reader :version
+
+      def initialize
+        super(:root)
+        @version = Version.new(self, 0, "1.0.0")
+        @versions = [@version].freeze
+      end
+    end
+
+    def self.root
+      @root ||= RootPackage.new
+    end
+
+    def self.root_version
+      root.version
+    end
+  end
+end

data/lib/pub_grub/partial_solution.rb

@@ -0,0 +1,125 @@
+require 'pub_grub/assignment'
+require 'set'
+
+module PubGrub
+  class PartialSolution
+    attr_reader :assignments, :decisions
+    attr_reader :attempted_solutions
+
+    def initialize
+      reset!
+
+      @attempted_solutions = 1
+      @backtracking = false
+    end
+
+    def decision_level
+      @decisions.length
+    end
+
+    def relation(term)
+      package = term.package
+      return :overlap if !@terms.key?(package)
+
+      @terms[package].relation(term)
+    end
+
+    def satisfies?(term)
+      relation(term) == :subset
+    end
+
+    def derive(term, cause)
+      add_assignment(Assignment.new(term, cause, decision_level, assignments.length))
+    end
+
+    def satisfier(term)
+      assigned_term = nil
+
+      @assignments_by[term.package].each do |assignment|
+        if assigned_term
+          assigned_term = assigned_term.intersect(assignment.term)
+        else
+          assigned_term = assignment.term
+        end
+
+        if assigned_term.satisfies?(term)
+          return assignment
+        end
+      end
+
+      raise "#{term} unsatisfied"
+    end
+
+    # A list of unsatisfied terms
+    def unsatisfied
+      @required.reject do |package|
+        @decisions.key?(package)
+      end.map do |package|
+        @terms[package]
+      end
+    end
+
+    def decide(version)
+      @attempted_solutions += 1 if @backtracking
+      @backtracking = false;
+
+      decisions[version.package] = version
+      assignment = Assignment.decision(version, decision_level, assignments.length)
+      add_assignment(assignment)
+    end
+
+    def backtrack(previous_level)
+      @backtracking = true
+
+      new_assignments = assignments.select do |assignment|
+        assignment.decision_level <= previous_level
+      end
+
+      new_decisions = Hash[decisions.first(previous_level)]
+
+      reset!
+
+      @decisions = new_decisions
+
+      new_assignments.each do |assignment|
+        add_assignment(assignment)
+      end
+    end
+
+    private
+
+    def reset!
+      # { Array<Assignment> }
+      @assignments = []
+
+      # { Package => Array<Assignment> }
+      @assignments_by = Hash.new { |h,k| h[k] = [] }
+
+      # { Package => Package::Version }
+      @decisions = {}
+
+      # { Package => Term }
+      @terms = {}
+
+      # { Package => Boolean }
+      @required = Set.new
+    end
+
+    def add_assignment(assignment)
+      @assignments << assignment
+      @assignments_by[assignment.term.package] << assignment
+
+      term = assignment.term
+      package = term.package
+
+      @required.add(package) if term.positive?
+
+      if @terms.key?(package)
+        old_term = @terms[package]
+        @terms[package] = old_term.intersect(term)
+      else
+        @terms[term.package] = term
+      end
+    end
+  end
+end

data/lib/pub_grub/solve_failure.rb

@@ -0,0 +1,13 @@
+require 'pub_grub/failure_writer'
+
+module PubGrub
+  class SolveFailure < StandardError
+    def initialize(incompatibility)
+      @incompatibility = incompatibility
+    end
+
+    def to_s
+      "\n" + FailureWriter.new(@incompatibility).write
+    end
+  end
+end

data/lib/pub_grub/static_package_source.rb

@@ -0,0 +1,83 @@
+require 'pub_grub/package'
+require 'pub_grub/version_constraint'
+require 'pub_grub/incompatibility'
+
+module PubGrub
+  class StaticPackageSource
+    class DSL
+      def initialize(packages, root_deps)
+        @packages = packages
+        @root_deps = root_deps
+      end
+
+      def root(deps:)
+        @root_deps.update(deps)
+      end
+
+      def add(name, version, deps: {})
+        @packages << [name, version, deps]
+      end
+    end
+
+    def initialize
+      @root_deps = {}
+      @package_list = []
+      yield DSL.new(@package_list, @root_deps)
+
+      @packages = {
+        root: Package.root
+      }
+      @deps_by_version = {
+        Package.root_version => @root_deps
+      }
+
+      @package_list.each do |name, version, deps|
+        @packages[name] ||= Package.new(name)
+        version = @packages[name].add_version(version)
+        @deps_by_version[version] = deps
+      end
+    end
+
+    def get_package(name)
+      @packages[name] ||
+        raise("No such package in source: #{name.inspect}")
+    end
+    alias_method :package, :get_package
+
+    def version(package_name, version_name)
+      package(package_name).version(version_name)
+    end
+
+    def incompatibilities_for(version)
+      package = version.package
+      @deps_by_version[version].map do |dep_package_name, dep_constraint_name|
+        bitmap = VersionConstraint.bitmap_matching(package) do |requesting_version|
+          deps = @deps_by_version[requesting_version]
+          deps && deps[dep_package_name] && deps[dep_package_name] == dep_constraint_name
+        end
+        description =
+          if (bitmap == (1 << package.versions.length) - 1)
+            "any"
+          elsif (bitmap == 1 << version.id)
+            version.name
+          else
+            "requiring #{dep_package_name} #{dep_constraint_name}"
+          end
+        self_constraint = VersionConstraint.new(package, description, bitmap: bitmap)
+
+        dep_package = @packages[dep_package_name]
+
+        if !dep_package
+          # no such package -> this version is invalid
+          description = "referencing invalid package #{dep_package_name.inspect}"
+          constraint = VersionConstraint.new(package, description, bitmap: bitmap)
+          return [Incompatibility.new([Term.new(constraint, true)], cause: :invalid_dependency)]
+        end
+
+        dep_constraint = VersionConstraint.new(dep_package, dep_constraint_name)
+
+        Incompatibility.new([Term.new(self_constraint, true), Term.new(dep_constraint, false)], cause: :dependency)
+      end
+    end
+  end
+end

data/lib/pub_grub/term.rb

@@ -0,0 +1,104 @@
+require 'forwardable'
+
+module PubGrub
+  class Term
+    attr_reader :package, :constraint, :positive
+
+    def initialize(constraint, positive)
+      @constraint = constraint
+      @package = @constraint.package
+      @positive = positive
+    end
+
+    def to_s(allow_every: false)
+      if positive
+        @constraint.to_s(allow_every: allow_every)
+      else
+        "not #{@constraint}"
+      end
+    end
+
+    def invert
+      self.class.new(@constraint, !@positive)
+    end
+    alias_method :inverse, :invert
+
+    def intersect(other)
+      raise ArgumentError, "packages must match" if package != other.package
+
+      return self if relation(other) == :subset
+      return other if other.relation(self) == :subset
+
+      if positive? && other.positive?
+        self.class.new(constraint.intersect(other.constraint), true)
+      elsif negative? && other.negative?
+        self.class.new(constraint.union(other.constraint), false)
+      else
+        positive = positive? ? self : other
+        negative = negative? ? self : other
+        self.class.new(positive.constraint.intersect(negative.constraint.invert), true)
+      end
+    end
+
+    def difference(other)
+      intersect(other.invert)
+    end
+
+    def relation(other)
+      if positive? && other.positive?
+        constraint.relation(other.constraint)
+      elsif negative? && other.positive?
+        if constraint.allows_all?(other.constraint)
+          :disjoint
+        else
+          :overlap
+        end
+      elsif positive? && other.negative?
+        if !other.constraint.allows_any?(constraint)
+          :subset
+        elsif other.constraint.allows_all?(constraint)
+          :disjoint
+        else
+          :overlap
+        end
+      elsif negative? && other.negative?
+        if constraint.allows_all?(other.constraint)
+          :subset
+        else
+          :overlap
+        end
+      else
+        raise
+      end
+    end
+
+    def normalized_constraint
+      @normalized_constraint ||= positive ? constraint : constraint.invert
+    end
+
+    def satisfies?(other)
+      raise ArgumentError, "packages must match" unless package == other.package
+
+      relation(other) == :subset
+    end
+
+    extend Forwardable
+    def_delegators :normalized_constraint, :versions
+
+    def positive?
+      @positive
+    end
+
+    def negative?
+      !positive?
+    end
+
+    def empty?
+      @empty ||= normalized_constraint.empty?
+    end
+
+    def inspect
+      "#<#{self.class} #{self}>"
+    end
+  end
+end