rubycut-babushka 0.10.6

data/spec/babushka/ip_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "IP" do
+  it "should accept IPs, arrays and strings" do
+    IP.new(IP.new('10.0.1.1')).to_s.should == '10.0.1.1'
+    IP.new([10, 0, 1, 1]).to_s.should == '10.0.1.1'
+    IP.new('10.0.1.1').to_s.should == '10.0.1.1'
+  end
+  it "should work for valid IPs" do
+    [
+      '10.0.1.1'      ,
+      '192.168.0.1'   ,
+      '174.129.110.43'
+    ].each {|string|
+      IP.new(string).should be_valid
+    }
+  end
+  it "should work for invalid IPs" do
+    [
+      '10.0.1.'        ,
+      '.10.0.1'        ,
+      '192.168.0'      ,
+      '192.168.0.c'    ,
+      '174.129.110.433'
+    ].each {|string|
+      IP.new(string).should_not be_valid
+    }
+  end
+  describe "equality" do
+    it "should be equal to equivalent IPs" do
+      IP.new('10.0.1.1').should == IP.new([10, 0, 1, 1])
+    end
+    it "should not be equal to different IPs" do
+      IP.new('10.0.1.1').should_not == IP.new('10.0.0.1')
+      IP.new('10.0.1.1').should_not == IP.new('10.0.1')
+    end
+  end
+  describe "#next" do
+    it "should return the next IP in the range" do
+      IP.new('10.0.1.1').next.to_s.should == '10.0.1.2'
+      IP.new('10.0.1.255').next.to_s.should == '10.0.2.0'
+      IP.new('10.13.37.1').next.to_s.should == '10.13.37.2'
+    end
+  end
+  describe "#prev" do
+    it "should return the previous IP in the range" do
+      IP.new('10.0.1.2').prev.to_s.should == '10.0.1.1'
+      IP.new('10.0.2.0').prev.to_s.should == '10.0.1.255'
+      IP.new('10.13.37.255').prev.to_s.should == '10.13.37.254'
+    end
+  end
+end
+
+describe "IPRange" do
+  it "should work for valid IPs" do
+    [
+      '10.0.1.x'   ,
+      '10.0.x'     ,
+      '174.129.x.x'
+    ].each {|string|
+      IPRange.new(string).should be_valid
+    }
+  end
+  it "should work for invalid IPs" do
+    [
+      '10.0.1.1'    ,
+      '10.0.x.1'    ,
+      '10.0.x.'     ,
+      '174.129.110.',
+      '174.129.x.43'
+    ].each {|string|
+      IPRange.new(string).should_not be_valid
+    }
+  end
+  it "should collapse multiple wildcards" do
+    IPRange.new('10.0.1.x').bytes.should == [10, 0, 1, 'x']
+    IPRange.new('10.x').bytes.should == [10, 'x']
+    IPRange.new('10.x.x.x').bytes.should == [10, 'x']
+    IPRange.new('10.0.x').bytes.should == [10, 0, 'x']
+    IPRange.new('10.0.x.x').bytes.should == [10, 0, 'x']
+  end
+  describe "#padded_bytes" do
+    it "should pad the ranges back out to 4 terms" do
+      IPRange.new('10.0.1.x').padded_bytes.should == [10, 0,   1,   'x']
+      IPRange.new('10.x').padded_bytes.should     == [10, 'x', 'x', 'x']
+      IPRange.new('10.x.x.x').padded_bytes.should == [10, 'x', 'x', 'x']
+      IPRange.new('10.0.x').padded_bytes.should   == [10, 0,   'x', 'x']
+      IPRange.new('10.0.x.x').padded_bytes.should == [10, 0,   'x', 'x']
+    end
+  end
+  describe "#first" do
+    it "should return the first IP in the range" do
+      IPRange.new('10.0.x').first.should == IP.new('10.0.0.1')
+      IPRange.new('10.13.37.x').first.should == IP.new('10.13.37.1')
+    end
+  end
+  describe "#last" do
+    it "should return the last IP in the range" do
+      IPRange.new('10.0.x').last.should == IP.new('10.0.255.255')
+      IPRange.new('10.13.37.x').last.should == IP.new('10.13.37.255')
+    end
+  end
+  describe "#ip_for" do
+    it "should combine network and address parts" do
+      IPRange.new('10.0.1.x').ip_for('x.x.x.1').should == IP.new('10.0.1.1')
+      IPRange.new('10.13.37.x').ip_for('x.254').should == IP.new('10.13.37.254')
+    end
+    it "should default uncovered sections to 0" do
+      IPRange.new('10.0.x').ip_for('x.x.x.1').should == IP.new('10.0.0.1')
+      IPRange.new('10.x').ip_for('x.254').should == IP.new('10.0.0.254')
+    end
+  end
+  describe "#subnet" do
+    it "should return the subnet mask" do
+      IPRange.new('10.0.1.x').subnet.should == '255.255.255.0'
+      IPRange.new('10.x')    .subnet.should == '255.0.0.0'
+      IPRange.new('10.x.x.x').subnet.should == '255.0.0.0'
+      IPRange.new('10.0.x')  .subnet.should == '255.255.0.0'
+      IPRange.new('10.0.x.x').subnet.should == '255.255.0.0'
+    end
+  end
+  describe "#broadcast" do
+    it "should return the broadcast address" do
+      IPRange.new('10.0.1.x').broadcast.should == '10.0.1.255'
+      IPRange.new('10.x')    .broadcast.should == '10.255.255.255'
+      IPRange.new('10.x.x.x').broadcast.should == '10.255.255.255'
+      IPRange.new('10.0.x')  .broadcast.should == '10.0.255.255'
+      IPRange.new('10.0.x.x').broadcast.should == '10.0.255.255'
+    end
+  end
+end

