solve 0.2.1 → 0.3.0

data/lib/solve/solver/constraint_row.rb

@@ -0,0 +1,17 @@
+module Solve
+  class Solver
+    # @author Andrew Garson <andrew.garson@gmail.com>
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ConstraintRow
+      attr_reader :package
+      attr_reader :constraint
+      attr_reader :source
+
+      def initialize(package, constraint, source)
+        @package = package
+        @constraint = constraint
+        @source = source
+      end
+    end
+  end
+end

data/lib/solve/solver/constraint_table.rb

@@ -0,0 +1,27 @@
+module Solve
+  class Solver
+    # @author Andrew Garson <andrew.garson@gmail.com>
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class ConstraintTable
+      attr_reader :rows
+
+      def initialize
+        @rows = Array.new
+      end
+
+      def add(package, constraint, source)
+        @rows << ConstraintRow.new(package, constraint, source)
+      end
+
+      def constraints_on_package(package)
+        @rows.select do |row|
+          row.package == package
+        end.map { |row| row.constraint }
+      end
+
+      def remove_constraints_from_source!(source)
+        @rows.reject! { |row| row.source == source }
+      end
+    end
+  end
+end

data/lib/solve/solver/variable.rb

@@ -0,0 +1,41 @@
+module Solve
+  class Solver
+    # @author Andrew Garson <andrew.garson@gmail.com>
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class Variable
+      attr_reader :package
+      attr_reader :value
+      attr_reader :sources
+
+      def initialize(package, source)
+        @package = package
+        @value = nil
+        @sources = Array(source)
+      end
+
+      def add_source(source)
+        @sources << source
+      end
+
+      def last_source
+        @sources.last
+      end
+
+      def bind(value)
+        @value = value
+      end
+
+      def unbind
+        @value = nil
+      end
+
+      def bound?
+        !@value.nil?
+      end
+
+      def remove_source(source)
+        @sources.delete(source)
+      end
+    end
+  end
+end

data/lib/solve/solver/variable_table.rb

@@ -0,0 +1,50 @@
+module Solve
+  class Solver
+    # @author Andrew Garson <andrew.garson@gmail.com>
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    class VariableTable
+      attr_reader :rows
+
+      def initialize
+        @rows = Array.new
+      end
+
+      def add(package, source)
+        row = rows.detect { |row| row.package == package }
+        if row.nil?
+          @rows << Variable.new(package, source)
+        else
+          row.add_source(source)
+        end
+      end
+
+      def first_unbound
+        @rows.detect { |row| row.bound? == false }
+      end
+
+      def find_package(package)
+        @rows.detect { |row| row.package == package }
+      end
+
+      def remove_all_with_only_this_source!(source)
+        with_only_this_source, others = @rows.partition { |row| row.sources == [source] }
+        @rows = others
+        with_only_this_source
+      end
+
+      def all_from_source(source)
+        @rows.select { |row| row.sources.include?(source) }
+      end
+
+      def before(package)
+        package_index = @rows.index { |row| row.package == package }
+        (package_index == 0) ? nil : @rows[package_index - 1]
+      end
+
+      def all_after(package)
+        package_index = @rows.index { |row| row.package == package }
+        @rows[(package_index+1)..-1]
+      end
+    end
+  end
+end

data/lib/solve/version.rb

@@ -1,16 +1,63 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Version
+    class << self
+      # @param [#to_s] version_string
+      #
+      # @raise [InvalidVersionFormat]
+      #
+      # @return [Array]
+      def split(version_string)
+        major, minor, patch = case version_string.to_s
+        when /^(\d+)\.(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, $3.to_i ]
+        when /^(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, nil ]
+        else
+          raise Errors::InvalidVersionFormat.new(version_string)
+        end
+      end
+    end
+
     include Comparable
 
     attr_reader :major
     attr_reader :minor
     attr_reader :patch
 
-    # @param [#to_s] ver_str
-    def initialize(ver_str = String.new)
-      @major, @minor, @patch = parse(ver_str)
+    # @overload initialize(version_array)
+    #   @param [Array] version_array
+    #
+    #   @example
+    #     Version.new([1, 2, 3]) => #<Version: @major=1, @minor=2, @patch=3>
+    #
+    # @overload initialize(version_string)
+    #   @param [#to_s] version_string
+    #
+    #   @example
+    #     Version.new("1.2.3") => #<Version: @major=1, @minor=2, @patch=3>
+    #
+    # @overload initialize(version)
+    #   @param [Solve::Version] version
+    #
+    #   @example
+    #     Version.new(Version.new("1.2.3")) => #<Version: @major=1, @minor=2, @patch=3>
+    #
+    def initialize(*args)
+      if args.first.is_a?(Array)
+        @major, @minor, @patch = args.first
+      else
+        @major, @minor, @patch = self.class.split(args.first.to_s)
+      end
+
+      @major ||= 0
+      @minor ||= 0
+      @patch ||= 0
     end
 
