pub_grub 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312b4d6ab0235f22ead56c025d6ae557043af8f4e4b0ac7bbed1e0a219151a29
-  data.tar.gz: 7b9de23d87e9918d4a97b24ded5d1db9573e7693af34b737c2b66b46f93a9e76
+  metadata.gz: 906d1263305a0df7b8082cf01fd1abb3ddbd92f294744b1d9131603396be31a1
+  data.tar.gz: 6566971cf3a8ed458d15d21233614351d12b407c3e056f3bc580b0efe810fef0
 SHA512:
-  metadata.gz: 2ceeb01137803054fb77b1fba533e21880c49b4ae3e4cbaed52887543137a641f9e4527a86e5840df725e96c9ed021b14f1dcf10233a8608f8eb1f84eb7c4e97
-  data.tar.gz: ce803cc3420bef9d78bd4745ad2e3829272dabb2b1083659e4de712f3a8ab1db4a9f990589a9405e251d0ed2f24d4e466fd035bea6d429ee366d05735cc1777c
+  metadata.gz: 2d793abfc4b0481e6a056f2355310c60e8450058f777754284e011369d2e420a14c37939a8631b3d1ae01ec3f7b1f7c4250234a245ba4b2b6d6d4fc4ea90a5ee
+  data.tar.gz: 526cc6588093a2ec82b44fdad8a2bf6c09f3520c02d1c9a248e11576ca80e6c2817dc8564573b95d8da637e29ea5bed80379632f176a8729bb7c4eecba227950

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_grub (0.3.2)
+    pub_grub (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/pub_grub.rb

@@ -16,5 +16,5 @@ module PubGrub
     attr_accessor :logger
   end
   self.logger = Logger.new(STDERR)
-  self.logger.level = Logger::WARN
+  self.logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
 end

data/lib/pub_grub/basic_package_source.rb

@@ -0,0 +1,166 @@
+require 'pub_grub/version_constraint'
+require 'pub_grub/incompatibility'
+
+module PubGrub
+  # Types:
+  #
+  # Where possible, PubGrub will accept user-defined types, so long as they quack.
+  #
+  # ## "Package":
+  #
+  # This class will be used to represent the various packages being solved for.
+  # .to_s will be called when displaying errors and debugging info, it should
+  # probably return the package's name.
+  # It must also have a reasonable definition of #== and #hash
+  #
+  # Example classes: String ("rails")
+  #
+  #
+  # ## "Version":
+  #
+  # This class will be used to represent a single version number.
+  #
+  # Versions don't need to store their associated package, however they will
+  # only be compared against other versions of the same package.
+  #
+  # It must be Comparible (and implement <=> reasonably)
+  #
+  # Example classes: Gem::Version, Integer
+  #
+  #
+  # ## "Dependency"
+  #
+  # This class represents the requirement one package has on another. It is
+  # returned by dependencies_for(package, version) and will be passed to
+  # parse_dependency to convert it to a format PubGrub understands.
+  #
+  # It must also have a reasonable definition of #==
+  #
+  # Example classes: String ("~> 1.0"), Gem::Requirement
+  #
+  class BasicPackageSource
+    # Override me!
+    #
+    # This is called per package to find all possible versions of a package.
+    #
+    # It is called at most once per-package
+    #
+    # Returns: Array of versions for a package, in preferred order of selection
+    def all_versions_for(package)
+      raise NotImplementedError
+    end
+
+    # Override me!
+    #
+    # Returns: Hash in the form of { package => requirement, ... }
+    def dependencies_for(package, version)
+      raise NotImplementedError
+    end
+
+    # Override me!
+    #
+    # Convert a (user-defined) dependency into a format PubGrub understands.
+    #
+    # Package is passed to this method but for many implementations is not
+    # needed.
+    #
+    # Returns: either a PubGrub::VersionRange, PubGrub::VersionUnion, or a
+    #   PubGrub::VersionConstraint
+    def parse_dependency(package, dependency)
+      raise NotImplementedError
+    end
+
+    # Override me!
+    #
+    # If not overridden, this will call dependencies_for with the root package.
+    #
+    # Returns: Hash in the form of { package => requirement, ... } (see dependencies_for)
+    def root_dependencies
+      dependencies_for(@root_package, @root_version)
+    end
+
+    def initialize
+      @root_package = Package.root
+      @root_version = Package.root_version
+
+      @cached_versions = Hash.new do |h,k|
+        if k == @root_package
+          h[k] = [0]
+        else
+          h[k] = all_versions_for(k)
+        end
+      end
+      @sorted_versions = Hash.new { |h,k| h[k] = @cached_versions[k].sort }
+
+      @cached_dependencies = Hash.new do |packages, package|
+        if package == @root_package
+          packages[package] = {
+            @root_version => root_dependencies
+          }
+        else
+          packages[package] = Hash.new do |versions, version|
+            versions[version] = dependencies_for(package, version)
+          end
+        end
+      end
+    end
+
+    def versions_for(package, range=VersionRange.any)
+      @cached_versions[package].select do |version|
+        range.include?(version)
+      end
+    end
+
+    def incompatibilities_for(package, version)
+      package_deps = @cached_dependencies[package]
+      sorted_versions = @sorted_versions[package]
+      package_deps[version].map do |dep_package, dep_constraint_name|
+        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] == dep_constraint_name
+          low -= 1
+        end
+        low =
+          if low == 0
+            nil
+          else
+            sorted_versions[low]
+          end
+
+        # find version high such that all < high share the same dep
+        while high < sorted_versions.length &&
+            package_deps[sorted_versions[high]][dep_package] == 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)
+
+        if !@packages.include?(dep_package)
+          # no such package -> this version is invalid
+        end
+
+        dep_constraint = parse_dependency(dep_package, dep_constraint_name)
+        if !dep_constraint
+          # falsey indicates this dependency was invalid
+          cause = PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
+          return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
+        elsif !dep_constraint.is_a?(VersionConstraint)
+          # Upgrade range/union to VersionConstraint
+          dep_constraint = VersionConstraint.new(dep_package, range: dep_constraint)
+        end
+
+        Incompatibility.new([Term.new(self_constraint, true), Term.new(dep_constraint, false)], cause: :dependency)
+      end
+    end
+  end
+end

