pub_grub 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 468d7bf24cf059751c1de78456163c371a4b28427f5c91c1185ff50a2e991a04
-  data.tar.gz: 46a60ee9a399e4a6736cb729d5acbd6f03a23f392c7aad19070856277f191a9a
+  metadata.gz: 35ae2080ad05322250f9908df76885b83bc1b2578202fccb33c13457bd570925
+  data.tar.gz: 0dc16b3c3e66f06548a51fa03876090d070c67821e43e6c552789e881dd8feab
 SHA512:
-  metadata.gz: 74ad2d2ea59a0f5fff3cf1121221d5c092f7056acb41eab9f2c3ac83399e7da3f7b3e0f3333486da68a381d707d9eb85e885621a87c68998220292a7701e43b5
-  data.tar.gz: a081e3c55d491310631d992360c1e63ca5c5afd66e7db954a86962b805ded63fa2c918c6fb6bcd37ffd36efb5fe6d8d4495e257e4ef82e692bdc44c1e4725043
+  metadata.gz: e86e819b78f3b6a6e94ec3379f0cc4b61e827cbabd16940eb070156cef6b02b9333a3166616e82fe4efb9b3661c25918ed00641a8a8967550dd3315b1c7d2e7c
+  data.tar.gz: 441598b506f2d4d418bb9976911f248f86b1ccc1c1a13127ee9e5f8d8f408469ec48ea7c58b1356fdc9ff9f7c78eba9a266af9db7580bf24457d82465f8e878b

data/Gemfile.lock

@@ -1,13 +1,17 @@
 PATH
   remote: .
   specs:
-    pub_grub (0.2.0)
+    pub_grub (0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.11.3)
+    minitest-stackprof (0.2.0)
+      minitest (>= 5.0)
+      stackprof (>= 0.2.7)
     rake (10.5.0)
+    stackprof (0.2.12)
 
 PLATFORMS
   ruby
@@ -15,8 +19,10 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.16)
   minitest (~> 5.0)
+  minitest-stackprof
   pub_grub!
   rake (~> 10.0)
+  stackprof (~> 0.2.12)
 
 BUNDLED WITH
-   1.16.1
+   1.16.4

data/bin/console

@@ -16,7 +16,7 @@ source =
 foo = source.get_package("foo")
 bar = source.get_package("bar")
 
-solver = VersionSolver.new(source: source)
+solver = PubGrub::VersionSolver.new(source: source)
 
 require 'irb'
 IRB.setup(__FILE__)

data/lib/pub_grub.rb

@@ -1,7 +1,9 @@
 require "pub_grub/package"
 require "pub_grub/static_package_source"
 require "pub_grub/term"
+require "pub_grub/version_range"
 require "pub_grub/version_constraint"
+require "pub_grub/version_union"
 require "pub_grub/version_solver"
 require "pub_grub/incompatibility"
 require 'pub_grub/solve_failure'

data/lib/pub_grub/assignment.rb

@@ -8,8 +8,8 @@ module PubGrub
       @index = index
     end
 
-    def self.decision(version, decision_level, index)
-      term = Term.new(VersionConstraint.exact(version), true)
+    def self.decision(package, version, decision_level, index)
+      term = Term.new(VersionConstraint.exact(package, version), true)
       new(term, :decision, decision_level, index)
     end
 

data/lib/pub_grub/incompatibility.rb

@@ -5,6 +5,12 @@ module PubGrub
       alias_method :other, :satisfier
     end
 
+    InvalidDependency = Struct.new(:package, :constraint) do
+    end
+
+    NoVersions = Struct.new(:constraint) do
+    end
+
     attr_reader :terms, :cause
 
     def initialize(terms, cause:)
@@ -35,10 +41,16 @@ module PubGrub
 
     def to_s
       case cause
+      when :root
+        "(root dependency)"
       when :dependency
         raise unless terms.length == 2
         "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
-      else
+      when PubGrub::Incompatibility::InvalidDependency
+        "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"
+      when PubGrub::Incompatibility::NoVersions
+        "no versions satisfy #{cause.constraint}"
+      when PubGrub::Incompatibility::ConflictCause
         if failure?
           "version solving has failed"
         elsif terms.length == 1
