rubycut-babushka 0.10.8 → 0.15.6.1

data/spec/babushka/dep_definer_spec.rb

@@ -1,9 +1,96 @@
 require 'spec_helper'
-require 'dep_definer_support'
 
 describe "source_template" do
   it "should return BaseTemplate" do
-    TestDepContext.source_template.should == Dep::BaseTemplate
+    DepContext.source_template.should == Dep::BaseTemplate
+  end
+end
+
+describe DepDefiner, '#define!' do
+  let(:a_dep) { dep('DepDefiner defining spec') }
+
+  it "should return itself" do
+    DepDefiner.new(a_dep).tap {|dd|
+      dd.define!.should == dd
+    }
+  end
+  it "shouldn't define straight away" do
+    DepDefiner.new(a_dep).tap {|dd|
+      dd.should_not be_loaded
+      dd.should_not be_failed
+    }
+    DepDefiner.new(a_dep) {}.tap {|dd|
+      dd.should_not be_loaded
+      dd.should_not be_failed
+    }
+  end
+  it "should define without a block" do
+    DepDefiner.new(a_dep).tap {|dd|
+      dd.define!
+      dd.should be_loaded
+      dd.should_not be_failed
+    }
+  end
+  it "should define with a valid block" do
+    DepDefiner.new(a_dep) {}.tap {|dd|
+      dd.define!
+      dd.should be_loaded
+      dd.should_not be_failed
+    }
+  end
+  it "should fail with an invalid block" do
+    DepDefiner.new(a_dep) { lol }.tap {|dd|
+      lambda { dd.define! }.should raise_error
+      dd.should_not be_loaded
+      dd.should be_failed
+    }
+  end
+  it "shouldn't define twice" do
+    DepDefiner.new(a_dep).tap {|dd|
+      dd.should_receive(:define_elements!).once
+      dd.define!
+      dd.define!
+    }
+  end
+  it "should allow DepDefinitionError to bubble up" do
+    lambda {
+      DepDefiner.new(a_dep) { raise DepDefinitionError }.define!
+    }.should raise_error(DepDefinitionError)
+  end
+  it "shouldn't attempt re-defining after failure" do
+    DepDefiner.new(a_dep).tap {|dd|
+      dd.stub!(:failed?).and_return(true)
+      dd.should_not_receive(:define_elements!)
+    }.define!
+  end
+end
+
+describe DepDefiner, '#invoke' do
+  let(:a_dep) { dep('DepDefiner invoking spec') }
+  let(:definer) { DepDefiner.new(a_dep) }
+
+  it "should define and invoke when undefined" do
+    definer.should_receive(:define!)
+    definer.should_receive(:met?).and_return(lambda {|_| })
+    definer.invoke(:met?)
+  end
+
+  it "should invoke only when already defined" do
+    definer.stub!(:loaded?).and_return(true)
+    definer.should_not_receive(:define!)
+    definer.should_receive(:met?).and_return(lambda {|_| })
+    definer.invoke(:met?)
+  end
+
+  it "should not invoke when defining failed" do
+    definer.should_receive(:define_elements!).and_raise(StandardError)
+    definer.should_not_receive(:met?)
+    lambda { definer.invoke(:met?) }.should raise_error
+  end
+
+  it "should call the task with a valid block" do
+    DepContext.new(a_dep) { }.invoke(:met?).should be_true
+    DepContext.new(a_dep) { met? { false } }.invoke(:met?).should be_false
   end
 end
 
@@ -103,12 +190,12 @@ describe "args" do
       subject.args.map_values {|_,v| v.name }.should == {:a => :a}
     end
     it "should lazily create the missing parameter" do
-      subject.context.b.should be_an_instance_of(Parameter)
-      subject.context.b.name.should == :b
+      subject.context.define!.b.should be_an_instance_of(Parameter)
+      subject.context.define!.b.name.should == :b
     end
     it "should set only the paramters that were passed" do
-      subject.context.a.should be_set
-      subject.context.b.should_not be_set
+      subject.context.define!.a.should be_set
+      subject.context.define!.b.should_not be_set
     end
   end
 end
