solve 1.2.1 → 2.0.0

data/lib/solve/solver/serializer.rb

@@ -1,37 +1,59 @@
 require 'json'
+require 'solve/graph'
 
 module Solve
+
+  Problem = Struct.new(:graph, :demands)
+
+  # Simple struct class that contains a #graph and #demands (in Array form)
+  #
+  # Can be serialized via Solver::Serializer to create a json representation of
+  # a dependency solving problem.
+  class Problem
+
+    # Create a Problem from a given Solver.
+    #
+    # @param [Solve::GecodeSolver,Solve::RubySolver] dependency solver
+    # @return [Problem]
+    def self.from_solver(solver)
+      demands_data = solver.demands.map do |demand|
+        [ demand.name, demand.constraint.to_s ]
+      end
+      new(solver.graph, demands_data)
+    end
+  end
+
   class Solver
     class Serializer
-      # @param [Solve::Solver] solver
+      # @param [Solve::Problem] problem struct
       #
       # @return [String]
-      def serialize(solver)
-        graph = solver.graph
-        demands = solver.demands
+      def serialize(problem)
+        graph = problem.graph
+        demands = problem.demands
 
         graph_hash = format_graph(graph)
         demands_hash = format_demands(demands)
 
-        problem = graph_hash.merge(demands_hash)
-        problem.to_json
+        problem_data = graph_hash.merge(demands_hash)
+        problem_data.to_json
       end
 
       # @param [Hash, #to_s] solver a json string or a hash representing a solver
       #
-      # @return [Solve::Solver]
-      def deserialize(solver)
-        unless solver.is_a?(Hash)
-          solver = JSON.parse(solver.to_s)
+      # @return [Solve::Problem]
+      def deserialize(problem_data)
+        unless problem_data.is_a?(Hash)
+          problem_data = JSON.parse(problem_data.to_s)
         end
 
-        graph_spec = solver["graph"]
-        demands_spec = solver["demands"]
+        graph_spec = problem_data["graph"]
+        demands_spec = problem_data["demands"]
 
         graph = load_graph(graph_spec)
         demands = load_demands(demands_spec)
 
-        Solve::Solver.new(graph, demands)
+        Solve::Problem.new(graph, demands)
       end
 
       private
@@ -71,8 +93,8 @@ module Solve
 
         def format_demand(demand)
           {
-            "name" => demand.name,
-            "constraint" => demand.constraint.to_s
+            "name" => demand[0],
+            "constraint" => demand[1]
           }
         end
 

data/lib/solve/version.rb

@@ -1,3 +1,3 @@
 module Solve
-  VERSION = "1.2.1"
+  VERSION = "2.0.0"
 end

data/solve.gemspec

@@ -17,5 +17,11 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 1.9.1"
 
   s.add_dependency "semverse",     "~> 1.1"
-  s.add_dependency "dep_selector", "~> 1.0"
+  s.add_dependency "molinillo",    "~> 0.2.3"
+
+  s.add_development_dependency 'thor', '>= 0.16.0'
+  s.add_development_dependency 'rake', '>= 0.9.2.2'
+
+  s.add_development_dependency 'spork'
+  s.add_development_dependency 'rspec', "~> 3.0"
 end

data/spec/acceptance/benchmark.rb

@@ -1,10 +1,12 @@
 require 'benchmark'
 require 'solve'
+require 'solve/gecode_solver'
 require File.expand_path("../large_graph_no_solution", __FILE__)
 require File.expand_path("../opscode_ci_graph", __FILE__)
 
 PROBLEM = OpscodeCiGraph
-N = 1
+#PROBLEM = LargeGraphNoSolution
+N = 100
 
 def demands
   PROBLEM::DEMANDS
@@ -35,11 +37,23 @@ end
 STATIC_GRAPH = create_graph
 
 def solve_gecode
-  Solve::Solver.new(STATIC_GRAPH, demands, {}).resolve({})
-rescue Solve::Errors::NoSolutionError
+  Solve::GecodeSolver.new(STATIC_GRAPH, demands).resolve({})
+rescue Solve::Errors::NoSolutionError => e
+  # Uncomment to look at the error messages. Probably only useful if N == 1
+  #puts e
+  e
+end
+
+def solve_ruby
+  Solve::RubySolver.new(STATIC_GRAPH, demands).resolve({})
+rescue Solve::Errors::NoSolutionError => e
+  # Uncomment to look at the error messages. Probably only useful if N == 1
+  #puts e
+  e
 end
 
 Benchmark.bm(12) do |x|
   x.report("Create graph")   { N.times { create_graph } }
   x.report("Solve Gecode") { N.times { solve_gecode } }
+  x.report("Solve Ruby") { N.times { solve_ruby } }
 end