@@ -72,6 +84,8 @@ module PubGrub
             end
           end
         end
+      else
+        raise "unhandled cause: #{cause.inspect}"
       end
     end
 
@@ -79,6 +93,17 @@ module PubGrub
       "#<#{self.class} #{to_s}>"
     end
 
+    def pretty_print(q)
+      q.group 2, "#<#{self.class}", ">" do
+        q.breakable
+        q.text to_s
+
+        q.breakable
+        q.text " caused by "
+        q.pp @cause
+      end
+    end
+
     private
 
     def cleanup_terms(terms)
@@ -97,12 +122,9 @@ module PubGrub
       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|
+        common_terms.inject do |acc, term|
           acc.intersect(term)
         end
-
-        term
       end
     end
   end

data/lib/pub_grub/package.rb

@@ -2,78 +2,30 @@
 
 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
+    attr_reader :name
 
     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)>"
+      "#<#{self.class} #{name.inspect}>"
     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
+    ROOT = Package.new(:root)
+    ROOT_VERSION = 0
 
     def self.root
-      @root ||= RootPackage.new
+      ROOT
     end
 
     def self.root_version
-      root.version
+      ROOT_VERSION
     end
   end
 end

data/lib/pub_grub/partial_solution.rb

@@ -59,12 +59,12 @@ module PubGrub
       end
     end
 
-    def decide(version)
+    def decide(package, version)
       @attempted_solutions += 1 if @backtracking
       @backtracking = false;
 
-      decisions[version.package] = version
-      assignment = Assignment.decision(version, decision_level, assignments.length)
+      decisions[package] = version
+      assignment = Assignment.decision(package, version, decision_level, assignments.length)
       add_assignment(assignment)
     end
 

data/lib/pub_grub/rubygems.rb

@@ -0,0 +1,50 @@
+require 'rubygems/requirement'
+
+module PubGrub
+  module RubyGems
+    extend self
+
+    def requirement_to_range(requirement)
+      ranges = requirement.requirements.map do |(op, ver)|
+        case op
+        when "~>"
+          # TODO: not sure this is correct for prereleases
+          VersionRange.new(min: ver, max: ver.bump, include_min: true)
+        when ">"
+          VersionRange.new(min: ver)
+        when ">="
+          if ver == Gem::Version.new("0")
+            VersionRange.any
+          else
+            VersionRange.new(min: ver, include_min: true)
+          end
+        when "<"
+          VersionRange.new(max: ver)
+        when "<="
+          VersionRange.new(max: ver, include_max: true)
+        when "="
+          VersionRange.new(min: ver, max: ver, include_min: true, include_max: true)
+        when "!="
+          VersionRange.new(min: ver, max: ver, include_min: true, include_max: true).invert
+        else
+          raise "bad version specifier: #{op}"
+        end
+      end
+
+      ranges.inject(&:intersect)
+    end
+
+    def requirement_to_constraint(package, requirement)
+      PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
+    end
+
+    def parse_range(dep)
+      requirement_to_range(Gem::Requirement.new(dep))
+    end
+
+    def parse_constraint(package, dep)
+      range = parse_range(dep)
+      PubGrub::VersionConstraint.new(package, range: range)
+    end
+  end
+end

data/lib/pub_grub/static_package_source.rb

@@ -27,14 +27,21 @@ module PubGrub
       @packages = {
         root: Package.root
       }