@@ -123,30 +210,35 @@ describe "methods in deps" do
     dep 'without helper method'
   }
   it "should only be defined on the specified dep" do
-    Dep('helper method test').context.should respond_to(:helper_test)
-    Dep('without helper method').context.should_not respond_to(:helper_test)
+    Dep('helper method test').context.define!.should respond_to(:helper_test)
+    Dep('without helper method').context.define!.should_not respond_to(:helper_test)
   end
   it "should return the right value" do
-    Dep('helper method test').context.helper_test.should == 'hello from the helper method!'
+    Dep('helper method test').context.define!.helper_test.should == 'hello from the helper method!'
   end
 end
 
 describe "#on for scoping accepters" do
+  let!(:the_lambda) { L{ 'hello from the lambda' } }
+  let!(:other_lambda) { L{ 'hello from the other lambda' } }
   before {
-    Base.stub!(:host).and_return OSXSystemProfile.for_flavour
-    Base.host.stub!(:version).and_return '10.6.7'
-    @lambda = lambda = L{ 'hello from the lambda' }
-    @other_lambda = other_lambda = L{ 'hello from the other lambda' }
+    Babushka.stub!(:host).and_return OSXSystemProfile.new
+    Babushka.host.stub!(:match_list).and_return([:osx])
+
+    local_lambda, other_local_lambda = the_lambda, other_lambda
+
     dep 'scoping' do
       on :osx do
-        met?(&lambda)
+        met?(&local_lambda)
       end
       on :linux do
-        met?(&other_lambda)
+        met?(&other_local_lambda)
       end
     end
   }
   it "should only allow choices that match" do
-    Dep('scoping').send(:payload)[:met?].should == {:osx => @lambda}
+    Dep('scoping').tap {|dep|
+      dep.context.define!
+    }.context.payload[:met?].should == {:osx => the_lambda}
   end
 end

data/spec/babushka/dep_spec.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 require 'spec_helper'
 require 'dep_support'
 
@@ -14,6 +16,12 @@ describe "Dep.new" do
     }.should raise_error(InvalidDepName, "The dep name 'carriage\rreturn' contains nonprintable characters.")
     Dep("carriage\rreturn").should be_nil
   end
+  it "should allow deps with unicode characters in their names" do
+    L{
+      Dep.new "☕script", Base.sources.anonymous, [], {}, nil
+    }.should_not raise_error
+    Dep("☕script").should be_an_instance_of(Dep)
+  end
   it "should reject deps slashes in their names" do
     L{
       Dep.new "slashes/invalidate names", Base.sources.anonymous, [], {}, nil
@@ -21,6 +29,7 @@ describe "Dep.new" do
     Dep("slashes/invalidate names").should be_nil
   end
   it "should reject deps colons in their names" do
+    GitHelpers.stub!(:git) # To avoid cloning.
     L{
       Dep.new "colons:invalidate names", Base.sources.anonymous, [], {}, nil
     }.should raise_error(InvalidDepName, "The dep name 'colons:invalidate names' contains ':', which isn't allowed (colons separate dep and template names from source prefixes).")
@@ -83,7 +92,7 @@ describe Dep, '.find_or_suggest' do
   end
   context "namespaced" do
     before {
-      Dep.stub!(:suggest_value_for).and_return(nil)
+      Prompt.stub!(:suggest_value_for).and_return(nil)
       @source = Source.new(nil, :name => 'namespaced')
       Source.stub!(:present).and_return([@source])
       Base.sources.load_context :source => @source do
@@ -91,9 +100,12 @@ describe Dep, '.find_or_suggest' do
       end
     }
     it "should not find the dep without a namespace" do
+      Babushka::Levenshtein.stub!(:distance).and_return(20) # For performance.
       Dep.find_or_suggest('namespaced Dep.find_or_suggest tests').should be_nil
     end
     it "should not find the dep with an incorrect namespace" do
+      Babushka::Levenshtein.stub!(:distance).and_return(20) # For performance.
+      GitHelpers.stub!(:git) # To avoid cloning.
       Dep.find_or_suggest('incorrect:namespaced Dep.find_or_suggest tests').should be_nil
     end
     it "should find the dep with the correct namespace" do
@@ -118,7 +130,7 @@ describe Dep, '.find_or_suggest' do
         @sub_dep = dep 'Dep.find_or_suggest sub-dep'
       }
       it "should find the sub dep" do
