rubycut-babushka 0.10.6

data/spec/babushka/cmdline/console_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "console" do
+  before {
+    entry_point = File.expand_path(File.join(__FILE__, '../../../../lib/babushka'))
+    Cmdline.should_receive(:exec).with("irb -r'#{entry_point}' --simple-prompt")
+  }
+  it "should launch a console via Kernel#exec" do
+    Cmdline::Parser.for(%w[console]).run
+  end
+end

data/spec/babushka/cmdline/help_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "help" do
+  context "with no verb" do
+    before {
+      [
+        "Babushka v#{Babushka::VERSION}, (c) 2011 Ben Hoskings <ben@hoskings.net>",
+        "\nThe gist:",
+        "  #{Base.program_name} <command> [options]",
+        "\nAlso:",
+        "  #{Base.program_name} help <command>  # Print command-specific usage info",
+        "  #{Base.program_name} <dep name>      # A shortcut for 'babushka meet <dep name>'",
+        "  #{Base.program_name} babushka        # Update babushka itself (what babushka.me/up does)",
+        "\nCommands:",
+        "  help       Print usage information",
+        "  version    Print the current version",
+        "  list       List the available deps",
+        "  meet       The main one: run a dep and all its dependencies.",
+        "  sources    Manage dep sources",
+        "  console    Start an interactive (irb-based) babushka session",
+        "  search     Search for deps in the community database",
+        "  edit       Load the file containing the specified dep in $EDITOR",
+        "\nCommands can be abbrev'ed, as long as they remain unique.",
+        "  e.g. '#{Base.program_name} l' is short for '#{Base.program_name} list'.",
+        "\n"
+      ].each {|line|
+        Cmdline::Helpers.should_receive(:log).with(line)
+      }
+    }
+    it "should print the verb help information" do
+      Cmdline::Parser.for(%w[help]).run
+    end
+  end
+  context "with a verb" do
+    let(:parser) { Cmdline::Parser.for(%w[help meet]) }
+    before {
+      [
+        "Babushka v#{Babushka::VERSION}, (c) 2011 Ben Hoskings <ben@hoskings.net>",
+        "\nmeet - The main one: run a dep and all its dependencies."
+      ].each {|line|
+        Cmdline::Helpers.should_receive(:log).with(line)
+      }
+
+      parser.should_receive(:log).with("
+    -v, --version                    Print the current version
+    -h, --help                       Show this information
+    -d, --debug                      Show more verbose logging, and realtime shell command output
+        --[no-]color, --[no-]colour  Disable color in the output
+    -n, --dry-run                    Discover the curent state without making any changes
+    -y, --defaults                   Assume the default value for all vars without prompting, where possible
+        --show-args                  Show the arguments being passed between deps as they're run
+        --track-blocks               Track deps' blocks in TextMate as they're run
+")
+
+      Cmdline::Helpers.should_receive(:log).with("\n")
+    }
+    it "should print the help information for the verb" do
+      parser.run
+    end
+  end
+end

data/spec/babushka/cmdline/version_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "version" do
+  before {
+    Cmdline::Helpers.should_receive(:log).with(Babushka::VERSION)
+  }
+  it "should print the version" do
+    Cmdline::Parser.for(%w[version]).run
+  end
+end

data/spec/babushka/core_patches_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Array, "to_list" do
+  it "no elements" do
+    [].to_list.should == ''
+  end
+  it "single element" do
+    %w[a].to_list.should == 'a'
+  end
+  it "two elements" do
+    %w[a b].to_list.should == 'a and b'
+  end
+  it "three elements" do
+    %w[a b c].to_list.should == 'a, b and c'
+  end
+  it "oxford comma" do
+    %w[a b c].to_list(:oxford => true).should == 'a, b, and c'
+  end
+  it "custom conjugation" do
+    %w[a b c].to_list(:conj => 'or').should == 'a, b or c'
+  end
+  describe "limits" do
+    it "below limit" do
+      %w[a b c].to_list(:limit => 4).should == 'a, b and c'
+    end
+    it "at limit" do
+      %w[a b c].to_list(:limit => 3).should == 'a, b and c'
+    end
+    it "above limit" do
+      %w[a b c].to_list(:limit => 2).should == 'a, b et al'
+      %w[a b c d e].to_list(:limit => 4).should == 'a, b, c, d et al'
+    end
+    it "with noun" do
+      %w[a b c].to_list(:limit => 2, :noun => 'items').should == 'a, b et al - 3 items'
+    end
+  end
+end
+
+describe Array, '#collapse' do
+  it "should work for empty lists" do
+    [].collapse('blah').should == []
+    [].collapse(/blah/).should == []
+  end
+  it "should select surnames from a list" do
+    [
+      'Ben Hoskings',
+      'Nathan Sampimon',
+      'Nathan de Vries'
+    ].collapse(/Nathan /).should == ['Sampimon', 'de Vries']
+  end
+  it "should strip git branch prefixes" do
+    [
+      '  next',
+      '* master',
+      '  topic'
+    ].collapse(/^\* /).should == [
+      'master'
+    ]
+  end
+  it "should use the replacement if passed" do
+    [
+      "Chain fail2ban-nginx-catchall (1 references)",
+      "target     prot opt source               destination",
+      "DROP       all  --  58.161.41.76         0.0.0.0/0  ",
+      "RETURN     all  --  0.0.0.0/0            0.0.0.0/0  "
+    ].collapse(/^DROP\s+[^\d]+([\d\.]+)\s+.*/, '\1').should == [
+      '58.161.41.76'
+    ]
+  end
+end
+
+describe Array, '#local_group_by' do
+  it "should work for empty lists" do
+    [].group_by(&:length).should == {}
+  end
+  it "should do what you expect" do
+    %w[cat badger narwahl pug].local_group_by(&:length).should == {
+      3 => %w[cat pug],
+      6 => %w[badger],
+      7 => %w[narwahl]
+    }
+  end
+  it "should work with nils and such" do
+    %w[cat badger narwahl pug].local_group_by {|i|
+      i[/a[rt]/]
+    }.should == {
+      nil => %w[badger pug],
+      'at' => %w[cat],
+      'ar' => %w[narwahl]
+    }
+  end
+  it "should return nil for keys that don't match a group" do
+    %w[cat badger narwahl pug].local_group_by(&:length)[4].should be_nil
+  end
+end
+
+def version_of *args
+  Babushka::VersionOf::Helpers.VersionOf *args
+end
+
+
+describe Array, '#versions' do
+  {
+    %w[a]     => [version_of('a')],
+    %w[a b c] => [version_of('a'), version_of('b'), version_of('c')],
+    [version_of('a')] => [version_of('a')],
+    ['a 0.1', 'b >= 0.6.0', 'c ~> 2.2'] => [version_of('a', '0.1'), version_of('b', '>= 0.6.0'), version_of('c', '~> 2.2')]
+  }.each_pair {|input, expected|
+    it "should return #{expected.inspect} when passed #{input.inspect}" do
+      input.versions.should == expected
+    end
+  }
+end
+
+describe Hash, '#defaults!' do
+  it "should work for empty hashes" do
+    {}.defaults!(:a => 'b', :c => 'd').should == {:a => 'b', :c => 'd'}
+  end
+  it "should work for empty defaults" do
+    {:a => 'custom b', :c => 'custom d'}.defaults!({}).should == {:a => 'custom b', :c => 'custom d'}
+  end
+  it "should combine defaults with the hash" do
+    {:a => 'custom b', :c => 'custom d'}.defaults!({:e => 'f', :g => 'h'}).should == {:a => 'custom b', :c => 'custom d', :e => 'f', :g => 'h'}
+  end
+  it "should override default values" do
+    {:a => 'custom b', :e => 'custom e'}.defaults!({:e => 'f', :g => 'h'}).should == {:a => 'custom b', :e => 'custom e', :g => 'h'}
+  end
+end
+
+describe String, "val_for" do
+  it "space separation" do
+    'key value'.val_for('key').should == 'value'
+  end
+  it "key/value separation" do
+    'key: value'.val_for('key').should == 'value'
+    'key = value'.val_for('key').should == 'value'
+  end
+  it "whitespace" do
+    '  key value '.val_for('key').should == 'value'
+  end
+  it "whitespace in key" do
+    'space-separated key: value'.val_for('space-separated key').should == 'value'
+  end
+  it "whitespace in value" do
+    'key: space-separated value'.val_for('key').should == 'space-separated value'
+  end
+  it "whitespace in both" do
+    'key with spaces: space-separated value'.val_for('key with spaces').should == 'space-separated value'
+  end
+  it "key ending in non-word characters" do
+    "psql (PostgreSQL) 9.1.0".val_for('psql (PostgreSQL)').should == '9.1.0'
+  end
+  it "non-word leading characters" do
+    '*key: value'.val_for('*key').should == 'value'
+    '-key: value'.val_for('-key').should == 'value'
+    '-key: value'.val_for('key').should == nil
+  end
+  it "non-word leading tokens" do
+    '* key: value'.val_for('key').should == 'value'
+    '- key with spaces: value'.val_for('key with spaces').should == 'value'
+    ' --  key with spaces: value'.val_for('key with spaces').should == 'value'
+  end
+  it "trailing characters" do
+    'key: value;'.val_for('key').should == 'value'
+    'key: value,'.val_for('key').should == 'value'
+  end
+  it "paths" do
+    "/dev/disk1s2        	Apple_HFS                      	/Volumes/TextMate 1.5.9".val_for("/dev/disk1s2        	Apple_HFS").should == "/Volumes/TextMate 1.5.9"
+    "/dev/disk1s2        	Apple_HFS                      	/Volumes/TextMate 1.5.9".val_for(/^\/dev\/disk\d+s\d+\s+Apple_HFS\s+/).should == "/Volumes/TextMate 1.5.9"
+  end
+end

data/spec/babushka/dep_context_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'dep_definer_support'
+
+describe "accepts_block_for behaviour" do
+  before {
+    Dep.stub!(:base_template).and_return(TestTemplate)
+    setup_test_lambdas
+    dep 'default'
+  }
+
+  it "should define a declarer" do
+    Dep('default').context.should_not respond_to(:test_defining)
+    TestDepContext.accepts_block_for :test_defining
+    Dep('default').context.should respond_to(:test_defining)
+  end
+
+  it "should return lambda" do
+    TestDepContext.accepts_block_for :test_defining
+    lambda = L{ 'blah' }
+    value_from_block = nil
+    dep 'returning test' do
+      value_from_block = test_defining &lambda
+    end.met?
+    value_from_block.should == lambda
+  end
+
+  it "should accept and return a block" do
+    test_accepts_block_for_response :test_response, @lambda_hello, @lambda_hello
+  end
+  it "should accept and return a block for this system" do
+    test_accepts_block_for_response :test_this_system, @lambda_hello, @lambda_hello, :on => Base.host.system
+  end
+  it "should return nothing on a non-specified system" do
+    test_accepts_block_for_response :test_other_system, @lambda_hello, nil, :on => :nonexistent
+  end
+
+  it "should use default blocks when no specific one is specified" do
+    lambda = L{ 'default value' }
+    TestDepContext.accepts_block_for :test_defaults, &lambda
+    value_from_block = nil
+    dep 'default test' do
+      value_from_block = test_defaults
+    end.met?
+    value_from_block.should == lambda
+  end
+
+  after { Base.sources.anonymous.deps.clear! }
+end
+
+describe "accepts_list_for behaviour" do
+  before {
+    Babushka::Base.stub!(:host).and_return FakeOSXSystemProfile.new
+    make_test_deps
+  }
+  it "should choose requires for the correct system" do
+    Dep('test build tools').context.requires.should == ['xcode tools']
+  end
+end

data/spec/babushka/dep_definer_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'dep_definer_support'
+
+describe "source_template" do
+  it "should return BaseTemplate" do
+    TestDepContext.source_template.should == Dep::BaseTemplate
+  end
+end
+
+describe "args" do
+  describe "parsing style" do
+    it "should parse as named when just a single hash is passed" do
+      dep('1 arg', :a).tap {|dep|
+        dep.should_receive(:parse_named_arguments).with({:a => 'a'}).and_return({})
+        dep.with(:a => 'a')
+      }
+    end
+    it "should parse as a list when non-hash values are passed" do
+      dep('2 args', :a, :b).tap {|dep|
+        dep.should_receive(:parse_positional_arguments).with(['a', {'key' => 'value'}]).and_return({})
+        dep.with('a', 'key' => 'value')
+      }
+    end
+    it "should parse as a list when no args are passed" do
+      dep('no args').tap {|dep|
+        dep.should_receive(:parse_positional_arguments).with([]).and_return({})
+        dep.with
+      }
+    end
+  end
+  context "without arguments" do
+    it "should fail when called with unnamed args" do
+      L{ dep('no args').with('a') }.should raise_error(DepArgumentError, "The dep 'no args' accepts 0 arguments, but 1 was passed.")
+    end
+    it "should fail when called with named args that don't match" do
+      L{ dep('no args').with(:a => 'a') }.should raise_error(DepArgumentError, "The dep 'no args' received an unexpected argument :a.")
+    end
+  end
+  context "with the wrong number of arguments" do
+    it "should fail when called with the wrong number of unnamed args" do
+      L{ dep('1 arg', :a).with('a', 'b') }.should raise_error(DepArgumentError, "The dep '1 arg' accepts 1 argument, but 2 were passed.")
+      L{ dep('2 args', :a, :b).with('a') }.should raise_error(DepArgumentError, "The dep '2 args' accepts 2 arguments, but 1 was passed.")
+    end
+    it "should fail when called with named args that don't match" do
+      L{ dep('1 arg', :a).with(:a => 'a', :b => 'b') }.should raise_error(DepArgumentError, "The dep '1 arg' received an unexpected argument :b.")
+      L{ dep('1 arg', :a).with(:a => 'a', :b => 'b', :c => 'c') }.should raise_error(DepArgumentError, "The dep '1 arg' received unexpected arguments :b and :c.")
+    end
+  end
+  context "with empty arguments" do
+    subject { dep('2 args', :a, :b).with() }
+    it "should populate the args with Parameter objects" do
+      subject.args.map_values {|_,v| v.class }.should == {:a => Parameter, :b => Parameter}
+    end
+    it "should set the names correctly" do
+      subject.args.map_values {|_,v| v.name }.should == {:a => :a, :b => :b}
+    end
+    it "should not set the values" do
+      subject.args.values.each {|v| v.should_not be_set }
+    end
+  end
+  context "with the right number of positional arguments" do
+    subject { dep('2 args', :a, :b).with('a', 'b') }
+    it "should populate the args with Parameter objects" do
+      subject.args.map_values {|_,v| v.class }.should == {:a => Parameter, :b => Parameter}
+    end
+    it "should set the names correctly" do
+      subject.args.map_values {|_,v| v.name }.should == {:a => :a, :b => :b}
+    end
+    it "should set the values" do
+      subject.args.values.each {|v| v.should be_set }
+    end
+  end
+  context "with the correct named arguments" do
+    subject { dep('2 args', :a, :b).with(:a => 'a', :b => 'b') }
+    it "should populate the args with Parameter objects" do
+      subject.args.map_values {|_,v| v.class }.should == {:a => Parameter, :b => Parameter}
+    end
+    it "should set the names correctly" do
+      subject.args.map_values {|_,v| v.name }.should == {:a => :a, :b => :b}
+    end
+    it "should set the values" do
+      subject.args.values.each {|v| v.should be_set }
+    end
+  end
+  context "with non-symbol names" do
+    it "should be rejected, singular" do
+      L{
+        dep('2 args', :a).with('a' => 'a')
+      }.should raise_error(DepArgumentError, %{The dep '2 args' received a non-symbol argument "a".})
+    end
+    it "should be rejected, plural" do
+      L{
+        dep('2 args', :a, :b).with('a' => 'a', 'b' => 'b')
+      }.should raise_error(DepArgumentError, %{The dep '2 args' received non-symbol arguments "a" and "b".})
+    end
+  end
+  context "with incomplete named arguments" do
+    subject { dep('2 args', :a, :b).with(:a => 'a') }
+    it "should partially populate the args with Parameter objects" do
+      subject.args.map_values {|_,v| v.class }.should == {:a => Parameter}
+    end
+    it "should set the names that are present correctly" 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
+    end
+    it "should set only the paramters that were passed" do
+      subject.context.a.should be_set
+      subject.context.b.should_not be_set
+    end
+  end
+end
+
+describe "methods in deps" do
+  before {
+    dep 'helper method test' do
+      def helper_test
+        'hello from the helper method!'
+      end
+    end
+    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)
+  end
+  it "should return the right value" do
+    Dep('helper method test').context.helper_test.should == 'hello from the helper method!'
+  end
+end
+
+describe "#on for scoping accepters" do
+  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' }
+    dep 'scoping' do
+      on :osx do
+        met?(&lambda)
+      end
+      on :linux do
+        met?(&other_lambda)
+      end
+    end
+  }
+  it "should only allow choices that match" do
+    Dep('scoping').send(:payload)[:met?].should == {:osx => @lambda}
+  end
+end