data/spec/babushka/lambda_chooser_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+
+describe "lambda choosing" do
+  it "should return the value of the block when there are no choices" do
+    LambdaChooser.new(nil, :ours, :theirs) {
+      "block value"
+    }.choose(:ours, :on).should == "block value"
+  end
+
+  it "should choose the specified call" do
+    LambdaChooser.new(nil, :ours, :theirs) {
+      on :ours, "this is ours"
+      on :theirs, "this is theirs"
+    }.choose(:ours, :on).should == ["this is ours"]
+    describe "with a block value" do
+      LambdaChooser.new(nil, :ours, :theirs) {
+        on :ours, "this is ours"
+        on :theirs, "this is theirs"
+        "block value"
+      }.choose(:ours, :on).should == ["this is ours"]
+    end
+  end
+
+  it "should pick the first choice from multiple choices" do
+    LambdaChooser.new(nil, :ours, :yours, :theirs) {
+      on :ours, "this is ours"
+      on :yours, "this is yours"
+      on :theirs, "this is theirs"
+    }.choose([:ours, :yours], :on).should == ["this is ours"]
+    LambdaChooser.new(nil, :ours, :yours, :theirs) {
+      on :yours, "this is yours"
+      on :ours, "this is ours"
+      on :theirs, "this is theirs"
+    }.choose([:ours, :yours], :on).should == ["this is ours"]
+  end
+
+  it "should reject :otherwise as a choice name" do
+    L{
+      LambdaChooser.new(nil, :ours, :yours, :otherwise)
+    }.should raise_error(ArgumentError, "You can't use :otherwise as a choice name, because it's reserved.")
+  end
+
+  it "should pick 'otherwise' if no choices match" do
+    LambdaChooser.new(nil, :ours, :yours, :theirs) {
+      on :ours, "this is ours"
+      on :yours, "this is yours"
+      otherwise "this is the default"
+    }.choose(:theirs, :on).should == ["this is the default"]
+  end
+
+  it "should return 'nil' if no choices match and there's no 'otherwise'" do
+    LambdaChooser.new(nil, :ours, :yours, :theirs) {
+      on :yours, "this is yours"
+      on :ours, "this is ours"
+    }.choose(:theirs, :on).should == nil
+  end
+
+  it "should not join lists from multiple choices" do
+    LambdaChooser.new(
+      nil,
+      :apt, :brew, :macports, :yum, :linux, :osx, :ubuntu, :debian, :osx, :karmic, :gutsy, :lucid, :intrepid, :dapper, :breezy, :jaunty, :feisty, :edgy, :warty, :hardy, :maverick, :hoary, :lenny, :snow_leopard, :panther, :tiger, :leopard
+    ) {
+      on :maverick, %w[ruby ruby1.8-dev]
+      on :apt, %w[ruby irb ruby1.8-dev libopenssl-ruby]
+    }.choose(
+      [:maverick, :ubuntu, :apt, :linux, :all],
+      :on
+    ).should == %w[ruby ruby1.8-dev]
+  end
+
+  it "should default the choice method to #on" do
+    LambdaChooser.new(nil, :ours, :theirs) {
+      on :ours, "this is ours"
+      on :theirs, "this is theirs"
+    }.choose(:ours).should == ["this is ours"]
+    LambdaChooser.new(nil, :ours, :theirs) {
+      on :ours, "this is ours"
+      on :theirs, "this is theirs"
+    }.choose(:ours, nil).should == ["this is ours"]
+  end
+
+  it "should reject values and block together" do
+    L{
+      LambdaChooser.new(nil, :ours, :theirs) {
+        on :ours, "this is ours"
+        on :theirs, "this is theirs" do
+          'another value'
+        end
+      }.choose(:ours, :on)
+    }.should raise_error("You can supply values or a block, but not both.")
+  end
+
+  it "should reject unknown choosers" do
+    L{
+      LambdaChooser.new(nil, :ours, :theirs) {
+        on :ours, "this is ours"
+        on :someone_elses, "this is theirs"
+      }.choose(:ours, :on)
+    }.should raise_error("The choice 'someone_elses' isn't valid.")
+  end
+
+  it "should return the data intact" do
+    {
+      "string" => ["string"],
+      %w[a r r a y] => %w[a r r a y],
+      {:h => 'a', :s => 'h'} => {:h => 'a', :s => 'h'}
+    }.each_pair {|input, expected|
+      LambdaChooser.new(nil, :ours, :theirs) {
+        on :ours, input
+        on :theirs, "this is theirs"
+      }.choose(:ours, :on).should == expected
+    }
+  end
+end

