solve 3.1.1 → 4.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 892c2181eaeac640092b4589fa4f8dbce3347618
-  data.tar.gz: e003bdcc9234dfc11b9150de314d7095b982bb5a
+SHA256:
+  metadata.gz: 5d0ae05eff693dfa5424fa6d2c92f96839d997da2d585505992e70f91e6ab863
+  data.tar.gz: 4ddae0850f4f234d98208ed8e42f6a2073b43e6f1d6696935c09127cd30c0bf8
 SHA512:
-  metadata.gz: 337dcf09b925483a50494a1682bce00c4bf3653f69a163490f9764517b740f0213063b1f3fce53ceb1a138cf6c540ffd11a4afc1f75905993c1151c76424a110
-  data.tar.gz: 0f7de65be2bb07b365c5db821d8802d6d87319fa5b4890e8546bb9be434631a6cb232e40883323231bbcbcec00dc94bc43db12f4d60085044fdf9e00d6c6243f
+  metadata.gz: 8c4b234445b2b64082b1cdfecad5f4b49b3c13b6757237033c4b23d359a28d9899f24eb2545cf686f238a037504f1151c6924f0c376e7819b142335e6d5255a3
+  data.tar.gz: 67dc423bc183e3c7b680ba9078340179556561837ef0eb14b0f3f650bbc3e4bd0430137d20a1e1998dca4e7c17f1890f7379147bf0e258a1fa1fad0bbbf3278e

data/lib/solve.rb

@@ -1,14 +1,14 @@
-require 'semverse'
+require "semverse"
 
 module Solve
-  require_relative 'solve/artifact'
-  require_relative 'solve/demand'
-  require_relative 'solve/dependency'
-  require_relative 'solve/version'
-  require_relative 'solve/errors'
-  require_relative 'solve/graph'
-  require_relative 'solve/ruby_solver'
-  require_relative 'solve/gecode_solver'
+  require_relative "solve/artifact"
+  require_relative "solve/demand"
+  require_relative "solve/dependency"
+  require_relative "solve/version"
+  require_relative "solve/errors"
+  require_relative "solve/graph"
+  require_relative "solve/ruby_solver"
+  require_relative "solve/gecode_solver"
 
   # We have to set the default engine here, it gets set on the wrong object if
   # we put this in the metaclass context below.
@@ -23,7 +23,6 @@ module Solve
     # @return [Symbol]
     attr_reader :engine
 
-
     # Sets the solving backend engine. Solve supports 2 engines:
     # * `:ruby` - Molinillo, a pure ruby solver
     # * `:gecode` - dep-selector, a wrapper around the Gecode CSP solver library
@@ -42,6 +41,7 @@ module Solve
       else
         engine_class.activate
       end
+
       @engine = selected_engine
     end
 
@@ -77,4 +77,3 @@ module Solve
   end
 
 end
-

data/lib/solve/artifact.rb

@@ -74,7 +74,7 @@ module Solve
     #     .depends('ntp', '~> 1.3')
     #
     # @return [Solve::Artifact]
-    def depends(name, constraint = '>= 0.0.0')
+    def depends(name, constraint = ">= 0.0.0")
       unless dependency?(name, constraint)
         set_dependency(name, constraint)
       end
@@ -91,8 +91,8 @@ module Solve
     # @return [Boolean]
     def ==(other)
       other.is_a?(self.class) &&
-      self.name == other.name &&
-      self.version == other.version
+        name == other.name &&
+        version == other.version
     end
     alias_method :eql?, :==
 
@@ -100,17 +100,17 @@ module Solve
     #
     # @return [Integer]
     def <=>(other)
-      self.version <=> other.version
+      version <=> other.version
     end
 
     private
 
-      def get_dependency(name, constraint)
-        @dependencies["#{name}-#{constraint}"]
-      end
+    def get_dependency(name, constraint)
+      @dependencies["#{name}-#{constraint}"]
+    end
 
-      def set_dependency(name, constraint)
-        @dependencies["#{name}-#{constraint}"] = Dependency.new(self, name, constraint)
-      end
+    def set_dependency(name, constraint)
+      @dependencies["#{name}-#{constraint}"] = Dependency.new(self, name, constraint)
+    end
   end
 end

data/lib/solve/constraint.rb

@@ -48,17 +48,17 @@ module Solve
         end
 
         split_version = case version.to_s