-        @sub_dep.should_receive :process
+        @sub_dep.should_receive :process!
         @namespaced_dep.process
       end
     end
@@ -129,7 +141,7 @@ describe Dep, '.find_or_suggest' do
         end
       }
       it "should find the sub dep" do
-        @sub_dep.should_receive :process
+        @sub_dep.should_receive :process!
         @namespaced_dep.process
       end
     end
@@ -228,18 +240,18 @@ describe Dep, "defining" do
     Base.sources.stub!(:current_real_load_source).and_return(Base.sources.anonymous)
   }
   it "should not define the dep when called without a block" do
-    dep('lazy defining test').dep_defined?.should == nil
+    dep('lazy defining test').context.should_not be_loaded
   end
   it "should not define the dep when called with a block" do
     dep('lazy defining test with block') do
       requires 'another dep'
-    end.dep_defined?.should == nil
+    end.context.should_not be_loaded
   end
   context "after running" do
     it "should be defined" do
       dep('lazy defining test with run').tap {|dep|
         dep.met?
-      }.dep_defined?.should == true
+      }.context.should be_loaded
     end
     context "with a template" do
       let!(:template) { meta 'lazy_defining_template' }
@@ -250,6 +262,18 @@ describe Dep, "defining" do
       end
     end
   end
+  context "with params" do
+    it "should run against subsequent parameters" do
+      parameter = Parameter.new(:arg)
+      dep('parameter preserving', :arg) {
+        arg.default!('a default value')
+      }.tap {|dep|
+        dep.met?('some other value')
+        dep.met?(parameter)
+      }
+      parameter.description.should == 'arg: [default!: "a default value"]'
+    end
+  end
   context "with errors" do
     before {
       Base.sources.stub!(:current_real_load_source).and_return(Base.sources.anonymous)
@@ -258,26 +282,26 @@ describe Dep, "defining" do
       dep('lazy defining test with errors') do
         nonexistent_method
       end.tap {|dep|
-        dep.dep_defined?.should == nil
+        dep.context.should_not be_loaded
         dep.met?
-      }.dep_defined?.should == false
+      }.context.should be_failed
     end
-  end
-  context "repeatedly" do
-    it "should only ever define the dep once" do
-      dep('lazy defining test with repetition').tap {|dep|
-        dep.met?
-        dep.context.should_receive(:define!).never
-        dep.met?
-      }
+    it "should not attempt to run" do
+      dep('lazy defining test with errors') do
+        nonexistent_method
+      end.tap {|dep|
+        dep.should_not_receive(:process_deps)
+        dep.should_not_receive(:process_self)
+      }.met?
     end
-    it "should not overwrite custom blocks" do
-      dep('lazy defining test with block overwriting') do
-        setup { 'initial' }
+    it "should not attempt to run later" do
+      dep('lazy defining test with errors') do
+        nonexistent_method
       end.tap {|dep|
-        dep.context.setup { 'custom' }
-        dep.send(:define!)
-      }.send(:process_task, :setup).should == 'custom'
+        dep.met?
+        dep.should_not_receive(:process_deps)
+        dep.should_not_receive(:process_self)
+      }.met?
     end
   end
 end
@@ -320,6 +344,21 @@ describe Dep, '#basename' do
   end
 end
 
+describe Dep, '#cache_key' do
+  it "should work for parameterless deps" do
+    dep('cache key, no params').cache_key.should == DepRequirement.new('cache key, no params', [])
+  end
+  it "should work for parameterised deps with no args" do
+    dep('cache key, no args', :arg1, :arg2).cache_key.should == DepRequirement.new('cache key, no args', [nil, nil])
+  end
+  it "should work for parameterised deps with named args" do
+    dep('cache key, named args', :arg1, :arg2).with(:arg2 => 'value').cache_key.should == DepRequirement.new('cache key, named args', [nil, 'value'])
+  end
+  it "should work for parameterised deps positional args" do
+    dep('cache key, positional args', :arg1, :arg2).with('value', 'another').cache_key.should == DepRequirement.new('cache key, positional args', ['value', 'another'])
+  end
+end
+
 describe Dep, "params" do
   describe "non-symbol params" do
     it "should be rejected, singular" do