data/spec/babushka/meta_dep_definer_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'dep_definer_support'
+
+describe "declaration" do
+  before {
+    @meta = meta 'test'
+  }
+  it "should work" do
+    L{ meta 'count_test' }.should change(Base.sources.anonymous.templates, :count).by(1)
+  end
+  it "should set the name" do
+    @meta.name.should == 'test'
+  end
+  it "should downcase the name" do
+    meta("Case_Test").name.should == 'case_test'
+  end
+  it "should set the source" do
+    @meta.source.should == Base.sources.anonymous
+  end
+  it "should define a dep context" do
+    @meta.context_class.should be_an_instance_of(Class)
+    @meta.context_class.ancestors.should include(Babushka::DepContext)
+  end
+  it "should define template on the context" do
+    @meta.context_class.source_template.should == @meta
+  end
+  it "should not define a dep helper" do
+    Object.new.should_not respond_to('test')
+  end
+  it "should not be marked as suffixed" do
+    @meta.opts[:suffix].should be_false
+  end
+  after { Base.sources.anonymous.templates.clear! }
+end
+
+describe "using" do
+  describe "invalid templates" do
+    it "should not define deps as options" do
+      L{
+        dep('something undefined', :template => 'undefined').should be_nil
+      }.should raise_error(TemplateNotFound, "There is no template named 'undefined' to define 'something undefined' against.")
+    end
+    it "should define deps as options" do
+      dep('something.undefined').should be_an_instance_of(Dep)
+    end
+  end
+
+  describe "without template" do
+    before {
+      @meta = meta('templateless_test') {}
+    }
+    it "should define deps based on the template" do
+      dep('templateless dep.templateless_test').template.should == @meta
+    end
+    after { Base.sources.anonymous.templates.clear! }
+  end
+
+  describe "with template" do
+    before {
+      @meta = meta 'template_test' do
+        def a_helper_method
+          'hello from the helper!'
+        end
+        template {
+          def a_helper
+            'hello from the helper in the template!'
+          end
+          met? {
+            'this dep is met.'
+          }
+        }
+      end
+    }
+    it "should define the helper on the context class" do
+      @meta.context_class.respond_to?(:a_helper).should be_false
+      @meta.context_class.new(nil).respond_to?(:a_helper).should be_false
+      dep('dep1.template_test').context.respond_to?(:a_helper).should be_true
+    end
+    it "should correctly define the helper method" do
+      dep('dep2.template_test').context.a_helper_method.should == 'hello from the helper!'
+    end
+    it "should correctly define the helper" do
+      dep('dep2.template_test').context.a_helper.should == 'hello from the helper in the template!'
+    end
+    it "should correctly define the met? block" do
+      dep('dep3.template_test').send(:process_task, :met?).should == 'this dep is met.'
+    end
+    it "should override the template correctly" do
+      dep('dep4.template_test') {
+        met? { 'overridden met? block.' }
+      }.send(:process_task, :met?).should == 'overridden met? block.'
+    end
+    after { Base.sources.anonymous.templates.clear! }
+  end
+
+  describe "acceptors" do
+    before {
+      @meta = meta 'acceptor_test' do
+        accepts_list_for :list_test
+        accepts_block_for :block_test
+        template {
+          met? {
+            list_test == ['valid']
+          }
+          meet {
+            block_test.call
+          }
+        }
+      end
+    }
+    it "should handle accepts_list_for" do
+      dep('unmet accepts_list_for.acceptor_test') { list_test 'invalid' }.met?.should be_false
+      dep('met accepts_list_for.acceptor_test') { list_test 'valid' }.met?.should be_true
+    end
+    it "should handle accepts_block_for" do
+      block_called = false
+      dep('accepts_block_for.acceptor_test') {
+        list_test 'invalid'
+        block_test {
+          block_called = true
+        }
+      }.meet
+      block_called.should be_true
+    end
+    after { Base.sources.anonymous.templates.clear! }
+  end
+end