-        when /^(\d+)\.(\d+)\.(\d+)(-([0-9a-z\-\.]+))?(\+([0-9a-z\-\.]+))?$/i
-          [ $1.to_i, $2.to_i, $3.to_i, $5, $7 ]
-        when /^(\d+)\.(\d+)\.(\d+)?$/
-          [ $1.to_i, $2.to_i, $3.to_i, nil, nil ]
-        when /^(\d+)\.(\d+)?$/
-          [ $1.to_i, $2.to_i, nil, nil, nil ]
-        when /^(\d+)$/
-          [ $1.to_i, nil, nil, nil, nil ]
-        else
-          raise Errors::InvalidConstraintFormat.new(constraint)
-        end
+                        when /^(\d+)\.(\d+)\.(\d+)(-([0-9a-z\-\.]+))?(\+([0-9a-z\-\.]+))?$/i
+                          [ $1.to_i, $2.to_i, $3.to_i, $5, $7 ]
+                        when /^(\d+)\.(\d+)\.(\d+)?$/
+                          [ $1.to_i, $2.to_i, $3.to_i, nil, nil ]
+                        when /^(\d+)\.(\d+)?$/
+                          [ $1.to_i, $2.to_i, nil, nil, nil ]
+                        when /^(\d+)$/
+                          [ $1.to_i, nil, nil, nil, nil ]
+                        else
+                          raise Errors::InvalidConstraintFormat.new(constraint)
+                        end
 
         [ operator, split_version ].flatten
       end
@@ -110,30 +110,30 @@ module Solve
       def compare_approx(constraint, target_version)
         min = constraint.version
         max = if constraint.patch.nil?
-          Semverse::Version.new([min.major + 1, 0, 0, 0])
-        elsif constraint.build
-          identifiers = constraint.version.identifiers(:build)
-          replace     = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
-          Semverse::Version.new([min.major, min.minor, min.patch, min.pre_release, identifiers.fill(replace, -1).join('.')])
-        elsif constraint.pre_release
-          identifiers = constraint.version.identifiers(:pre_release)
-          replace     = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
-          Semverse::Version.new([min.major, min.minor, min.patch, identifiers.fill(replace, -1).join('.')])
-        else
-          Semverse::Version.new([min.major, min.minor + 1, 0, 0])
-        end
+                Semverse::Version.new([min.major + 1, 0, 0, 0])
+              elsif constraint.build
+                identifiers = constraint.version.identifiers(:build)
+                replace = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
+                Semverse::Version.new([min.major, min.minor, min.patch, min.pre_release, identifiers.fill(replace, -1).join(".")])
+              elsif constraint.pre_release
+                identifiers = constraint.version.identifiers(:pre_release)
+                replace = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
+                Semverse::Version.new([min.major, min.minor, min.patch, identifiers.fill(replace, -1).join(".")])
+              else
+                Semverse::Version.new([min.major, min.minor + 1, 0, 0])
+              end
         min <= target_version && target_version < max
       end
     end
 
     OPERATOR_TYPES = {
       "~>" => :approx,
-      "~"  => :approx,
+      "~" => :approx,
       ">=" => :greater_than_equal,
       "<=" => :less_than_equal,
-      "="  => :equal,
-      ">"  => :greater_than,
-      "<"  => :less_than,
+      "=" => :equal,
+      ">" => :greater_than,
+      "<" => :less_than,
     }.freeze
 
     COMPARE_FUNS = {
@@ -142,10 +142,10 @@ module Solve
       greater_than: method(:compare_gt),
       less_than_equal: method(:compare_lte),
       less_than: method(:compare_lt),
-      equal: method(:compare_equal)
+      equal: method(:compare_equal),
     }.freeze
 