@@ -334,25 +373,30 @@ describe Dep, "params" do
     end
   end
   it "should define methods on the context" do
-    dep('params test', :a_param).context.should respond_to(:a_param)
+    dep('params test', :a_param).context.define!.should respond_to(:a_param)
   end
   it "should raise on conflicting methods" do
     L{
-      dep('conflicting param names', :name).context
+      dep('conflicting param names', :name).context.define!
     }.should raise_error(DepParameterError, "You can't use :name as a parameter (on 'conflicting param names'), because that's already a method on Babushka::DepDefiner.")
   end
+  it "should discard the context" do
+    dep('context discarding').tap {|dep|
+      dep.context.should_not == dep.with.context
+    }
+  end
   it "should not pollute other deps" do
     dep('params test', :a_param)
-    Dep('params test').context.should respond_to(:a_param)
-    dep('paramless dep').context.should_not respond_to(:a_param)
+    Dep('params test').context.define!.should respond_to(:a_param)
+    dep('paramless dep').context.define!.should_not respond_to(:a_param)
   end
   it "should return a param containing the value when it's set" do
     dep('set params test', :a_set_param)
-    Dep('set params test').with('a value').context.a_set_param.should be_an_instance_of(Parameter)
-    Dep('set params test').with('a value').context.a_set_param.to_s.should == 'a value'
+    Dep('set params test').with('a value').context.define!.a_set_param.should be_an_instance_of(Parameter)
+    Dep('set params test').with('a value').context.define!.a_set_param.to_s.should == 'a value'
   end
   it "should ask for the value when it's not set" do
-    dep('unset params test', :an_unset_param)
+    dep('unset params test', :an_unset_param).context.define!
     Dep('unset params test').context.an_unset_param.should be_an_instance_of(Parameter)
     Prompt.should_receive(:get_value).with('an_unset_param', {}).and_return('a value from the prompt')
     Dep('unset params test').context.an_unset_param.to_s.should == 'a value from the prompt'
@@ -361,32 +405,34 @@ end
 
 describe Dep, 'lambda lists' do
   before {
-    Babushka::Base.host.stub!(:name).and_return(:test_name)
-    Babushka::Base.host.stub!(:system).and_return(:test_system)
-    Babushka::Base.host.stub!(:pkg_helper_key).and_return(:test_helper)
+    Babushka.host.matcher.stub!(:name).and_return(:test_name)
+    Babushka.host.matcher.stub!(:system).and_return(:test_system)
+    Babushka.host.matcher.stub!(:pkg_helper_key).and_return(:test_helper)
 
     Babushka::SystemDefinitions.stub!(:all_names).and_return([:test_name, :other_name])
     Babushka::SystemDefinitions.stub!(:all_systems).and_return([:test_system, :other_system])
     Babushka::PkgHelper.stub!(:all_manager_keys).and_return([:test_helper, :other_helper])
   }
   it "should match against the system name" do
-    dep('lambda list name match') { requires { on :test_name, 'awesome' } }.context.requires.should == ['awesome']
+    dep('lambda list name match') { requires { on :test_name, 'awesome' } }.context.define!.requires.should == ['awesome']
   end
   it "should match against the system type" do
-    dep('lambda list system match') { requires { on :test_system, 'awesome' } }.context.requires.should == ['awesome']
+    dep('lambda list system match') { requires { on :test_system, 'awesome' } }.context.define!.requires.should == ['awesome']
   end
   it "should match against the system name" do