data/spec/babushka/meta_dep_wrapper_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe "name checks" do
+  it "should not allow blank names" do
+    L{ meta(nil) }.should raise_error(ArgumentError, "You can't define a template with a blank name.")
+    L{ meta('') }.should raise_error(ArgumentError, "You can't define a template with a blank name.")
+  end
+  it "should not allow reserved names" do
+    L{ meta(:base) }.should raise_error(ArgumentError, "You can't use 'base' for a template name, because it's reserved.")
+  end
+  it "should allow valid names" do
+    L{ meta(:a) }.should_not raise_error
+    L{ meta('b') }.should_not raise_error
+    L{ meta('valid') }.should_not raise_error
+  end
+  it "should not allow spaces and numbers" do
+    L{ meta('meta dep 2') }.should raise_error(ArgumentError, "You can't use 'meta dep 2' for a template name - it can only contain [a-z0-9_].")
+  end
+  it "should not allow invalid characters" do
+    L{ meta("meta\ndep") }.should raise_error(ArgumentError, "You can't use 'meta\ndep' for a template name - it can only contain [a-z0-9_].")
+  end
+  it "should not allow names that don't start with a letter" do
+    L{ meta('3d_dep') }.should raise_error(ArgumentError, "You can't use '3d_dep' for a template name - it must start with a letter.")
+  end
+  describe "duplicate declaration" do
+    before { meta 'duplicate' }
+    it "should be prevented" do
+      L{ meta(:duplicate) }.should raise_error(ArgumentError, "A template called 'duplicate' has already been defined.")
+    end
+    after { Base.sources.anonymous.templates.clear! }
+  end
+end