data/spec/acceptance/ruby_solver_solutions_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+
+describe "Solutions when using the ruby solver" do
+
+  before do
+    Solve.engine = :ruby
+  end
+
+  it "chooses the correct artifact for the demands" do
+    graph = Solve::Graph.new
+    graph.artifact("mysql", "2.0.0")
+    graph.artifact("mysql", "1.2.0")
+    graph.artifact("nginx", "1.0.0").depends("mysql", "= 1.2.0")
+
+    result = Solve.it!(graph, [['nginx', '= 1.0.0'], ['mysql']])
+
+    result.should eql("nginx" => "1.0.0", "mysql" => "1.2.0")
+  end
+
+  it "chooses the best artifact for the demands" do
+    graph = Solve::Graph.new
+    graph.artifact("mysql", "2.0.0")
+    graph.artifact("mysql", "1.2.0")
+    graph.artifact("nginx", "1.0.0").depends("mysql", ">= 1.2.0")
+
+    result = Solve.it!(graph, [['nginx', '= 1.0.0'], ['mysql']])
+
+    result.should eql("nginx" => "1.0.0", "mysql" => "2.0.0")
+  end
+
+  it "raises NoSolutionError when a solution cannot be found" do
+    graph = Solve::Graph.new
+    graph.artifact("mysql", "1.2.0")
+
+    lambda {
+      Solve.it!(graph, ['mysql', '>= 2.0.0'])
+    }.should raise_error(Solve::Errors::NoSolutionError)
+  end
+
+  it "find the correct solution when backtracking in variables introduced via demands" do
+    graph = Solve::Graph.new
+
+    graph.artifact("D", "1.2.0")
+    graph.artifact("D", "1.3.0")
+    graph.artifact("D", "1.4.0")
+    graph.artifact("D", "2.0.0")
+    graph.artifact("D", "2.1.0")
+
+    graph.artifact("C", "2.0.0").depends("D", "= 1.2.0")
+    graph.artifact("C", "2.1.0").depends("D", ">= 2.1.0")
+    graph.artifact("C", "2.2.0").depends("D", "> 2.0.0")
+
+    graph.artifact("B", "1.0.0").depends("D", "= 1.0.0")
+    graph.artifact("B", "1.1.0").depends("D", "= 1.0.0")
+    graph.artifact("B", "2.0.0").depends("D", ">= 1.3.0")
+    graph.artifact("B", "2.1.0").depends("D", ">= 2.0.0")
+
+    graph.artifact("A", "1.0.0").depends("B", "> 2.0.0")
+    graph.artifact("A", "1.0.0").depends("C", "= 2.1.0")
+    graph.artifact("A", "1.0.1").depends("B", "> 1.0.0")
+    graph.artifact("A", "1.0.1").depends("C", "= 2.1.0")
+    graph.artifact("A", "1.0.2").depends("B", "> 1.0.0")
+    graph.artifact("A", "1.0.2").depends("C", "= 2.0.0")
+
+    result = Solve.it!(graph, [['A', '~> 1.0.0'], ['D', ">= 2.0.0"]])
+
+
+    result.should eql("A" => "1.0.1",
+                      "B" => "2.1.0",
+                      "C" => "2.1.0",
+                      "D" => "2.1.0")
+  end
+
+  it "rejects a circular dependency with a circular dep error" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0").depends("B", "1.0.0")
+    graph.artifact("B", "1.0.0").depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0").depends("A", "1.0.0")
+
+    expect { Solve.it!(graph, [["A", "1.0.0"]]) }.to raise_error(Solve::Errors::NoSolutionError)
+  end
+
+  it "rejects a p shaped depenency chain with a circular dep error" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0").depends("B", "1.0.0")
+    graph.artifact("B", "1.0.0").depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0").depends("B", "1.0.0")
+
+    expect { Solve.it!(graph, [["A", "1.0.0"]]) }.to raise_error(Solve::Errors::NoSolutionError)
+  end
+
+  it "finds the correct solution when there is a diamond shaped dependency" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0")
+      .depends("B", "1.0.0")
+      .depends("C", "1.0.0")
+    graph.artifact("B", "1.0.0")
+      .depends("D", "1.0.0")
+    graph.artifact("C", "1.0.0")
+      .depends("D", "1.0.0")
+    graph.artifact("D", "1.0.0")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0",
+                      "B" => "1.0.0",
+                      "C" => "1.0.0",
+                      "D" => "1.0.0")
+  end
+
+  it "solves when packages and constraints have prerelease elements" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0")
+      .depends("B", ">= 1.0.0-alpha")
+    graph.artifact("B", "1.0.0-alpha")
+      .depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0",
+                      "B" => "1.0.0-alpha",
+                      "C" => "1.0.0")
+
+  end
+
+  it "solves when packages and constraints have build elements" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0")
+      .depends("B", ">= 1.0.0+build")
+    graph.artifact("B", "1.0.0+build")
+      .depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0",
+                      "B" => "1.0.0+build",
+                      "C" => "1.0.0")
+
+  end
+
+  it "fails with a self dependency" do
+    graph = Solve::Graph.new
+
+    graph.artifact("bottom", "1.0.0")
+    graph.artifact("middle", "1.0.0").depends("top", "= 1.0.0").depends("middle")
+
+    demands = [["bottom", "1.0.0"],["middle", "1.0.0"]]
+
+    expect { Solve.it!(graph, demands, { :sorted => true  } ) }.to raise_error { |error|
+      error.should be_a(Solve::Errors::NoSolutionError)
+    }
+  end
+
+  it "gives an empty solution when there are no demands" do
+    graph = Solve::Graph.new
+    result = Solve.it!(graph, [])
+    result.should eql({})
+  end
+
+  it "tries all combinations until it finds a solution" do
+
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0").depends("B", "~> 1.0.0")
+    graph.artifact("A", "1.0.1").depends("B", "~> 1.0.0")
+    graph.artifact("A", "1.0.2").depends("B", "~> 1.0.0")
+
+    graph.artifact("B", "1.0.0").depends("C", "~> 1.0.0")
+    graph.artifact("B", "1.0.1").depends("C", "~> 1.0.0")
+    graph.artifact("B", "1.0.2").depends("C", "~> 1.0.0")
+
+    graph.artifact("C", "1.0.0").depends("D", "1.0.0")
+    graph.artifact("C", "1.0.1").depends("D", "1.0.0")
+    graph.artifact("C", "1.0.2").depends("D", "1.0.0")
+
+    # Note:
+    # This test previously used two circular dependencies:
+    # (D 1.0.0) -> A < 0.0.0
+    # (D 0.0.0) -> A = 0.0.0
+    # But Molinillo doesn't support circular dependencies at all.
+
+    # ensure we can't find a solution in the above
+    graph.artifact("D", "1.0.0").depends("E", "< 0.0.0")
+
+    # Add a solution to the graph that should be reached only after all of the
+    # others have been tried
+    graph.artifact("A", "0.0.0").depends("B", "0.0.0")
+    graph.artifact("B", "0.0.0").depends("C", "0.0.0")
+    graph.artifact("C", "0.0.0").depends("D", "0.0.0")
+    graph.artifact("D", "0.0.0")
+
+    demands = [["A"]]
+
+    result = Solve.it!(graph, demands)
+
+    result.should eql({ "A" => "0.0.0",
+                        "B" => "0.0.0",
+                        "C" => "0.0.0",
+                        "D" => "0.0.0"})
+
+  end
+
+  it "correctly resolves when a resolution exists but it is not the latest" do
+    graph = Solve::Graph.new
+
+    graph.artifact("get-the-old-one", "1.0.0")
+      .depends("locked-mid-1", ">= 0.0.0")
+      .depends("locked-mid-2", ">= 0.0.0")
+    graph.artifact("get-the-old-one", "0.5.0")
+
+    graph.artifact("locked-mid-1", "2.0.0").depends("old-bottom", "= 2.0.0")
+    graph.artifact("locked-mid-1", "1.3.0").depends("old-bottom", "= 0.5.0")
+    graph.artifact("locked-mid-1", "1.0.0")
+
+    graph.artifact("locked-mid-2", "2.0.0").depends("old-bottom", "= 2.1.0")
+    graph.artifact("locked-mid-2", "1.4.0").depends("old-bottom", "= 0.5.0")
+    graph.artifact("locked-mid-2", "1.0.0")
+
+    graph.artifact("old-bottom", "2.1.0")
+    graph.artifact("old-bottom", "2.0.0")
+    graph.artifact("old-bottom", "1.0.0")
+    graph.artifact("old-bottom", "0.5.0")
+
+    demands = [["get-the-old-one"]]
+
+    result = Solve.it!(graph, demands)
+
+    # Note: Gecode solver is different. It picks:
+    #
+    # "get-the-old-one" => "1.0.0",
+    # "locked-mid-1" => "1.0.0",
+    # "locked-mid-2" => "2.0.0",
+    # "old-bottom" => "2.1.0"
+
+    result.should eql({
+      "get-the-old-one" => "1.0.0",
+      "locked-mid-1" => "2.0.0",
+      "locked-mid-2" => "1.0.0",
+      "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.artifact("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifact("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("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.artifact("B", "1.0.0").depends("A", "= 1.0.0")
+        graph.artifact("A", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("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::NoSolutionError because Molinillo doesn't support circular deps" do
+        graph = Solve::Graph.new
+
+        graph.artifact("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifact("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("C", "1.0.0").depends("A", "= 1.0.0")
+
+        demands = [["A"]]
+
+        expect { Solve.it!(graph, demands, { :sorted => true  } ) }.to raise_error(Solve::Errors::NoSolutionError)
+      end
+    end
+  end
+end