data/lib/pub_grub/failure_writer.rb

@@ -16,6 +16,8 @@ module PubGrub
     end
 
     def write
+      return @root.to_s unless @root.conflict?
+
       visit(@root)
 
       padding = @line_numbers.empty? ? 0 : "(#{@line_numbers.values.last}) ".length

data/lib/pub_grub/incompatibility.rb

@@ -16,6 +16,10 @@ module PubGrub
     def initialize(terms, cause:)
       @cause = cause
       @terms = cleanup_terms(terms)
+
+      if cause == :dependency && @terms.length != 2
+        raise ArgumentError, "a dependency Incompatibility must have exactly two terms. Got #{terms.inspect}"
+      end
     end
 
     def failure?
@@ -44,7 +48,6 @@ module PubGrub
       when :root
         "(root dependency)"
       when :dependency
-        raise unless terms.length == 2
         "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
       when PubGrub::Incompatibility::InvalidDependency
         "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"

data/lib/pub_grub/package.rb

@@ -27,5 +27,9 @@ module PubGrub
     def self.root_version
       ROOT_VERSION
     end
+
+    def to_s
+      name
+    end
   end
 end

data/lib/pub_grub/static_package_source.rb

@@ -1,9 +1,10 @@
 require 'pub_grub/package'
 require 'pub_grub/version_constraint'
 require 'pub_grub/incompatibility'
+require 'pub_grub/basic_package_source'
 
 module PubGrub
-  class StaticPackageSource
+  class StaticPackageSource < BasicPackageSource
     class DSL
       def initialize(packages, root_deps)
         @packages = packages
@@ -15,95 +16,38 @@ module PubGrub
       end
 
       def add(name, version, deps: {})
-        @packages << [name, version, deps]
+        version = Gem::Version.new(version)
+        @packages[name] ||= {}
+        raise ArgumentError, "#{name} #{version} declared twice" if @packages[name].key?(version)
+        @packages[name][version] = deps
       end
     end
 
     def initialize
       @root_deps = {}
-      @package_list = []
-      yield DSL.new(@package_list, @root_deps)
-
-      @packages = {
-        root: Package.root
-      }
-      @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
+      @packages = {}
 
-      @package_list.each do |name, version, deps|
-        @packages[name] ||= Package.new(name)
-        package = @packages[name]
+      yield DSL.new(@packages, @root_deps)
 
-        version = Gem::Version.new(version)
-        @package_versions[package] << version
-        @deps_by_version[package][version] = deps
-      end
+      super()
     end
 