+    # @param [Solve::Version] other
+    #
+    # @return [Integer]
     def <=>(other)
       [:major, :minor, :patch].each do |method|
         ans = (self.send(method) <=> other.send(method))
@@ -19,6 +66,9 @@ module Solve
       0
     end
 
+    # @param [Solve::Version] other
+    #
+    # @return [Boolean]
     def eql?(other)
       other.is_a?(Version) && self == other
     end
@@ -30,18 +80,5 @@ module Solve
     def to_s
       "#{major}.#{minor}.#{patch}"
     end
-
-    private
-
-      def parse(ver_str = String.new)
-        @major, @minor, @patch = case ver_str.to_s
-        when /^(\d+)\.(\d+)\.(\d+)$/
-          [ $1.to_i, $2.to_i, $3.to_i ]
-        when /^(\d+)\.(\d+)$/
-          [ $1.to_i, $2.to_i, 0 ]
-        else
-          raise InvalidVersionFormat.new(ver_str)
-        end
-      end
   end
 end

data/solve.gemspec

@@ -16,9 +16,8 @@ Gem::Specification.new do |s|
   s.version               = Solve::VERSION
   s.required_ruby_version = ">= 1.9.1"
 
-  s.add_runtime_dependency 'dep_selector', '~> 0.0.8'
-
-  s.add_development_dependency 'thor'
+  s.add_development_dependency 'thor', '>= 0.16.0'
+  s.add_development_dependency 'rake', '>= 0.9.2.2'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'fuubar'
   s.add_development_dependency 'spork'

data/spec/acceptance/solutions_spec.rb

@@ -1,25 +1,98 @@
 require 'spec_helper'
 
 describe "Solutions" do
-  it "chooses the best artifact for the demands" do
+  
+  it "chooses the correct artifact for the demands" do
     graph = Solve::Graph.new
     graph.artifacts("mysql", "2.0.0")
     graph.artifacts("mysql", "1.2.0")
     graph.artifacts("nginx", "1.0.0").depends("mysql", "= 1.2.0")
-    graph.demands('nginx')
-    graph.demands('mysql')
 
-    Solve.it(graph).should eql("nginx" => "1.0.0", "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 "raises NoSolutionError when a solution cannot be found" do
+  it "chooses the best artifact for the demands" do
     graph = Solve::Graph.new
+    graph.artifacts("mysql", "2.0.0")
     graph.artifacts("mysql", "1.2.0")
+    graph.artifacts("nginx", "1.0.0").depends("mysql", ">= 1.2.0")
+    
+    result = Solve.it!(graph, [['nginx', '= 1.0.0'], ['mysql']])
 
-    graph.demands("mysql", ">= 2.0.0")
+    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.artifacts("mysql", "1.2.0")
 
     lambda {
-      Solve.it!(graph)
-    }.should raise_error(Solve::NoSolutionError)
+      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.artifacts("D", "1.2.0")
+    graph.artifacts("D", "1.3.0")
+    graph.artifacts("D", "1.4.0")
+    graph.artifacts("D", "2.0.0")
+    graph.artifacts("D", "2.1.0")
+
+    graph.artifacts("C", "2.0.0").depends("D", "= 1.2.0")
+    graph.artifacts("C", "2.1.0").depends("D", ">= 2.1.0")
+    graph.artifacts("C", "2.2.0").depends("D", "> 2.0.0")
+
+    graph.artifacts("B", "1.0.0").depends("D", "= 1.0.0")
+    graph.artifacts("B", "1.1.0").depends("D", "= 1.0.0")
+    graph.artifacts("B", "2.0.0").depends("D", ">= 1.3.0")
+    graph.artifacts("B", "2.1.0").depends("D", ">= 2.0.0")
+
+    graph.artifacts("A", "1.0.0").depends("B", "> 1.0.0")
+    graph.artifacts("A", "1.0.0").depends("C", "= 2.0.0")
+    graph.artifacts("A", "1.0.1").depends("B", "> 1.0.0")
+    graph.artifacts("A", "1.0.1").depends("C", "= 2.1.0")
+    graph.artifacts("A", "1.0.2").depends("B", "> 2.0.0")
+    graph.artifacts("A", "1.0.2").depends("C", "= 2.1.0")
+
+    result = Solve.it!(graph, [['A', '~> 1.0.0'], ['D', ">= 2.0.0"]])
+
+
+    result.should eql("A" => "1.0.2",
+                      "B" => "2.1.0",
+                      "C" => "2.1.0",
+                      "D" => "2.1.0")
+  end
+
+  it "finds the correct solution when there is a circular dependency" 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")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0", 
+                      "B" => "1.0.0",
+                      "C" => "1.0.0")
+  end
+
+  it "finds the correct solution when there is a p shaped depenency chain" 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("B", "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")
+  end
+
 end

data/spec/unit/solve/artifact_spec.rb

@@ -13,44 +13,58 @@ describe Solve::Artifact do
   let(:version) { "1.0.0" }
   subject { Solve::Artifact.new(graph, name, version) }
 