data/spec/babushka/parameter_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Parameter do
+  it "should not be set without a value" do
+    Parameter.new(:test).set?.should be_false
+  end
+  it "should be set with a value" do
+    Parameter.new(:test, 'testy test').set?.should be_true
+  end
+
+  describe ".for" do
+    let(:input) { 'testy test' }
+    let(:param) { Parameter.for(:test, input) }
+    it "should return a parameter" do
+      param.should be_an_instance_of(Parameter)
+    end
+    context "with Parameter input" do
+      let(:input) { Parameter.new(:test, 'testy test') }
+      it "should not re-wrap the Parameter" do
+        Parameter.for(:test, input).object_id.should == input.object_id
+      end
+    end
+  end
+
+  describe "#==" do
+    it "should behave like a string when it's set" do
+      Parameter.new(:test, "a value").should == "a value"
+      Parameter.new(:test, "a value").should_not == "another value"
+    end
+    it "should prompt when the value isn't set" do
+      Prompt.should_receive(:get_value)
+      Parameter.new(:test) == "a value"
+    end
+  end
+
+  describe "#to_s" do
+    it "should delegate to the value" do
+      Parameter.new(:test, "a value").to_s.should == "a value"
+    end
+    it "should convert non-string values to strings" do
+      Parameter.new(:test, 3065).to_s.should == "3065"
+    end
+    it "should interpolate" do
+      "a #{Parameter.new(:adjective, "nice")} param".should == "a nice param"
+    end
+  end
+
+  describe "#to_str" do
+    it "should delegate to the value" do
+      File.exists?(Parameter.new(:path, "/bin")).should be_true
+    end
+    it "should fail when the value itself would fail" do
+      parameter = Parameter.new(:path, 3065)
+      message = if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+        "Coercion error: #<Babushka::Parameter:#{parameter.object_id} path: 3065>.to_str => String failed"
+      else
+        "Can't coerce 3065:Fixnum into a String"
+      end
+      L{
+        File.exists?(parameter)
+      }.should raise_error(TypeError, message)
+    end
+  end
+
+  describe '#description' do
+    it "should describe unset parameters" do
+      Parameter.new(:test).description.should == 'test: [unset]'
+    end
+    it "should describe unset parameters with defaults" do
+      Parameter.new(:test).default("a default").description.should == 'test: [default: "a default"]'
+    end
+    it "should describe unset parameters with bang-defaults" do
+      Parameter.new(:test).default!("a bang-default").description.should == 'test: [default!: "a bang-default"]'
+    end
+    it "should describe set parameters" do
+      Parameter.new(:test, "a value").description.should == 'test: "a value"'
+    end
+    it "should describe non-string values" do
+      Parameter.new(:test, %w[non-string value]).description.should == 'test: ["non-string", "value"]'
+    end
+  end
+
+  describe "other stringy methods" do
+    it "should work with #/" do
+      (Parameter.new(:test, "/path") / 'joining') == "/path/joining"
+    end
+    it "should work with #[]" do
+      Parameter.new(:test, "The Rural Jurour")[/ur/].should == 'ur'
+    end
+    it "should work with #p" do
+      Parameter.new(:test, "/bin").p.should be_an_instance_of(Fancypath)
+    end
+  end
+
+  describe "#default!" do
+    it "should be returned when no value is set" do
+      Parameter.new(:unset).default!('default!').to_s.should == 'default!'
+    end
+    it "should be ignored when a value is set" do
+      Parameter.new(:set, 'value').default!('default!').to_s.should == 'value'
+    end
+    it "should take precedence over default values" do
+      Parameter.new(:unset).default!('default!').default('default').to_s.should == 'default!'
+    end
+  end
+
+  describe "asking for values" do
+    it "should request a value when it's not present" do
+      Prompt.should_receive(:get_value).with('unset', {}).and_return('value')
+      Parameter.new(:unset).to_s.should == 'value'
+    end
+    it "should pass the default from #default" do
+      Prompt.should_receive(:get_value).with('unset', :default => 'default').and_return('default')
+      Parameter.new(:unset).default('default').to_s.should == 'default'
+    end
+    it "should pass the message from #ask" do
+      Prompt.should_receive(:get_value).with('What number am I thinking of', {}).and_return('7')
+      Parameter.new(:unset).ask('What number am I thinking of').to_s.should == '7'
+    end
+    describe "choices, from #choose" do
+      it "should pass to #choices when given as an array" do
+        Prompt.should_receive(:get_value).with('unset', :choices => %w[a b]).and_return('a')
+        Parameter.new(:unset).choose(%w[a b]).to_s.should == 'a'
+      end
+      it "should pass to #choices when given as splatted args" do
+        Prompt.should_receive(:get_value).with('unset', :choices => %w[a b]).and_return('a')
+        Parameter.new(:unset).choose('a', 'b').to_s.should == 'a'
+      end
+      it "should pass to #choice_descriptions when given as a hash" do
+        Prompt.should_receive(:get_value).with('unset', :choice_descriptions => {:a => 'a', :b => 'b'}).and_return('a')
+        Parameter.new(:unset).choose(:a => 'a', :b => 'b').to_s.should == 'a'
+      end
+    end
+  end
+end