-      @deps_by_version = {
-        Package.root_version => @root_deps
-      }
+      @package_versions = Hash.new{ |h, k| h[k] = [] }
+
+      @deps_by_version = Hash.new { |h, k| h[k] = {} }
+
+      root_version = Package.root_version
+      @package_versions[Package.root] = [root_version]
+      @deps_by_version[Package.root][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
+        package = @packages[name]
+
+        version = Gem::Version.new(version)
+        @package_versions[package] << version
+        @deps_by_version[package][version] = deps
       end
     end
 
@@ -44,37 +51,56 @@ module PubGrub
     end
     alias_method :package, :get_package
 
-    def version(package_name, version_name)
-      package(package_name).version(version_name)
+    def versions_for(package, range=VersionRange.any)
+      @package_versions[package].select do |version|
+        range.include?(version)
+      end
     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
+    def incompatibilities_for(package, version)
+      package_deps = @deps_by_version[package]
+      package_versions = @package_versions[package]
+      package_deps[version].map do |dep_package_name, dep_constraint_name|
+        sorted_versions = package_versions.sort
+        low = high = sorted_versions.index(version)
+
+        # find version low such that all >= low share the same dep
+        while low > 0 &&
+            package_deps[sorted_versions[low - 1]][dep_package_name] == dep_constraint_name
+          low -= 1
         end
-        description =
-          if (bitmap == (1 << package.versions.length) - 1)
-            "any"
-          elsif (bitmap == 1 << version.id)
-            version.name
+        low =
+          if low == 0
+            nil
           else
-            "requiring #{dep_package_name} #{dep_constraint_name}"
+            sorted_versions[low]
           end
-        self_constraint = VersionConstraint.new(package, description, bitmap: bitmap)
+
+        # find version high such that all < high share the same dep
+        while high < sorted_versions.length &&
+            package_deps[sorted_versions[high]][dep_package_name] == dep_constraint_name
+          high += 1
+        end
+        high =
+          if high == sorted_versions.length
+            nil
+          else
+            sorted_versions[high]
+          end
+
+        range = VersionRange.new(min: low, max: high, include_min: true)
+
+        self_constraint = VersionConstraint.new(package, range: range)
 
         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)]
+          cause = PubGrub::Incompatibility::InvalidDependency.new(dep_package_name, dep_constraint_name)
+          return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
         end
 
-        dep_constraint = VersionConstraint.new(dep_package, dep_constraint_name)
+        dep_constraint = PubGrub::RubyGems.parse_constraint(dep_package, dep_constraint_name)
 
         Incompatibility.new([Term.new(self_constraint, true), Term.new(dep_constraint, false)], cause: :dependency)
       end

data/lib/pub_grub/term.rb

@@ -82,9 +82,6 @@ module PubGrub
       relation(other) == :subset
     end
 
-    extend Forwardable
-    def_delegators :normalized_constraint, :versions
-
     def positive?
       @positive
     end

data/lib/pub_grub/version_constraint.rb

@@ -1,41 +1,28 @@
-require 'rubygems/requirement'
+require 'pub_grub/version_range'
 
 module PubGrub
   class VersionConstraint
-    attr_reader :package, :constraint
+    attr_reader :package, :range
 
     # @param package [PubGrub::Package]
-    # @param constraint [String]
-    def initialize(package, constraint = nil, bitmap: nil)
+    # @param range [PubGrub::VersionRange]
+    def initialize(package, range: nil)
       @package = package
-      @constraint = Array(constraint)
-      @bitmap = bitmap # Calculated lazily
+      @range = range
     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)
+    class << self
+      def exact(package, version)
+        range = VersionRange.new(min: version, max: version, include_min: true, include_max: true)
+        new(package, range: range)
       end
-    end
 
-    def bitmap
-      return @bitmap if @bitmap
+      def any(package)
+        new(package, range: VersionRange.any)
+      end
 
-      # 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))
+      def empty(package)
+        new(package, range: VersionRange.empty)
       end
     end
 
@@ -43,64 +30,33 @@ module PubGrub
       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
+
+      self.class.new(package, range: range.intersect(other.range))
     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
+
+      self.class.new(package, range: range.union(other.range))
     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)
+      new_range = range.invert
+      self.class.new(package, range: new_range)
     end
 
     def difference(other)
       intersect(other.invert)
     end
 
-    def versions
-      package.versions.select do |version|
-        bitmap[version.id] == 1
-      end
+    def allows_all?(other)
+      range.allows_all?(other.range)
     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
+    def allows_any?(other)
+      range.intersects?(other.range)
     end
 
     def subset?(other)
@@ -136,27 +92,24 @@ module PubGrub
     end
 
     def constraint_string