-  describe "#dependencies" do
-    context "given a name and constraint argument" do
-      let(:name) { "nginx" }
-      let(:constraint) { "~> 0.101.5" }
+  describe "equality" do
+    context "given an artifact with the same name and version" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "riot", "1.0.0") }
 
-      context "given the dependency of the given name and constraint does not exist" do
-        it "returns a Solve::Artifact" do
-          subject.dependencies(name, constraint).should be_a(Solve::Dependency)
-        end
-
-        it "the dependency has the given name" do
-          subject.dependencies(name, constraint).name.should eql(name)
-        end
+      it "is equal" do
+        one.should be_eql(two)
+      end
+    end
 
-        it "the dependency has the given constraint" do
-          subject.dependencies(name, constraint).constraint.to_s.should eql(constraint)
-        end
+    context "given an artifact with the same name but different version" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
 
-        it "adds an dependency to the dependency collection" do
-          subject.dependencies(name, constraint)
+      it "is not equal" do
+        one.should_not be_eql(two)
+      end
+    end
 
-          subject.dependencies.should have(1).item
-        end
+    context "given an artifact with the same version but different name" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "league", "1.0.0") }
 
-        it "the dependency added matches the given name" do
-          subject.dependencies(name, constraint)
+      it "is not equal" do
+        one.should_not be_eql(two)
+      end
+    end
+  end
 
-          subject.dependencies[0].name.should eql(name)
-        end
+  describe "sorting" do
+    let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+    let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
+    let(:three) { Solve::Artifact.new(graph, "riot", "3.0.0") }
+
+    let(:artifacts) do
+      [
+        one,
+        two,
+        three
+      ].shuffle
+    end
 
-        it "the dependency added matches the given constraint" do
-          subject.dependencies(name, constraint)
+    it "orders artifacts by their version number" do
+      sorted = artifacts.sort
 
-          subject.dependencies[0].constraint.to_s.should eql(constraint)
-        end
-      end
+      sorted[0].should eql(one)
+      sorted[1].should eql(two)
+      sorted[2].should eql(three)
     end
+  end
 
+  describe "#dependencies" do
     context "given no arguments" do
       it "returns an array" do
         subject.dependencies.should be_a(Array)
@@ -59,38 +73,48 @@ describe Solve::Artifact do
       it "returns an empty array if no dependencies have been accessed" do
         subject.dependencies.should have(0).items
       end
+    end
+  end
 
-      it "returns an array containing an dependency if one was accessed" do
-        subject.dependencies("nginx", "~> 0.101.5")
+  describe "#depends" do
+    context "given a name and constraint argument" do
+      let(:name) { "nginx" }
+      let(:constraint) { "~> 0.101.5" }
 
-        subject.dependencies.should have(1).item
+      context "given the dependency of the given name and constraint does not exist" do
+        it "returns a Solve::Artifact" do
+          subject.depends(name, constraint).should be_a(Solve::Artifact)
+        end
+
+        it "adds a dependency with the given name and constraint to the list of dependencies" do
+          subject.depends(name, constraint)
+
+          subject.dependencies.should have(1).item
+          subject.dependencies.first.name.should eql(name)
+          subject.dependencies.first.constraint.to_s.should eql(constraint)
+        end
       end
     end
 
     context "given only a name argument" do
-      it "returns an array containing a match all constraint (>= 0.0.0)" do
-        subject.dependencies("nginx").constraint.to_s.should eql(">= 0.0.0")
+      it "adds a dependency with a all constraint (>= 0.0.0)" do
+        subject.depends("nginx")
+
+        subject.dependencies.should have(1).item
+        subject.dependencies.first.constraint.to_s.should eql(">= 0.0.0")
       end
     end
+  end
 
-    context "given an unexpected number of arguments" do
-      it "raises an ArgumentError if more than two are provided" do
-        lambda {
-          subject.dependencies(1, 2, 3)
-        }.should raise_error(ArgumentError, "Unexpected number of arguments. You gave: 3. Expected: 2 or less.")
-      end
+  describe "::get_dependency" do
+    before(:each) { subject.depends("nginx", "~> 1.2.3") }
 
-      it "raises an ArgumentError if a name argument is provided but it is nil" do
-        lambda {
-          subject.dependencies(nil)
-        }.should raise_error(ArgumentError, "A name must be specified. You gave: [nil].")
-      end
+    it "returns an instance of Solve::Dependency matching the given name and constraint" do
+      dependency = subject.get_dependency("nginx", "~> 1.2.3")
 
-      it "raises an ArgumentError if a name and constraint argument are provided but the name is nil" do
-        lambda {
-          subject.dependencies(nil, "= 1.0.0")
-        }.should raise_error(ArgumentError, 'A name must be specified. You gave: [nil, "= 1.0.0"].')
-      end
+      dependency.should be_a(Solve::Dependency)
+      dependency.name.should eql("nginx")
+      dependency.constraint.to_s.should eql("~> 1.2.3")
     end
   end