-    dep('lambda list pkg_helper_key match') { requires { on :test_helper, 'awesome' } }.context.requires.should == ['awesome']
+    dep('lambda list pkg_helper_key match') { requires { on :test_helper, 'awesome' } }.context.define!.requires.should == ['awesome']
   end
 end
 
 describe Dep, '#requirements_for' do
   let(:dependency) {
-    dep 'requirements_for specs' do
+    dep('requirements_for specs') {
       requires 'a dep'
       requires 'another dep'.with(:some, :args)
       requires 'a third'.with()
-    end
+    }.tap {|d|
+      d.context.define!
+    }
   }
   let(:requirements) {
     dependency.send(:requirements_for, :requires)
@@ -394,8 +440,8 @@ describe Dep, '#requirements_for' do
   it "should have the right number of requirements" do
     requirements.length.should == 3
   end
-  it "should return a Requirement for all the required deps" do
-    requirements.each {|c| c.should be_an_instance_of(Babushka::Dep::Requirement) }
+  it "should return a DepRequirement for all the required deps" do
+    requirements.each {|c| c.should be_an_instance_of(Babushka::DepRequirement) }
   end
   it "should contain the right dep names" do
     requirements.map(&:name).should == ['a dep', 'another dep', 'a third']
@@ -466,7 +512,7 @@ describe "calling meet on a single dep" do
   end
   it "should fail fast and return nil on explicitly unmeetable deps" do
     make_counter_dep(
-      :name => 'explicitly unmeetable', :met? => L{ unmeetable }
+      :name => 'explicitly unmeetable', :met? => L{ unmeetable! }
     ).meet.should == nil
     @yield_counts['explicitly unmeetable'].should == @yield_counts_met_run
   end
@@ -484,7 +530,7 @@ describe "calling meet on a single dep" do
   end
   it "should fail, not run meet, and fail again on unmet deps where meet raises UnmeetableDep" do
     make_counter_dep(
-      :name => 'unmet, #before fails', :met? => L{ false }, :meet => L{ unmeetable }
+      :name => 'unmet, #before fails', :met? => L{ false }, :meet => L{ unmeetable! }
     ).meet.should == nil
     @yield_counts['unmet, #before fails'].should == @yield_counts_early_exit_meet_run
   end
@@ -502,66 +548,3 @@ describe "calling meet on a single dep" do
   end
   after { Base.sources.anonymous.deps.clear! }
 end
-
-describe "run_in" do
-  it "should run in the current directory when run_in isn't set" do
-    cwd = Dir.pwd
-    ran_in = nil
-    dep 'dep without run_in set' do
-      met? { ran_in = Dir.pwd }
-    end.met?
-    Dir.pwd.should == cwd
-    ran_in.should == cwd
-  end
-  it "should not run when run_in is set to a nonexistent directory" do
-    ran_in = nil
-    dep 'dep with run_in set' do
-      run_in tmp_prefix / 'nonexistent'
-      met? { ran_in = Dir.pwd }
-    end.met?
-    ran_in.should be_nil
-  end
-  it "should run in the specified directory when run_in is set" do
-    cwd = Dir.pwd
-    ran_in = nil
-    dep 'dep with run_in set' do
-      run_in tmp_prefix
-      met? { ran_in = Dir.pwd }
-    end.met?
-    Dir.pwd.should == cwd
-    ran_in.should == tmp_prefix
-  end
-  it "should run this deps' requirements in the original directory" do
-    cwd = Dir.pwd
-    ran_in = child_ran_in = nil
-    dep 'another without run_in set' do
-      met? { child_ran_in = Dir.pwd }
-    end
-    dep 'dep with run_in set' do
-      requires 'another without run_in set'
-      run_in tmp_prefix
-      met? { ran_in = Dir.pwd }
-    end.met?
-    Dir.pwd.should == cwd
-    ran_in.should == tmp_prefix
-    child_ran_in.should == cwd
-  end
-  it "should run this deps' requirements in their own directories when specified" do
-    cwd = Dir.pwd
-    ran_in = child_ran_in = nil
-    (tmp_prefix / 'run_in').mkdir
-    dep 'another with run_in set' do
-      run_in tmp_prefix / 'run_in'
-      met? { child_ran_in = Dir.pwd }
-    end
-    dep 'dep with run_in set' do
-      requires 'another with run_in set'
-      run_in tmp_prefix
-      met? { ran_in = Dir.pwd }
-    end.met?
-    Dir.pwd.should == cwd
-    ran_in.should == tmp_prefix
-    child_ran_in.should == tmp_prefix / 'run_in'
-  end
-  after { Base.sources.anonymous.deps.clear! }
-end