solve 0.2.1

data/spec/acceptance/solutions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Solutions" 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")
+    graph.demands('nginx')
+    graph.demands('mysql')
+
+    Solve.it(graph).should eql("nginx" => "1.0.0", "mysql" => "1.2.0")
+  end
+
+  it "raises NoSolutionError when a solution cannot be found" do
+    graph = Solve::Graph.new
+    graph.artifacts("mysql", "1.2.0")
+
+    graph.demands("mysql", ">= 2.0.0")
+
+    lambda {
+      Solve.it!(graph)
+    }.should raise_error(Solve::NoSolutionError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler'
+require 'spork'
+
+Spork.prefork do
+  require 'rspec'
+  
+  APP_ROOT = File.expand_path('../../', __FILE__)
+  
+  Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
+
+  RSpec.configure do |config|
+    config.mock_with :rspec
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.filter_run focus: true
+    config.run_all_when_everything_filtered = true
+  end
+end
+
+Spork.each_run do
+  require 'solve'
+end

data/spec/unit/solve/artifact_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Solve::Artifact do
+  let(:graph) do
+    package = double('package')
+    package_version = double('package_version')
+    package_version.stub(:dependencies).and_return([])
+    package.stub(:add_version).and_return(package_version)
+    double('graph', dep_graph: double('dep_graph', package: package))
+  end
+
+  let(:name) { "league" }
+  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" }
+
+      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 "the dependency has the given constraint" do
+          subject.dependencies(name, constraint).constraint.to_s.should eql(constraint)
+        end
+
+        it "adds an dependency to the dependency collection" do
+          subject.dependencies(name, constraint)
+
+          subject.dependencies.should have(1).item
+        end
+
+        it "the dependency added matches the given name" do
+          subject.dependencies(name, constraint)
+
+          subject.dependencies[0].name.should eql(name)
+        end
+
+        it "the dependency added matches the given constraint" do
+          subject.dependencies(name, constraint)
+
+          subject.dependencies[0].constraint.to_s.should eql(constraint)
+        end
+      end
+    end
+
+    context "given no arguments" do
+      it "returns an array" do
+        subject.dependencies.should be_a(Array)
+      end
+
+      it "returns an empty array if no dependencies have been accessed" do
+        subject.dependencies.should have(0).items
+      end
+
+      it "returns an array containing an dependency if one was accessed" do
+        subject.dependencies("nginx", "~> 0.101.5")
+
+        subject.dependencies.should have(1).item
+      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")
+      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
+
+      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 "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
+    end
+  end
+
+  describe "#delete" do
+    context "given the artifact is a member of a graph" do
+      subject { Solve::Artifact.new(graph, name, version) }
+
+      before(:each) do
+        graph.should_receive(:remove_artifact).with(subject).and_return(subject)
+      end
+
+      it "notifies the graph that the artifact should be removed" do
+        subject.delete
+      end
+
+      it "sets the graph attribute to nil" do
+        subject.delete
+
+        subject.graph.should be_nil
+      end
+
+      it "returns the instance of artifact deleted from the graph" do
+        subject.delete.should eql(subject)
+      end
+    end
+
+    context "given the artifact is not the member of a graph" do
+      subject { Solve::Artifact.new(nil, name, version) }
+
+      it "returns nil" do
+        subject.delete.should be_nil
+      end
+    end
+  end
+end

data/spec/unit/solve/constraint_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Solve::Constraint do
+  let(:valid_string) { ">= 0.0.0" }
+  let(:invalid_string) { "x23u7089213.*" }
+
+  describe "ClassMethods" do
+    subject { Solve::Constraint }
+
+    describe "#parse" do
+      it "returns an array containing two items" do
+        subject.parse(valid_string).should have(2).items
+      end
+
+      it "returns the operator at index 0" do
+        subject.parse(valid_string)[0].should eql(">=")
+      end
+
+      it "returns the version string at index 1" do
+        subject.parse(valid_string)[1].should eql("0.0.0")
+      end
+
+      context "given a string that does not match the Constraint REGEXP" do
+        it "returns nil" do
+          subject.parse(invalid_string).should be_nil
+        end
+      end
+
+      context "given a string that does not contain an operator" do
+        it "returns a constraint constraint with a default operator (=)" do
+          subject.parse("1.0.0")[0].should eql("=")
+        end
+      end
+    end
+
+    describe "#initialize" do
+      it "returns a new instance of Constraint" do
+        subject.new(valid_string).should be_a(Solve::Constraint)
+      end
+
+      it "assigns the parsed operator to the operator attribute" do
+        subject.new(valid_string).operator.should eql(">=")
+      end
+
+      it "assigns the parsed version string as an instance of Version to the version attribute" do
+        result = subject.new(valid_string)
+
+        result.version.should be_a(Solve::Version)
+        result.version.to_s.should eql("0.0.0")
+      end
+
+      context "given a string that does not match the Constraint REGEXP" do
+        it "raises an InvalidConstraintFormat error" do
+          lambda {
+            subject.new(invalid_string)
+          }.should raise_error(Solve::InvalidConstraintFormat)
+        end
+      end
+
+      context "given a nil value" do
+        it "raises an InvalidConstraintFormat error" do
+          lambda {
+            subject.new(nil)
+          }.should raise_error(Solve::InvalidConstraintFormat)
+        end
+      end
+    end
+  end
+
+  describe "#satisfies?" do
+    subject { Solve::Constraint.new("= 1.0.0") }
+
+    it "accepts a String for version" do
+      subject.satisfies?("1.0.0").should be_true
+    end
+
+    it "accepts a Version for version" do
+      subject.satisfies?(Solve::Version.new("1.0.0")).should be_true
+    end
+
+    context "strictly greater than (>)" do
+      subject { Solve::Constraint.new("> 1.0.0") }
+
+      it "returns true if the given version would satisfy the constraint" do
+        subject.satisfies?("2.0.0").should be_true
+      end
+
+      it "returns false if the given version would not satisfy the constraint" do
+        subject.satisfies?("1.0.0").should be_false
+      end
+    end
+
+    context "strictly less than (<)" do
+      subject { Solve::Constraint.new("< 1.0.0") }
+
+      it "returns true if the given version would satisfy the constraint" do
+        subject.satisfies?("0.1.0").should be_true
+      end
+
+      it "returns false if the given version would not satisfy the constraint" do
+        subject.satisfies?("1.0.0").should be_false
+      end
+    end
+
+    context "strictly equal to (=)" do
+      subject { Solve::Constraint.new("= 1.0.0") }
+
+      it "returns true if the given version would satisfy the constraint" do
+        subject.satisfies?("1.0.0").should be_true
+      end
+
+      it "returns false if the given version would not satisfy the constraint" do
+        subject.satisfies?("1.0.1").should be_false
+      end
+    end
+
+    context "greater than or equal to (>=)" do
+      subject { Solve::Constraint.new(">= 1.0.0") }
+
+      it "returns true if the given version is greater than the version constraint" do
+        subject.satisfies?("2.0.0").should be_true
+      end
+
+      it "returns true if the given version is equal to the version constraint" do
+        subject.satisfies?("1.0.0").should be_true
+      end
+
+      it "returns false if the given version is less than the version constraint" do
+        subject.satisfies?("0.9.0").should be_false
+      end
+    end
+
+    context "greater than or equal to (<=)" do
+      subject { Solve::Constraint.new("<= 1.0.0") }
+
+      it "returns true if the given version is less than the version constraint" do
+        subject.satisfies?("0.9.0").should be_true
+      end
+
+      it "returns true if the given version is equal to the version constraint" do
+        subject.satisfies?("1.0.0").should be_true
+      end
+
+      it "returns false if the given version is less than the version constraint" do
+        subject.satisfies?("1.0.1").should be_false
+      end
+    end
+
+    context "greater than or equal to (~>)" do
+      subject { Solve::Constraint.new("~> 1.0.0") }
+
+      it "returns true if the given version is equal to the version constraint" do
+        subject.satisfies?("1.0.0").should be_true
+      end
+
+      context "when the last value in the constraint is for patch" do
+        subject { Solve::Constraint.new("~> 1.0.1") }
+
+        it "returns true if the patch level is greater than the constraint's" do
+          subject.satisfies?("1.0.2").should be_true
+        end
+
+        it "returns true if the patch level is equal to the constraint's" do
+          subject.satisfies?("1.0.1").should be_true
+        end
+
+        it "returns false if the patch level is less than the constraint's" do
+          subject.satisfies?("1.0.0").should be_false
+        end
+
+        it "returns false if the given version is less than the constraint's" do
+          subject.satisfies?("0.9.0").should be_false
+        end
+      end
+
+      context "when the last value in the constraint is for minor" do
+        subject { Solve::Constraint.new("~> 1.1") }
+
+        it "returns true if the minor level is greater than the constraint's" do
+          subject.satisfies?("1.2").should be_true
+        end
+
+        it "returns true if the minor level is equal to the constraint's" do
+          subject.satisfies?("1.1").should be_true
+        end
+
+        it "returns true if a patch level is set but the minor level is equal to or greater than the constraint's" do
+          subject.satisfies?("1.2.8").should be_true
+        end
+
+        it "returns false if the patch level is less than the constraint's" do
+          subject.satisfies?("1.0.1").should be_false
+        end
+
+        it "returns false if the major level is greater than the constraint's" do
+          subject.satisfies?("2.0.0").should be_false
+        end
+      end
+    end
+  end
+end

data/spec/unit/solve/demand_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Solve::Demand do
+  let(:graph) { double('graph') }
+  let(:name) { "league" }
+
+  describe "ClassMethods" do
+    subject { Solve::Demand }
+
+    describe "::initialize" do
+      it "accepts a string for the constraint parameter" do
+        subject.new(graph, name, "= 0.0.1").constraint.to_s.should eql("= 0.0.1")
+      end
+
+      it "accepts a Solve::Constraint for the constraint parameter" do
+        constraint = Solve::Constraint.new("= 0.0.1")
+
+        subject.new(graph, name, constraint).constraint.should eql(constraint)
+      end
+    end
+  end
+
+  let(:constraint) { "~> 1.0.0" }
+  subject { Solve::Demand.new(graph, name, constraint) }
+
+  describe "#delete" do
+    context "given the artifact is a member of a graph" do
+      subject { Solve::Demand.new(graph, name, constraint) }
+
+      before(:each) do
+        graph.should_receive(:remove_demand).with(subject).and_return(subject)
+      end
+
+      it "notifies the graph that the artifact should be removed" do
+        subject.delete
+      end
+
+      it "sets the graph attribute to nil" do
+        subject.delete
+
+        subject.graph.should be_nil
+      end
+
+      it "returns the instance of artifact deleted from the graph" do
+        subject.delete.should eql(subject)
+      end
+    end
+
+    context "given the artifact is not the member of a graph" do
+      subject { Solve::Demand.new(nil, name, constraint) }
+
+      it "returns nil" do
+        subject.delete.should be_nil
+      end
+    end
+  end
+end

data/spec/unit/solve/dependency_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Solve::Dependency do
+  let(:artifact) { double('artifact') }
+  let(:name) { 'nginx' }
+  let(:constraint) { "~> 0.0.1" }
+
+  subject { Solve::Dependency.new(artifact, name, constraint) }
+
+  describe "#delete" do
+    context "given the dependency is a member of an artifact" do
+      subject { Solve::Dependency.new(artifact, name, constraint) }
+
+      before(:each) do
+        artifact.should_receive(:remove_dependency).with(subject).and_return(subject)
+      end
+
+      it "notifies the artifact that the dependency should be removed" do
+        subject.delete
+      end
+
+      it "sets the artifact attribute to nil" do
+        subject.delete
+
+        subject.artifact.should be_nil
+      end
+
+      it "returns the instance of dependency deleted from the artifact" do
+        subject.delete.should eql(subject)
+      end
+    end
+
+    context "given the dependency is not the member of an artifact" do
+      subject { Solve::Dependency.new(nil, name, constraint) }
+
+      it "returns nil" do
+        subject.delete.should be_nil
+      end
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true if the other object is an instance of Solve::Dependency with the same constraint and artifact" do
+      other = Solve::Dependency.new(artifact, name, constraint)
+
+      subject.should eql(other)
+    end
+  end
+end