-    REGEXP = /^(#{OPERATOR_TYPES.keys.join('|')})\s?(.+)$/
+    REGEXP = /^(#{OPERATOR_TYPES.keys.join('|')})\s?(.+)$/.freeze
 
     attr_reader :operator
     attr_reader :major
@@ -164,7 +164,7 @@ module Solve
     def initialize(constraint = nil)
       constraint = constraint.to_s
       if constraint.nil? || constraint.empty?
-        constraint = '>= 0.0.0'
+        constraint = ">= 0.0.0"
       end
 
       @operator, @major, @minor, @patch, @pre_release, @build = self.class.split(constraint)
@@ -175,18 +175,18 @@ module Solve
       end
 
       @version = Semverse::Version.new([
-        self.major,
-        self.minor,
-        self.patch,
-        self.pre_release,
-        self.build,
+        major,
+        minor,
+        patch,
+        pre_release,
+        build,
       ])
     end
 
     # @return [Symbol]
     def operator_type
-      unless type = OPERATOR_TYPES.fetch(operator)
-        raise RuntimeError, "unknown operator type: #{operator}"
+      unless ( type = OPERATOR_TYPES.fetch(operator) )
+        raise "unknown operator type: #{operator}"
       end
 
       type
@@ -201,7 +201,7 @@ module Solve
     def satisfies?(target)
       target = Semverse::Version.coerce(target)
 
-      return false if !version.zero? && greedy_match?(target)
+      return false if !(version == 0) && greedy_match?(target)
 
       compare(target)
     end
@@ -215,13 +215,13 @@ module Solve
     # @return [Boolean]
     def ==(other)
       other.is_a?(self.class) &&
-        self.operator == other.operator &&
-        self.version == other.version
+        operator == other.operator &&
+        version == other.version
     end
     alias_method :eql?, :==
 
     def inspect
-      "#<#{self.class.to_s} #{to_s}>"
+      "#<#{self.class} #{self}>"
     end
 
     def to_s
@@ -241,15 +241,15 @@ module Solve
       #
       # @param [Semverse::Version] target_version
       #
-      def greedy_match?(target_version)
-        operator_type !~ /less/ && target_version.pre_release? && !version.pre_release?
-      end
+    def greedy_match?(target_version)
+      operator_type !~ /less/ && target_version.pre_release? && !version.pre_release?
+    end
 
       # @param [Semverse::Version] target
       #
       # @return [Boolean]
-      def compare(target)
-        COMPARE_FUNS.fetch(operator_type).call(self, target)
-      end
+    def compare(target)
+      COMPARE_FUNS.fetch(operator_type).call(self, target)
+    end
   end
 end

data/lib/solve/demand.rb

@@ -30,8 +30,8 @@ module Solve
 
     def ==(other)
       other.is_a?(self.class) &&
-        self.name == other.name &&
-        self.constraint == other.constraint
+        name == other.name &&
+        constraint == other.constraint
     end
     alias_method :eql?, :==
   end

data/lib/solve/dependency.rb

@@ -27,14 +27,16 @@ module Solve
     def to_s
       "#{name} (#{constraint})"
     end
+    alias :inspect :to_s
 
     # @param [Object] other
     #
     # @return [Boolean]
     def ==(other)
       other.is_a?(self.class) &&
-      self.artifact == other.artifact &&
-      self.constraint == other.constraint
+        name == other.name &&
+        artifact == other.artifact &&
+        constraint == other.constraint
     end
     alias_method :eql?, :==
   end

data/lib/solve/errors.rb

@@ -47,14 +47,14 @@ module Solve
       def to_s
         s = ""
         s << "#{@message}\n"
-        s << "Missing artifacts: #{missing_artifacts.join(',')}\n" unless missing_artifacts.empty?
+        s << "Missing artifacts: #{missing_artifacts.join(",")}\n" unless missing_artifacts.empty?
         unless constraints_excluding_all_artifacts.empty?
-	  pretty = constraints_excluding_all_artifacts.map { |constraint| "(#{constraint[0]} #{constraint[1]})" }.join(',')
+          pretty = constraints_excluding_all_artifacts.map { |constraint| "(#{constraint[0]} #{constraint[1]})" }.join(",")
           s << "Constraints that match no available version: #{pretty}\n"
         end
         s << "Demand that cannot be met: #{unsatisfiable_demand}\n" if unsatisfiable_demand
         unless artifacts_with_no_satisfactory_version.empty?
-          s << "Artifacts for which there are conflicting dependencies: #{artifacts_with_no_satisfactory_version.join(',')}"
+          s << "Artifacts for which there are conflicting dependencies: #{artifacts_with_no_satisfactory_version.join(",")}"
         end
         s
       end

data/lib/solve/gecode_solver.rb

@@ -1,6 +1,6 @@
-require 'set'
-require 'solve/errors'
-require_relative 'solver/serializer'
+require "set" unless defined?(Set)
+require_relative "errors"
+require_relative "solver/serializer"
 
 module Solve
   class GecodeSolver
@@ -10,13 +10,13 @@ module Solve
       #
       # @return [Integer]
       def timeout
-        seconds = 30 unless seconds = ENV["SOLVE_TIMEOUT"]
+        seconds = 30 unless ( seconds = ENV["SOLVE_TIMEOUT"] )
         seconds.to_i * 1_000
       end
 
       # Attemp to load the dep_selector gem which this solver engine requires.
       def activate
-        require 'dep_selector'
+        require "dep_selector"
       rescue LoadError => e
         raise Errors::EngineNotAvailable, "dep_selector is not installed, GecodeSolver cannot be used (#{e})"
       end
@@ -84,126 +84,129 @@ module Solve
     private
 
       # DepSelector::DependencyGraph object representing the problem.
-      attr_reader :ds_graph
+    attr_reader :ds_graph
 
       # Timeout in milliseconds. Hardcoded to 1s for now.
-      attr_reader :timeout_ms
+    attr_reader :timeout_ms
 
       # Runs the solver with the set of demands given. If any DepSelector
       # exceptions are raised, they are rescued and re-raised
-      def solve_demands(demands_as_constraints)
-        selector = DepSelector::Selector.new(ds_graph, (timeout_ms / 1000.0))
-        selector.find_solution(demands_as_constraints, all_artifacts)
-      rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
-        report_invalid_constraints_error(e)
-      rescue DepSelector::Exceptions::NoSolutionExists => e
-        report_no_solution_error(e)
-      rescue DepSelector::Exceptions::TimeBoundExceeded
-        # DepSelector timed out trying to find the solution. There may or may
-        # not be a solution.
-        raise Solve::Errors::NoSolutionError.new(
-          "The dependency constraints could not be solved in the time allotted.")
-      rescue DepSelector::Exceptions::TimeBoundExceededNoSolution
-        # DepSelector determined there wasn't a solution to the problem, then
-        # timed out trying to determine which constraints cause the conflict.
-        raise Solve::Errors::NoSolutionCauseUnknown.new(
-          "There is a dependency conflict, but the solver could not determine the precise cause in the time allotted.")
-      end
+    def solve_demands(demands_as_constraints)
+      selector = DepSelector::Selector.new(ds_graph, (timeout_ms / 1000.0))
+      selector.find_solution(demands_as_constraints, all_artifacts)
+    rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
+      report_invalid_constraints_error(e)
+    rescue DepSelector::Exceptions::NoSolutionExists => e
+      report_no_solution_error(e)
+    rescue DepSelector::Exceptions::TimeBoundExceeded
+      # DepSelector timed out trying to find the solution. There may or may
+      # not be a solution.
+      raise Solve::Errors::NoSolutionError.new(
+        "The dependency constraints could not be solved in the time allotted."
+      )
+    rescue DepSelector::Exceptions::TimeBoundExceededNoSolution
+      # DepSelector determined there wasn't a solution to the problem, then
+      # timed out trying to determine which constraints cause the conflict.
+      raise Solve::Errors::NoSolutionCauseUnknown.new(
+        "There is a dependency conflict, but the solver could not determine the precise cause in the time allotted."
+      )
+    end
 
       # Maps demands to corresponding DepSelector::SolutionConstraint objects.
-      def demands_as_constraints
-        @demands_as_constraints ||= demands_array.map do |demands_item|
-          item_name, constraint_with_operator = demands_item
-          version_constraint = Semverse::Constraint.new(constraint_with_operator)
-          DepSelector::SolutionConstraint.new(ds_graph.package(item_name), version_constraint)
-        end
+    def demands_as_constraints
+      @demands_as_constraints ||= demands_array.map do |demands_item|
+        item_name, constraint_with_operator = demands_item
+        version_constraint = Semverse::Constraint.new(constraint_with_operator)
+        DepSelector::SolutionConstraint.new(ds_graph.package(item_name), version_constraint)
       end
+    end
 
       # Maps all artifacts in the graph to DepSelector::Package objects. If not
       # already done, artifacts are added to the ds_graph as a necessary side effect.
-      def all_artifacts
-        return @all_artifacts if @all_artifacts
-        populate_ds_graph!
-        @all_artifacts
-      end
+    def all_artifacts
+      return @all_artifacts if @all_artifacts
+
+      populate_ds_graph!
+      @all_artifacts
+    end
 
       # Converts artifacts to DepSelector::Package objects and adds them to the
       # DepSelector graph. This should only be called once; use #all_artifacts
       # to safely get the set of all artifacts.
-      def populate_ds_graph!
-        @all_artifacts = Set.new
+    def populate_ds_graph!
+      @all_artifacts = Set.new
 
-        graph.artifacts.each do |artifact|
-          add_artifact_to_ds_graph(artifact)
-          @all_artifacts << ds_graph.package(artifact.name)
-        end
+      graph.artifacts.each do |artifact|
+        add_artifact_to_ds_graph(artifact)
+        @all_artifacts << ds_graph.package(artifact.name)
       end
+    end
 
-      def add_artifact_to_ds_graph(artifact)
-        package_version = ds_graph.package(artifact.name).add_version(artifact.version)
-        artifact.dependencies.each do |dependency|
-          dependency = DepSelector::Dependency.new(ds_graph.package(dependency.name), dependency.constraint)
-          package_version.dependencies << dependency
-        end
-        package_version
+    def add_artifact_to_ds_graph(artifact)
+      package_version = ds_graph.package(artifact.name).add_version(artifact.version)
+      artifact.dependencies.each do |dependency|
+        dependency = DepSelector::Dependency.new(ds_graph.package(dependency.name), dependency.constraint)
+        package_version.dependencies << dependency
       end
+      package_version
+    end
 
-      def report_invalid_constraints_error(e)
-        non_existent_cookbooks = e.non_existent_packages.inject([]) do |list, constraint|
-          list << constraint.package.name
-        end
-
-        constrained_to_no_versions = e.constrained_to_no_versions.inject([]) do |list, constraint|
-          list << [constraint.package.name, constraint.constraint.to_s]
-        end
+    def report_invalid_constraints_error(e)
+      non_existent_cookbooks = e.non_existent_packages.inject([]) do |list, constraint|
+        list << constraint.package.name
+      end
 
-        raise Solve::Errors::NoSolutionError.new(
-          "Required artifacts do not exist at the desired version",
-          missing_artifacts: non_existent_cookbooks,
-          constraints_excluding_all_artifacts: constrained_to_no_versions
-        )
+      constrained_to_no_versions = e.constrained_to_no_versions.inject([]) do |list, constraint|
+        list << [constraint.package.name, constraint.constraint.to_s]
       end
 
-      def report_no_solution_error(e)
-        most_constrained_cookbooks = e.disabled_most_constrained_packages.inject([]) do |list, package|
-          list << "#{package.name} = #{package.versions.first.to_s}"
-        end
+      raise Solve::Errors::NoSolutionError.new(
+        "Required artifacts do not exist at the desired version",
+        missing_artifacts: non_existent_cookbooks,
+        constraints_excluding_all_artifacts: constrained_to_no_versions
+      )
+    end
 
-        non_existent_cookbooks = e.disabled_non_existent_packages.inject([]) do |list, package|
-          list << package.name
-        end
+    def report_no_solution_error(e)
+      most_constrained_cookbooks = e.disabled_most_constrained_packages.inject([]) do |list, package|
+        list << "#{package.name} = #{package.versions.first}"
+      end
 
-        raise Solve::Errors::NoSolutionError.new(
-          e.message,
-          unsatisfiable_demand: e.unsatisfiable_solution_constraint.to_s,
-          missing_artifacts: non_existent_cookbooks,
-          artifacts_with_no_satisfactory_version: most_constrained_cookbooks
-        )
+      non_existent_cookbooks = e.disabled_non_existent_packages.inject([]) do |list, package|
+        list << package.name
       end
 
-      def build_sorted_solution(unsorted_solution)
-        nodes = Hash.new
-        unsorted_solution.each do |name, version|
-          nodes[name] = @graph.artifact(name, version).dependencies.map(&:name)
-        end
+      raise Solve::Errors::NoSolutionError.new(
+        e.message,
+        unsatisfiable_demand: e.unsatisfiable_solution_constraint.to_s,
+        missing_artifacts: non_existent_cookbooks,
+        artifacts_with_no_satisfactory_version: most_constrained_cookbooks
+      )
+    end
 
-        # Modified from http://ruby-doc.org/stdlib-1.9.3/libdoc/tsort/rdoc/TSort.html
-        class << nodes
-          include TSort
-          alias tsort_each_node each_key
-          def tsort_each_child(node, &block)
-            fetch(node).each(&block)
-          end
-        end
-        begin
-          sorted_names = nodes.tsort
-        rescue TSort::Cyclic => e
-          raise Solve::Errors::UnsortableSolutionError.new(e, unsorted_solution)
-        end
+    def build_sorted_solution(unsorted_solution)
+      nodes = {}
+      unsorted_solution.each do |name, version|
+        nodes[name] = @graph.artifact(name, version).dependencies.map(&:name)
+      end
 
-        sorted_names.map do |artifact|
-          [artifact, unsorted_solution[artifact]]
+      # Modified from http://ruby-doc.org/stdlib-1.9.3/libdoc/tsort/rdoc/TSort.html
+      class << nodes
+        include TSort
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
         end
       end
+      begin
+        sorted_names = nodes.tsort
+      rescue TSort::Cyclic => e
+        raise Solve::Errors::UnsortableSolutionError.new(e, unsorted_solution)
+      end
+
+      sorted_names.map do |artifact|
+        [artifact, unsorted_solution[artifact]]
+      end
+    end
   end
 end