pub_grub 0.1.0

data/lib/pub_grub/version_constraint.rb

@@ -0,0 +1,162 @@
+require 'rubygems/requirement'
+
+module PubGrub
+  class VersionConstraint
+    attr_reader :package, :constraint
+
+    # @param package [PubGrub::Package]
+    # @param constraint [String]
+    def initialize(package, constraint = nil, bitmap: nil)
+      @package = package
+      @constraint = Array(constraint)
+      @bitmap = bitmap # Calculated lazily
+    end
+
+    def self.exact(version)
+      package = version.package
+      new(package, version.name, bitmap: bitmap_matching(package) { |v| v == version })
+    end
+
+    def self.any(package)
+      new(package, nil, bitmap: (1 << package.versions.count) - 1)
+    end
+
+    def self.bitmap_matching(package)
+      package.versions.select do |version|
+        yield version
+      end.inject(0) do |acc, version|
+        acc | (1 << version.id)
+      end
+    end
+
+    def bitmap
+      return @bitmap if @bitmap
+
+      # TODO: Should not be hardcoded to rubygems semantics
+      requirement = Gem::Requirement.new(constraint)
+      @bitmap = self.class.bitmap_matching(package) do |version|
+        requirement.satisfied_by?(Gem::Version.new(version.name))
+      end
+    end
+
+    def intersect(other)
+      unless package == other.package
+        raise ArgumentError, "Can only intersect between VersionConstraint of the same package"
+      end
+      if bitmap == other.bitmap
+        self
+      else
+        self.class.new(package, constraint + other.constraint, bitmap: bitmap & other.bitmap)
+      end
+    end
+
+    def union(other)
+      unless package == other.package
+        raise ArgumentError, "Can only intersect between VersionConstraint of the same package"
+      end
+      if bitmap == other.bitmap
+        self
+      else
+        self.class.new(package, "#{constraint_string} OR #{other.constraint_string}", bitmap: bitmap | other.bitmap)
+      end
+    end
+
+    def invert
+      new_bitmap = bitmap ^ ((1 << package.versions.length) - 1)
+      new_constraint =
+        if constraint.length == 0
+          ["not >= 0"]
+        elsif constraint.length == 1
+          ["not #{constraint[0]}"]
+        else
+          ["not (#{constraint_string})"]
+        end
+      self.class.new(package, new_constraint, bitmap: new_bitmap)
+    end
+
+    def difference(other)
+      intersect(other.invert)
+    end
+
+    def versions
+      package.versions.select do |version|
+        bitmap[version.id] == 1
+      end
+    end
+
+    if RUBY_VERSION >= "2.5"
+      def allows_all?(other)
+        bitmap.allbits?(other.bitmap)
+      end
+
+      def allows_any?(other)
+        bitmap.anybits?(other.bitmap)
+      end
+    else
+      def allows_all?(other)
+        other_bitmap = other.bitmap
+        (bitmap & other_bitmap) == other_bitmap
+      end
+
+      def allows_any?(other)
+        (bitmap & other.bitmap) != 0
+      end
+    end
+
+    def subset?(other)
+      other.allows_all?(self)
+    end
+
+    def overlap?(other)
+      other.allows_any?(self)
+    end
+
+    def disjoint?(other)
+      !overlap?(other)
+    end
+
+    def relation(other)
+      if subset?(other)
+        :subset
+      elsif overlap?(other)
+        :overlap
+      else
+        :disjoint
+      end
+    end
+
+    def to_s(allow_every: false)
+      if package == Package.root
+        "root"
+      elsif allow_every && any?
+        "every version of #{package.name}"
+      else
+        "#{package.name} #{constraint_string}"
+      end
+    end
+
+    def constraint_string
+      case constraint.length
+      when 0
+        ">= 0"
+      when 1
+        "#{constraint[0]}"
+      else
+        "#{constraint.join(", ")}"
+      end
+    end
+
+    def empty?
+      bitmap == 0
+    end
+
+    # Does this match every version of the package
+    def any?
+      bitmap == self.class.any(package).bitmap
+    end
+
+    def inspect
+      "#<#{self.class} #{self} (#{bitmap.to_s(2).rjust(package.versions.count, "0")})>"
+    end
+  end
+end

data/lib/pub_grub/version_solver.rb