-      case constraint.length
-      when 0
+      if any?
         ">= 0"
-      when 1
-        "#{constraint[0]}"
       else
-        "#{constraint.join(", ")}"
+        range.to_s
       end
     end
 
     def empty?
-      bitmap == 0
+      range.empty?
     end
 
     # Does this match every version of the package
     def any?
-      bitmap == self.class.any(package).bitmap
+      range.any?
     end
 
     def inspect
-      "#<#{self.class} #{self} (#{bitmap.to_s(2).rjust(package.versions.count, "0")})>"
+      "#<#{self.class} #{self}>"
     end
   end
 end

data/lib/pub_grub/version_range.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module PubGrub
+  class VersionRange
+    attr_reader :min, :max, :include_min, :include_max
+
+    alias_method :include_min?, :include_min
+    alias_method :include_max?, :include_max
+
+    class Empty < VersionRange
+      undef_method :min, :max
+      undef_method :include_min, :include_min?
+      undef_method :include_max, :include_max?
+
+      def initialize
+      end
+
+      def empty?
+        true
+      end
+
+      def intersects?(_)
+        false
+      end
+
+      def allows_all?(other)
+        other.empty?
+      end
+
+      def include?(_)
+        false
+      end
+
+      def any?
+        false
+      end
+
+      def constraints
+        ["(no versions)"]
+      end
+
+      def ==(other)
+        other.class == self.class
+      end
+
+      def invert
+        VersionRange.any
+      end
+    end
+
+    def self.empty
+      Empty.new
+    end
+
+    def self.any
+      new
+    end
+
+    def initialize(min: nil, max: nil, include_min: false, include_max: false)
+      @min = min
+      @max = max
+      @include_min = include_min
+      @include_max = include_max
+
+      if min && max
+        if min > max
+          raise ArgumentError, "min version #{min} must be less than max #{max}"
+        elsif min == max && (!include_min || !include_max)
+          raise ArgumentError, "include_min and include_max must be true when min == max"
+        end
+      end
+    end
+
+    def include?(version)
+      compare_version(version) == 0
+    end
+
+    def compare_version(version)
+      if min
+        case version <=> min
+        when -1
+          return -1
+        when 0
+          return -1 if !include_min
+        when 1
+        end
+      end
+
+      if max
+        case version <=> max
+        when -1
+        when 0
+          return 1 if !include_max
+        when 1
+          return 1
+        end
+      end
+
+      0
+    end
+
+    def strictly_lower?(other)
+      return false if !max || !other.min
+
+      case max <=> other.min
+      when 0
+        !include_max || !other.include_min
+      when -1
+        true
+      when 1
+        false
+      end
+    end
+
+    def strictly_higher?(other)
+      other.strictly_lower?(self)
+    end
+
+    def intersects?(other)
+      return false if other.empty?
+      return other.intersects?(self) if other.is_a?(VersionUnion)
+      !strictly_lower?(other) && !strictly_higher?(other)
+    end
+    alias_method :allows_any?, :intersects?
+
+    def intersect(other)
+      return self.class.empty unless intersects?(other)
+      return other.intersect(self) if other.is_a?(VersionUnion)
+
+      min_range =
+        if !min
+          other
+        elsif !other.min
+          self
+        else
+          case min <=> other.min
+          when 0
+            include_min ? other : self
+          when -1
+            other
+          when 1
+            self
+          end
+        end
+
+      max_range =
+        if !max
+          other
+        elsif !other.max
+          self
+        else
+          case max <=> other.max
+          when 0
+            include_max ? other : self
+          when -1
+            self
+          when 1
+            other
+          end
+        end
+
+      self.class.new(
+        min: min_range.min,
+        include_min: min_range.include_min,
+        max: max_range.max,
+        include_max: max_range.include_max
+      )
+    end
+
+    # The span covered by two ranges
+    #
+    # If self and other are contiguous, this builds a union of the two ranges.
+    # (if they aren't you are probably calling the wrong method)
+    def span(other)
+      return self if other.empty?
+
+      min_range =
+        if !min
+          self
+        elsif !other.min
+          other
+        else
+          case min <=> other.min
+          when 0
+            include_min ? self : other
+          when -1
+            self
+          when 1
+            other
+          end
+        end
+
+      max_range =
+        if !max
+          self
+        elsif !other.max
+          other
+        else
+          case max <=> other.max
+          when 0
+            include_max ? self : other
+          when -1
+            other
+          when 1
+            self
+          end
+        end
+
+      self.class.new(
+        min: min_range.min,
+        include_min: min_range.include_min,
+        max: max_range.max,
+        include_max: max_range.include_max
+      )
+    end
+
+    def union(other)
+      return other.union(self) if other.is_a?(VersionUnion)
+
+      if contiguous_to?(other)
+        span(other)
+      else
+        VersionUnion.union([self, other])
+      end
+    end
+
+    def contiguous_to?(other)
+      return false if other.empty?
+
+      intersects?(other) ||
+        (min == other.max && (include_min || other.include_max)) ||
+        (max == other.min && (include_max || other.include_min))
+    end
+
+    def allows_all?(other)
+      return true if other.empty?
+
+      if other.is_a?(VersionUnion)
+        return other.ranges.all? { |r| allows_all?(r) }
+      end
+
+      return false if max && !other.max
+      return false if min && !other.min
+
+      if min
+        case min <=> other.min
+        when -1
+        when 0
+          return false if !include_min && other.include_min
+        when 1
+          return false
+        end
+      end
+
+      if max
+        case max <=> other.max
+        when -1
+          return false
+        when 0
+          return false if !include_max && other.include_max
+        when 1
+        end
+      end
+
+      true
+    end
+
+    def constraints
+      return ["any"] if any?
+      return ["#{min}"] if min == max
+
+      # FIXME: remove this
+      if min && max && include_min && !include_max && min.respond_to?(:bump) && min.bump == max
+        return ["~> #{min}"]
+      end
+
+      c = []
+      c << "#{include_min ? ">=" : ">"} #{min}" if min
+      c << "#{include_max ? "<=" : "<"} #{max}" if max
+      c
+    end
+
+    def any?
+      !min && !max
+    end
+
+    def empty?
+      false
+    end
+
+    def to_s
+      constraints.join(", ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def invert
+      return self.class.empty if any?
+
+      low = VersionRange.new(max: min, include_max: !include_min)
+      high = VersionRange.new(min: max, include_min: !include_max)
+
+      if !min
+        high
+      elsif !max
+        low
+      else
+        low.union(high)
+      end
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        min == other.min &&
+        max == other.max &&
+        include_min == other.include_min &&
+        include_max == other.include_max
+    end
+  end
+end

data/lib/pub_grub/version_solver.rb

@@ -32,11 +32,11 @@ module PubGrub
         next_package = choose_package_version
       end
 
-      result = solution.decisions.values
+      result = solution.decisions
 
       logger.info "Solution found after #{solution.attempted_solutions} attempts:"
-      result.each do |version|
-        logger.info "* #{version.package.name} #{version}"
+      result.each do |package, version|
+        logger.info "* #{package.name} #{version}"
       end
 
       result
@@ -93,32 +93,40 @@ module PubGrub
         return nil
       end
 
-      unsatisfied_term = unsatisfied.min_by do |term|
-        term.versions.count
-      end
-      version = unsatisfied_term.versions.first
+      unsatisfied_term, versions =
+        unsatisfied.map do |term|
+          range = term.constraint.range
+          [term, source.versions_for(term.package, range)]
+        end.min_by do |(_, v)|
+          v.count
+        end
+
+      package = unsatisfied_term.package
+      version = versions.first
 
       if version.nil?
-        raise "required term with no versions: #{unsatisfied_term}"
+        cause = Incompatibility::NoVersions.new(unsatisfied_term)
+        add_incompatibility Incompatibility.new([unsatisfied_term], cause: cause)
+        return package
       end
 
       conflict = false
 
-      source.incompatibilities_for(version).each do |incompatibility|
+      source.incompatibilities_for(package, version).each do |incompatibility|
         add_incompatibility incompatibility
 
         conflict ||= incompatibility.terms.all? do |term|
-          term.package == version.package || solution.satisfies?(term)
+          term.package == package || solution.satisfies?(term)
         end
       end
 
       unless conflict
-        logger.info("selecting #{version.package.name} #{version}")
+        logger.info("selecting #{package.name} #{version}")
 
-        solution.decide(version)
+        solution.decide(package, version)
       end
 
-      version.package
+      package
     end
 
     def resolve_conflict(incompatibility)

data/lib/pub_grub/version_union.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module PubGrub
+  class VersionUnion
+    attr_reader :ranges
+
+    def self.normalize_ranges(ranges)
+      ranges = ranges.flat_map do |range|
+        if range.is_a?(VersionUnion)
+          range.ranges
+        else
+          [range]
+        end
+      end
+
+      ranges.reject!(&:empty?)
+
+      return [] if ranges.empty?
+
+      mins, ranges = ranges.partition { |r| !r.min }
+      original_ranges = mins + ranges.sort_by { |r| [r.include_min ? 0 : 1, r.min] }
+      ranges = [original_ranges.shift]
+      original_ranges.each do |range|
+        if ranges.last.contiguous_to?(range)
+          ranges << ranges.pop.span(range)
+        else
+          ranges << range
+        end
+      end
+
+      ranges
+    end
+
+    def self.union(ranges)
+      ranges = normalize_ranges(ranges)
+
+      if ranges.size == 0
+        VersionRange.empty
+      elsif ranges.size == 1
+        ranges[0]
+      else
+        new(ranges)
+      end
+    end
+
+    def initialize(ranges)
+      raise ArgumentError unless ranges.all? { |r| r.instance_of?(VersionRange) }
+      @ranges = ranges
+    end
+
+    def include?(version)
+      !!ranges.bsearch {|r| r.compare_version(version) }
+    end
+
+    def intersects?(other)
+      my_ranges = ranges.dup
+      other_ranges =
+        if other.instance_of?(VersionRange)
+          [other]
+        else
+          other.ranges.dup
+        end
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        if my_range.intersects?(other_range)
+          return true
+        end
+
+        if !my_range.max || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+    end
+    alias_method :allows_any?, :intersects?
+
+    def allows_all?(other)
+      other_ranges =
+        if other.is_a?(VersionUnion)
+          other.ranges
+        else
+          [other]
+        end
+
+      other_ranges.all? do |other_range|
+        ranges.any? do |range|
+          range.allows_all?(other_range)
+        end
+      end
+    end
+
+    def empty?
+      false
+    end
+
+    def any?
+      false
+    end
+
+    def intersect(other)
+      new_ranges = ranges.map{ |r| r.intersect(other) }
+      VersionUnion.union(new_ranges)
+    end
+
+    def invert
+      ranges.map(&:invert).inject(:intersect)
+    end
+
+    def union(other)
+      VersionUnion.union([self, other])
+    end
+
+    def to_s
+      ranges.map(&:to_s).join(" OR ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.ranges == other.ranges
+    end
+  end
+end

data/pub_grub.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "pub_grub"
-  spec.version       = "0.2.0"
+  spec.version       = "0.3.0"
   spec.authors       = ["John Hawthorn"]
   spec.email         = ["john@hawthorn.email"]
 
@@ -23,4 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "stackprof", "~> 0.2.12"
+  spec.add_development_dependency "minitest-stackprof"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pub_grub
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-04 00:00:00.000000000 Z
+date: 2018-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.12
+- !ruby/object:Gem::Dependency
+  name: minitest-stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A version solver based on dart's PubGrub
 email:
 - john@hawthorn.email
@@ -75,11 +103,14 @@ files:
 - lib/pub_grub/incompatibility.rb
 - lib/pub_grub/package.rb
 - lib/pub_grub/partial_solution.rb
+- lib/pub_grub/rubygems.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_range.rb
 - lib/pub_grub/version_solver.rb
+- lib/pub_grub/version_union.rb
 - pub_grub.gemspec
 homepage: https://github.com/jhawthorn/pubgrub
 licenses:
@@ -101,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A version solver based on dart's PubGrub