-    def get_package(name)
-      @packages[name] ||
-        raise("No such package in source: #{name.inspect}")
+    def all_versions_for(package)
+      @packages[package].keys
     end
-    alias_method :package, :get_package
 
-    def versions_for(package, range=VersionRange.any)
-      @package_versions[package].select do |version|
-        range.include?(version)
-      end
+    def root_dependencies
+      @root_deps
     end
 
-    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
-        low =
-          if low == 0
-            nil
-          else
-            sorted_versions[low]
-          end
-
-        # 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
-          cause = PubGrub::Incompatibility::InvalidDependency.new(dep_package_name, dep_constraint_name)
-          return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
-        end
+    def dependencies_for(package, version)
+      @packages[package][version]
+    end
 
-        dep_constraint = PubGrub::RubyGems.parse_constraint(dep_package, dep_constraint_name)
+    def parse_dependency(package, dependency)
+      return false unless @packages.key?(package)
 
-        Incompatibility.new([Term.new(self_constraint, true), Term.new(dep_constraint, false)], cause: :dependency)
-      end
+      PubGrub::RubyGems.parse_constraint(package, dependency)
     end
   end
 end

data/lib/pub_grub/version_constraint.rb

@@ -85,9 +85,9 @@ module PubGrub
       if package == Package.root
         "root"
       elsif allow_every && any?
-        "every version of #{package.name}"
+        "every version of #{package}"
       else
-        "#{package.name} #{constraint_string}"
+        "#{package} #{constraint_string}"
       end
     end
 

data/lib/pub_grub/version_solver.rb

@@ -8,7 +8,7 @@ module PubGrub
     attr_reader :source
     attr_reader :solution
 
-    def initialize(source:)
+    def initialize(source:, root: Package.root)
       @source = source
 
       # { package => [incompatibility, ...]}
@@ -19,29 +19,43 @@ module PubGrub
       @solution = PartialSolution.new
 
       add_incompatibility Incompatibility.new([
-        Term.new(VersionConstraint.any(Package.root), false)
+        Term.new(VersionConstraint.any(root), false)
       ], cause: :root)
+
+      propagate(root)
     end
 
-    def solve
-      next_package = Package.root
+    def solved?
+      solution.unsatisfied.empty?
+    end
 
-      while next_package
-        propagate(next_package)
+    # Returns true if there is more work to be done, false otherwise
+    def work
+      return false if solved?
 
-        next_package = choose_package_version
-      end
+      next_package = choose_package_version
+      propagate(next_package)
 
-      result = solution.decisions
+      if solved?
+        logger.info "Solution found after #{solution.attempted_solutions} attempts:"
+        solution.decisions.each do |package, version|
+          logger.info "* #{package} #{version}"
+        end
 
-      logger.info "Solution found after #{solution.attempted_solutions} attempts:"
-      result.each do |package, version|
-        logger.info "* #{package.name} #{version}"
+        false
+      else
+        true
       end
+    end
+
+    def solve
+      work until solved?
 
-      result
+      solution.decisions
     end
 
+    alias_method :result, :solve
+
     private
 
     def propagate(initial_package)
@@ -121,7 +135,7 @@ module PubGrub
       end
 
       unless conflict
-        logger.info("selecting #{package.name} #{version}")
+        logger.info("selecting #{package} #{version}")
 
         solution.decide(package, version)
       end

data/lib/pub_grub/version_union.rb

@@ -55,7 +55,7 @@ module PubGrub
     def select_versions(all_versions)
       versions = []
       ranges.inject(all_versions) do |acc, range|
-        lower, matching, higher = range.partition_versions(acc)
+        _, matching, higher = range.partition_versions(acc)
         versions.concat matching
         higher
       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.3.2"
+  spec.version       = "0.4.0"
   spec.authors       = ["John Hawthorn"]
   spec.email         = ["john@hawthorn.email"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pub_grub
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-08 00:00:00.000000000 Z
+date: 2018-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,6 +99,7 @@ files:
 - bin/setup
 - lib/pub_grub.rb
 - lib/pub_grub/assignment.rb
+- lib/pub_grub/basic_package_source.rb
 - lib/pub_grub/failure_writer.rb
 - lib/pub_grub/incompatibility.rb
 - lib/pub_grub/package.rb
@@ -132,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A version solver based on dart's PubGrub