@@ -0,0 +1,209 @@
+require 'pub_grub/partial_solution'
+require 'pub_grub/term'
+require 'pub_grub/incompatibility'
+require 'pub_grub/solve_failure'
+
+module PubGrub
+  class VersionSolver
+    attr_reader :source
+    attr_reader :solution
+
+    def initialize(source:)
+      @source = source
+
+      # { package => [incompatibility, ...]}
+      @incompatibilities = Hash.new do |h, k|
+        h[k] = []
+      end
+
+      @solution = PartialSolution.new
+
+      add_incompatibility Incompatibility.new([
+        Term.new(VersionConstraint.any(Package.root), false)
+      ], cause: :root)
+    end
+
+    def solve
+      next_package = Package.root
+
+      while next_package
+        propagate(next_package)
+
+        next_package = choose_package_version
+      end
+
+      result = solution.decisions.values
+
+      logger.info "Solution found after #{solution.attempted_solutions} attempts:"
+      result.each do |version|
+        logger.info "* #{version.package.name} #{version}"
+      end
+
+      result
+    end
+
+    private
+
+    def propagate(initial_package)
+      changed = [initial_package]
+      while package = changed.shift
+        @incompatibilities[package].reverse_each do |incompatibility|
+          result = propagate_incompatibility(incompatibility)
+          if result == :conflict
+            root_cause = resolve_conflict(incompatibility)
+            changed.clear
+            changed << propagate_incompatibility(root_cause)
+          elsif result # should be a Package
+            changed << result
+          end
+        end
+        changed.uniq!
+      end
+    end
+
+    def propagate_incompatibility(incompatibility)
+      unsatisfied = nil
+      incompatibility.terms.each do |term|
+        relation = solution.relation(term)
+        if relation == :disjoint
+          return nil
+        elsif relation == :overlap
+          # If more than one term is inconclusive, we can't deduce anything
+          return nil if unsatisfied
+          unsatisfied = term
+        end
+      end
+
+      if !unsatisfied
+        return :conflict
+      end
+
+      logger.debug("derived: #{unsatisfied.invert}")
+
+      solution.derive(unsatisfied.invert, incompatibility)
+
+      unsatisfied.package
+    end
+
+    def choose_package_version
+      unsatisfied = solution.unsatisfied
+
+      if unsatisfied.empty?
+        logger.info "No packages unsatisfied. Solving complete!"
+        return nil
+      end
+
+      unsatisfied_term = unsatisfied.min_by do |term|
+        term.versions.count
+      end
+      version = unsatisfied_term.versions.first
+
+      if version.nil?
+        raise "required term with no versions: #{unsatisfied_term}"
+      end
+
+      conflict = false
+
+      source.incompatibilities_for(version).each do |incompatibility|
+        add_incompatibility incompatibility
+
+        conflict ||= incompatibility.terms.all? do |term|
+          term.package == version.package || solution.satisfies?(term)
+        end
+      end
+
+      unless conflict
+        logger.info("selecting #{version.package.name} #{version}")
+
+        solution.decide(version)
+      end
+
+      version.package
+    end
+
+    def resolve_conflict(incompatibility)
+      logger.info "conflict: #{incompatibility}"
+
+      new_incompatibility = false
+
+      while !incompatibility.failure?
+        most_recent_term = nil
+        most_recent_satisfier = nil
+        difference = nil
+
+        previous_level = 1
+
+        incompatibility.terms.each do |term|
+          satisfier = solution.satisfier(term)
+
+          if most_recent_satisfier.nil?
+            most_recent_term = term
+            most_recent_satisfier = satisfier
+          elsif most_recent_satisfier.index < satisfier.index
+            previous_level = [previous_level, most_recent_satisfier.decision_level].max
+            most_recent_term = term
+            most_recent_satisfier = satisfier
+            difference = nil
+          else
+            previous_level = [previous_level, satisfier.decision_level].max
+          end
+
+          if most_recent_term == term
+            difference = most_recent_satisfier.term.difference(most_recent_term)
+            if difference.empty?
+              difference = nil
+            else
+              difference_satisfier = solution.satisfier(difference.inverse)
+              previous_level = [previous_level, difference_satisfier.decision_level].max
+            end
+          end
+        end
+
+        if previous_level < most_recent_satisfier.decision_level ||
+            most_recent_satisfier.decision?
+
+          logger.info "backtracking to #{previous_level}"
+          solution.backtrack(previous_level)
+
+          if new_incompatibility
+            add_incompatibility(incompatibility)
+          end
+
+          return incompatibility
+        end
+
+        new_terms = []
+        new_terms += incompatibility.terms - [most_recent_term]
+        new_terms += most_recent_satisfier.cause.terms.reject { |term|
+          term.package == most_recent_satisfier.term.package
+        }
+        if difference
+          new_terms << difference.invert
+        end
+
+        incompatibility = Incompatibility.new(new_terms, cause: Incompatibility::ConflictCause.new(incompatibility, most_recent_satisfier.cause))
+
+        new_incompatibility = true
+
+        partially = difference ? " partially" : ""
+        logger.info "! #{most_recent_term} is#{partially} satisfied by #{most_recent_satisfier.term}"
+        logger.info "! which is caused by #{most_recent_satisfier.cause}"
+        logger.info "! thus #{incompatibility}"
+      end
+
+      raise SolveFailure.new(incompatibility)
+    end
+
+    def add_incompatibility(incompatibility)
+      logger.debug("fact: #{incompatibility}");
+      incompatibility.terms.each do |term|
+        package = term.package
+        @incompatibilities[package] << incompatibility
+      end
+    end
+
+    def logger
+      PubGrub.logger
+    end
+  end
+end

data/pub_grub.gemspec

@@ -0,0 +1,26 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "pub_grub"
+  spec.version       = "0.1.0"
+  spec.authors       = ["John Hawthorn"]
+  spec.email         = ["john@hawthorn.email"]
+
+  spec.summary       = %q{A version solver based on dart's PubGrub}
+  spec.description   = %q{A version solver based on dart's PubGrub}
+  spec.homepage      = "https://github.com/jhawthorn/pubgrub"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: pub_grub
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Hawthorn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A version solver based on dart's PubGrub
+email:
+- john@hawthorn.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pub_grub.rb
+- lib/pub_grub/assignment.rb
+- lib/pub_grub/failure_writer.rb
+- lib/pub_grub/incompatibility.rb
+- lib/pub_grub/package.rb
+- lib/pub_grub/partial_solution.rb
+- lib/pub_grub/solve_failure.rb
+- lib/pub_grub/static_package_source.rb
+- lib/pub_grub/term.rb
+- lib/pub_grub/version_constraint.rb
+- lib/pub_grub/version_solver.rb
+- pub_grub.gemspec
+homepage: https://github.com/jhawthorn/pubgrub
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A version solver based on dart's PubGrub
+test_files: []