solve 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b23c8ac10998066c9ecea0480dfa83bc74266a20
-  data.tar.gz: ec933cf811cffa4abcb405ab6d9092e8a34b980b
+  metadata.gz: 868022031f083b30e7c32a6d424896fb2fb08367
+  data.tar.gz: 5d50e154ab203dbddd6888616295fc683f26672c
 SHA512:
-  metadata.gz: 4b19ad0f653833739926bd31dde7d774ff134728855ec43be35eeec4945721e798d0e75e04c28071baaacaad191f61115ffcb22623bf2140fdbba770a7e5eaec
-  data.tar.gz: a9bf1c0f0160e9a2d2dbe0489d25a99a7bed8df34c6d9fce67958731cb734d6427b46101f3668e84b91954edcb4ff9a6881de5252715b9b791a8d3b0b94744cd
+  metadata.gz: 56abef15a6d5da9a0e31e1ed88cc46ce9acb7aab8526ec7aaf0c615e8f09cfa1fbb0b361349282640813328fecc954f9eb75fea5d73764176964b771c1a467ec
+  data.tar.gz: 0a079122af8824f23e23c69649092b4f32c7cbb44f72e4fc9d754350c45a48580280e758bb8e94269d6edba99ed026c379399d1edd38fe49afa53b70acfbc84c

data/README.md

@@ -31,6 +31,11 @@ And now solve the graph with some demands
 
     Solve.it!(graph, ['nginx', '>= 0.100.0'])
 
+Or, if you want a topologically sorted solution
+NOTE: This will raise Solve::Errors::UnsortableSolutionError if the solution contains a cycle (which can happen with ruby packages)
+
+    Solve.it!(graph, ['nginx', '>= 0.100.0'], sorted: true)
+
 ### Removing an artifact, or dependency from the graph
 
     graph.artifacts("nginx", "1.0.0").delete

data/lib/solve.rb

@@ -18,13 +18,17 @@ module Solve
     #
     # @param [Solve::Graph] graph
     # @param [Array<Solve::Demand>, Array<String, String>] demands
-    # @param [#say, nil] ui (nil)
+    #
+    # @option options [#say] :ui (nil)
+    #   a ui object for output
+    # @option options [Boolean] :sorted (false)
+    #   should the output be a sorted list rather than a Hash
     #
     # @raise [NoSolutionError]
     #
     # @return [Hash]
-    def it!(graph, demands, ui = nil)
-      Solver.new(graph, demands, ui).resolve
+    def it!(graph, demands, options = {})
+      Solver.new(graph, demands, options[:ui]).resolve(options)
     end
   end
 end

data/lib/solve/errors.rb

@@ -31,5 +31,19 @@ module Solve
     end
 
     class NoSolutionError < SolveError; end
+
+    class UnsortableSolutionError < SolveError
+      attr_reader :internal_exception
+      attr_reader :unsorted_solution
+
+      def initialize(internal_exception, unsorted_solution)
+        @internal_exception = internal_exception
+        @unsorted_solution  = unsorted_solution
+      end
+
+      def to_s
+        "The solution contains a cycle and cannot be topologically sorted. See #unsorted_solution on this exception for the unsorted solution"
+      end
+    end
   end
 end

data/lib/solve/gem_version.rb

@@ -1,3 +1,3 @@
 module Solve
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/lib/solve/solver.rb

@@ -1,3 +1,4 @@
+require 'tsort'
 require_relative 'solver/variable_table'
 require_relative 'solver/variable_row'
 require_relative 'solver/constraint_table'
@@ -87,8 +88,12 @@ module Solve
       end
     end
 
-    # @return [Hash]
-    def resolve
+    # @option options [Boolean] :sorted
+    #   return the solution as a sorted list instead of a Hash
+    #
+    # @return [Hash, List] Returns a hash like { "Artifact Name" => "Version",... }
+    #   unless options[:sorted], then it returns a list like [["Artifact Name", "Version],...]
+    def resolve(options = {})
       trace("Attempting to find a solution")
       seed_demand_dependencies
 
@@ -119,16 +124,46 @@ module Solve
         end
       end
 
-      solution = {}.tap do |solution|
+      solution = (options[:sorted]) ? build_sorted_solution : build_unsorted_solution
+
+      trace("Found Solution")
+      trace(solution)
+
+      solution
+    end
+
+    def build_unsorted_solution
+      {}.tap do |solution|
         variable_table.rows.each do |variable|
           solution[variable.artifact] = variable.value.version.to_s
         end
       end
+    end
+
+    def build_sorted_solution
+      unsorted_solution = build_unsorted_solution
+      nodes = Hash.new
+      unsorted_solution.each do |name, version|
+        nodes[name] = @graph.get_artifact(name, version).dependencies.map(&:name)
+      end
 
-      trace("Found Solution")
-      trace(solution)
+      # 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
 
-      solution
+      sorted_names.map do |artifact|
+        [artifact, unsorted_solution[artifact]]
+      end
     end
 
     # @overload demands(name, constraint)

data/spec/acceptance/solutions_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe "Solutions" do
-
   it "chooses the correct artifact for the demands" do
     graph = Solve::Graph.new
     graph.artifacts("mysql", "2.0.0")
@@ -191,4 +190,69 @@ describe "Solutions" do
       "old-bottom" => "2.0.0"
     })
   end
+
+  describe "when options[:sorted] is true" do
+    describe "with a simple list of dependencies" do
+      it "returns a sorted list of dependencies" do
+        graph = Solve::Graph.new
+
+        graph.artifacts("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifacts("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifacts("C", "1.0.0")
+
+        demands = [["A"]]
+
+        result = Solve.it!(graph, demands, { :sorted => true })
+
+        result.should eql([
+          ["C", "1.0.0"],
+          ["B", "1.0.0"],
+          ["A", "1.0.0"]
+        ])
+      end
+    end
+
+    # The order that the demands come in determines the order of artifacts
+    # in the solver's variable_table. This must not determine the sort order
+    describe "with a constraint that depends upon an earlier constrained artifact" do
+      it "returns a sorted list of dependencies" do
+        graph = Solve::Graph.new
+
+        graph.artifacts("B", "1.0.0").depends("A", "= 1.0.0")
+        graph.artifacts("A", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifacts("C", "1.0.0")
+
+        demands = [["A"],["B"]] 
+
+        result = Solve.it!(graph, demands, { :sorted => true  } )
+
+        result.should eql([
+          ["C", "1.0.0"],
+          ["A", "1.0.0"],
+          ["B", "1.0.0"]
+        ])
+      end
+    end
+
+    describe "when the solution is cyclic" do
+      it "raises a Solve::Errors::UnsortableSolutionError which contains the unsorted solution" do
+        graph = Solve::Graph.new
+
+        graph.artifacts("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifacts("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifacts("C", "1.0.0").depends("A", "= 1.0.0")
+
+        demands = [["A"]]
+
+        expect { Solve.it!(graph, demands, { :sorted => true  } ) }.to raise_error { |error|
+          error.should be_a(Solve::Errors::UnsortableSolutionError)
+          error.unsorted_solution.should eql({
+            "A" => "1.0.0",
+            "B" => "1.0.0",
+            "C" => "1.0.0",
+          })
+        }
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solve
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Jamie Winsor
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-16 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby version constraint solver
 email: