rubycut-babushka 0.10.8 → 0.15.6.1

data/spec/babushka/dep_template_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe "name checks" do
+  describe "invalid names" 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
+  end
+
+  describe "duplicates" 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
+
+  describe "valid names" do
+    it "should work" do
+      L{ meta 'count_test' }.should change(Base.sources.anonymous.templates, :count).by(1)
+    end
+    it "should downcase the name" do
+      meta("Case_Test").name.should == 'case_test'
+    end
+  end
+end
+
+describe "declaration" do
+  let(:template) { meta 'test' }
+  it "should set the name" do
+    template.name.should == 'test'
+  end
+  it "should set the source" do
+    template.source.should == Base.sources.anonymous
+  end
+  it "should define a dep context" do
+    template.context_class.should be_an_instance_of(Class)
+    template.context_class.ancestors.should include(Babushka::DepContext)
+  end
+  it "should define template on the context" do
+    template.context_class.source_template.should == template
+  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
+    template.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
+    let!(:template) { meta('templateless_test') {} }
+    it "should define deps based on the template" do
+      dep('templateless dep.templateless_test').template.should == template
+    end
+    after { Base.sources.anonymous.templates.clear! }
+  end
+
+  describe "with template" do
+    let!(:template) {
+      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
+      template.context_class.respond_to?(:a_helper).should be_false
+      template.context_class.new(nil).respond_to?(:a_helper).should be_false
+      dep('dep1.template_test').context.define!.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.define!.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
+    let!(:template) {
+      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
+
+  describe "calling accepted blocks" do
+    let(:a_meta) {
+      meta :acceptor_calling_test do
+        accepts_block_for(:testing) {
+          self
+        }
+      end
+    }
+    let(:a_dep) {
+      dep 'acceptor calling test', :template => a_meta.name
+    }
+
+    it "should run the default block in the dep's context" do
+      a_dep.context.invoke(:testing).should == a_dep.context
+    end
+  end
+end

data/spec/babushka/deps_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 require 'dep_support'
 
-shared_examples_for "met?" do
+shared_examples_for "met? when met" do
   describe "met?" do
     before { Dep('a').met? }
-    it "should met?-check each dep exactly once" do
+    it "should met?-check deps that don't have failed subdeps" do
       %w[a b c d e f].each {|i| @yield_counts[i].should == @yield_counts_already_met }
     end
     it "shouldn't run the meet-only dep" do
@@ -13,6 +13,35 @@ shared_examples_for "met?" do
   end
 end
 
+shared_examples_for "met? when unmet" do
+  describe "met?" do
+    before { Dep('a').met? }
+    it "should met?-check deps that don't have failed subdeps" do
+      %w[f].each {|i| @yield_counts[i].should == @yield_counts_already_met }
+    end
+    it "should not met?-check deps that have failed subdeps" do
+      %w[a b c d e].each {|i| @yield_counts[i].should == @yield_counts_dep_failed }
+    end
+    it "shouldn't run the meet-only dep" do
+      @yield_counts['g'].should == @yield_counts_none
+    end
+  end
+end
+
+describe "met? return value" do
+  before {
+    dep 'return value a' do
+      requires 'return value b'
+    end
+    dep 'return value b' do
+      met? { false }
+    end
+  }
+  it "should return false when subdeps are unmet" do
+    Dep('return value a').met?.should be_false
+  end
+end
+
 describe "an already met dep tree" do
   before {
     setup_yield_counts
@@ -24,7 +53,7 @@ describe "an already met dep tree" do
     make_counter_dep :name => 'f'
     make_counter_dep :name => 'g'
   }
-  it_should_behave_like "met?"
+  it_should_behave_like "met? when met"
   describe "meet" do
     before { Dep('a').meet }
     it "should meet no deps" do
@@ -48,7 +77,7 @@ describe "an unmeetable dep tree" do
     make_counter_dep :name => 'f', :met? => L{ false }
     make_counter_dep :name => 'g', :met? => L{ false }
   }
-  it_should_behave_like "met?"
+  it_should_behave_like "met? when unmet"
   describe "meet" do
     before { Dep('a').meet }
     it "should fail on the bootom-most dep" do
@@ -67,15 +96,15 @@ end
 describe "a meetable dep tree" do
   before {
     setup_yield_counts
-    make_counter_dep :name => 'a', :requires => %w[b c]  , :met? => L{ @yield_counts['a'][:met?] > 1 }
-    make_counter_dep :name => 'b', :requires => %w[c d e], :met? => L{ @yield_counts['b'][:met?] > 1 }
-    make_counter_dep :name => 'c', :requires => %w[f]    , :met? => L{ @yield_counts['c'][:met?] > 1 }, :requires_when_unmet => %w[g]
-    make_counter_dep :name => 'd', :requires => %w[e f]  , :met? => L{ @yield_counts['d'][:met?] > 1 }
-    make_counter_dep :name => 'e', :requires => %w[f]    , :met? => L{ @yield_counts['e'][:met?] > 1 }
-    make_counter_dep :name => 'f',                         :met? => L{ @yield_counts['f'][:met?] > 1 }
-    make_counter_dep :name => 'g',                         :met? => L{ @yield_counts['g'][:met?] > 1 }
+    make_counter_dep :name => 'a', :requires => %w[b c]  , :met? => L{ @yield_counts['a'][:meet] > 0 }
+    make_counter_dep :name => 'b', :requires => %w[c d e], :met? => L{ @yield_counts['b'][:meet] > 0 }
+    make_counter_dep :name => 'c', :requires => %w[f]    , :met? => L{ @yield_counts['c'][:meet] > 0 }, :requires_when_unmet => %w[g]
+    make_counter_dep :name => 'd', :requires => %w[e f]  , :met? => L{ @yield_counts['d'][:meet] > 0 }
+    make_counter_dep :name => 'e', :requires => %w[f]    , :met? => L{ @yield_counts['e'][:meet] > 0 }
+    make_counter_dep :name => 'f',                         :met? => L{ @yield_counts['f'][:meet] > 0 }
+    make_counter_dep :name => 'g',                         :met? => L{ @yield_counts['g'][:meet] > 0 }
   }
-  it_should_behave_like "met?"
+  it_should_behave_like "met? when unmet"
   describe "meet" do
     before { Dep('a').meet }
     it "should meet each dep exactly once" do
@@ -88,15 +117,15 @@ end
 describe "a partially meetable dep tree" do
   before {
     setup_yield_counts
-    make_counter_dep :name => 'a', :requires => %w[b c]  , :met? => L{ @yield_counts['a'][:met?] > 1 }
-    make_counter_dep :name => 'b', :requires => %w[c d e], :met? => L{ @yield_counts['b'][:met?] > 1 }
-    make_counter_dep :name => 'c', :requires => %w[f]    , :met? => L{ @yield_counts['c'][:met?] > 1 }, :requires_when_unmet => %w[g]
-    make_counter_dep :name => 'd', :requires => %w[e f]  , :met? => L{ @yield_counts['d'][:met?] > 1 }
+    make_counter_dep :name => 'a', :requires => %w[b c]  , :met? => L{ @yield_counts['a'][:meet] > 0 }
+    make_counter_dep :name => 'b', :requires => %w[c d e], :met? => L{ @yield_counts['b'][:meet] > 0 }
+    make_counter_dep :name => 'c', :requires => %w[f]    , :met? => L{ @yield_counts['c'][:meet] > 0 }, :requires_when_unmet => %w[g]
+    make_counter_dep :name => 'd', :requires => %w[e f]  , :met? => L{ @yield_counts['d'][:meet] > 0 }
     make_counter_dep :name => 'e', :requires => %w[f]    , :met? => L{ false }
-    make_counter_dep :name => 'f',                         :met? => L{ @yield_counts['f'][:met?] > 1 }
-    make_counter_dep :name => 'g',                         :met? => L{ @yield_counts['g'][:met?] > 1 }
+    make_counter_dep :name => 'f',                         :met? => L{ @yield_counts['f'][:meet] > 0 }
+    make_counter_dep :name => 'g',                         :met? => L{ @yield_counts['g'][:meet] > 0 }
   }
-  it_should_behave_like "met?"
+  it_should_behave_like "met? when unmet"
   describe "meet" do
     before { Dep('a').meet }
     it "should meet deps until one fails" do

data/spec/babushka/gem_helper_spec.rb

@@ -1,67 +1,54 @@
 require 'spec_helper'
 
-def stub_env_info
-  GemHelper.stub!(:env_info).and_return(%q{
-RubyGems Environment:
-  - INSTALLATION DIRECTORY: /Library/Ruby/Gems/1.8
-})
-end
-
-def stub_versions_of
-  GemHelper.stub!(:versions_of).and_return([
-    VersionStr.new('0.2.11'),
-    VersionStr.new('0.2.11.3'),
-    VersionStr.new('0.3.7'),
-    VersionStr.new('0.3.9')
-  ])
-end
-
-describe "has?" do
+describe Babushka::GemHelper do
+  let(:gem_helper) { Babushka::GemHelper }
   before {
-    stub_versions_of
+    gem_helper.stub!(:versions_of).and_return([
+      VersionStr.new('0.2.11'),
+      VersionStr.new('0.2.11.3'),
+      VersionStr.new('0.3.7'),
+      VersionStr.new('0.3.9')
+    ])
   }
-  it "should report installed gems correctly" do
-    GemHelper.has?('hammock 0.3.9').should == VersionStr.new('0.3.9')
-  end
-  it "should report missing gems correctly" do
-    GemHelper.has?('hammock 0.3.8').should be_nil
-  end
-  it "should report matching gems correctly" do
-    GemHelper.has?('hammock >= 0.3.10').should be_nil
-    GemHelper.has?('hammock >= 0.3.9').should == VersionStr.new('0.3.9')
-    GemHelper.has?('hammock >= 0.3.8').should == VersionStr.new('0.3.9')
-    GemHelper.has?('hammock >= 0.3.7').should == VersionStr.new('0.3.9')
-    GemHelper.has?('hammock ~> 0.2.7').should == VersionStr.new('0.2.11.3')
-    GemHelper.has?('hammock ~> 0.3.7').should == VersionStr.new('0.3.9')
+  describe "has?" do
+    it "should report installed gems correctly" do
+      gem_helper.has?('hammock 0.3.9').should == VersionStr.new('0.3.9')
+    end
+    it "should report missing gems correctly" do
+      gem_helper.has?('hammock 0.3.8').should be_nil
+    end
+    it "should report matching gems correctly" do
+      gem_helper.has?('hammock >= 0.3.10').should be_nil
+      gem_helper.has?('hammock >= 0.3.9').should == VersionStr.new('0.3.9')
+      gem_helper.has?('hammock >= 0.3.8').should == VersionStr.new('0.3.9')
+      gem_helper.has?('hammock >= 0.3.7').should == VersionStr.new('0.3.9')
+      gem_helper.has?('hammock ~> 0.2.7').should == VersionStr.new('0.2.11.3')
+      gem_helper.has?('hammock ~> 0.3.7').should == VersionStr.new('0.3.9')
+    end
   end
-end
 
-describe "gem_path_for" do
-  before {
-    stub_env_info
-    stub_versions_of
-    @prefix = '/Library/Ruby/Gems/1.8/gems'
-  }
-  it "should return the correct path" do
-    GemHelper.gem_path_for('hammock').should == @prefix / 'hammock-0.3.9'
-    GemHelper.gem_path_for('hammock', '0.3.9').should == @prefix / 'hammock-0.3.9'
-    GemHelper.gem_path_for('hammock', '~> 0.3.7').should == @prefix / 'hammock-0.3.9'
-    GemHelper.gem_path_for('hammock', '0.3.8').should be_nil
+  describe "gem_path_for" do
+    let(:prefix) { '/Library/Ruby/Gems/1.8/gems' }
+    before { Babushka.ruby.stub!(:gem_dir).and_return(prefix) }
+    it "should return the correct path" do
+      gem_helper.gem_path_for('hammock').should == prefix / 'hammock-0.3.9'
+      gem_helper.gem_path_for('hammock', '0.3.9').should == prefix / 'hammock-0.3.9'
+      gem_helper.gem_path_for('hammock', '~> 0.3.7').should == prefix / 'hammock-0.3.9'
+      gem_helper.gem_path_for('hammock', '0.3.8').should be_nil
+    end
   end
-end
 
-describe Babushka::GemHelper do
   describe '.should_sudo?' do
-    before :each do
-      Babushka::GemHelper.stub!(
-        :gem_root => '/path/to/gems'.p,
-        :bin_path => '/path/to/bins'.p
+    before {
+      Babushka.ruby.stub!(
+        :gem_dir => '/path/to/gems'.p,
+        :bin_dir => '/path/to/bins'.p
       )
-    end
-    
+    }
+
     it "should return true if the bin dir is not writeable" do
       File.should_receive(:writable?).with('/path/to/bins').and_return(false)
-      Babushka::GemHelper.should_sudo?.should be_true
+      gem_helper.should_sudo?.should be_true
     end
 
     context "when the bin dir is writable" do
@@ -69,20 +56,20 @@ describe Babushka::GemHelper do
         File.should_receive(:writable?).with('/path/to/bins').and_return(true)
       }
       it "should return false if the gem dir does not exist" do
-        Babushka::GemHelper.gem_root.should_receive(:exists?).and_return(false)
-        Babushka::GemHelper.should_sudo?.should be_false
+        Babushka.ruby.gem_dir.should_receive(:exists?).and_return(false)
+        gem_helper.should_sudo?.should be_false
       end
       context "when the gem dir exists" do
         before {
-          Babushka::GemHelper.gem_root.should_receive(:exists?).and_return(true)
+          Babushka.ruby.gem_dir.should_receive(:exists?).and_return(true)
         }
         it "should return true if the gem dir is not writeable" do
-          Babushka::GemHelper.gem_root.should_receive(:writable?).and_return(false)
-          Babushka::GemHelper.should_sudo?.should be_true
+          Babushka.ruby.gem_dir.should_receive(:writable?).and_return(false)
+          gem_helper.should_sudo?.should be_true
         end
         it "should return false if the gem dir is writeable" do
-          Babushka::GemHelper.gem_root.should_receive(:writable?).and_return(true)
-          Babushka::GemHelper.should_sudo?.should be_false
+          Babushka.ruby.gem_dir.should_receive(:writable?).and_return(true)
+          gem_helper.should_sudo?.should be_false
         end
       end
     end

data/spec/babushka/git_repo_spec.rb

@@ -2,31 +2,31 @@ require 'spec_helper'
 
 def stub_commitless_repo name
   (tmp_prefix / 'repos' / name).rm
-  cd tmp_prefix / 'repos' / name, :create => true do
-    shell "git init"
+  PathHelpers.cd tmp_prefix / 'repos' / name, :create => true do
+    ShellHelpers.shell "git init"
   end
 end
 
 def stub_repo name
   (tmp_prefix / 'repos' / "#{name}_remote").rm
-  cd tmp_prefix / 'repos' / "#{name}_remote", :create => true do
-    shell "tar -zxvf #{File.dirname(__FILE__) / '../repos/remote.git.tgz'}"
+  PathHelpers.cd tmp_prefix / 'repos' / "#{name}_remote", :create => true do
+    ShellHelpers.shell "tar -zxvf #{File.dirname(__FILE__) / '../repos/remote.git.tgz'}"
   end
 
   (tmp_prefix / 'repos' / name).rm
-  cd tmp_prefix / 'repos' do
-    shell "git clone #{name}_remote/remote.git #{name}"
+  PathHelpers.cd tmp_prefix / 'repos' do
+    ShellHelpers.shell "git clone #{name}_remote/remote.git #{name}"
   end
 end
 
 def repo_context name, &block
-  cd(tmp_prefix / 'repos'/ name, &block)
+  PathHelpers.cd(tmp_prefix / 'repos'/ name, &block)
 end
 
 describe GitRepo, 'creation' do
   before(:all) { stub_repo 'a' }
   it "should return nil on nonexistent paths" do
-    Babushka::GitRepo.new(tmp_prefix / 'repos/nonexistent').root.should == nil
+    Babushka::GitRepo.new(tmp_prefix / 'repos/missing').root.should == nil
   end
   it "should return nil on non-repo paths" do
     Babushka::GitRepo.new(tmp_prefix / 'repos').root.should == nil
@@ -54,22 +54,46 @@ describe GitRepo, 'creation' do
   end
 end
 
+describe GitRepo, 'without a dir' do
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/missing') }
+  it "should not exist" do
+    subject.exists?.should be_false
+  end
+  [:clean?, :dirty?, :current_branch, :current_head, :remote_branch_exists?, :ahead?].each {|method|
+    it "should raise on #{method}" do
+      L{ subject.send(method) }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/missing'}.")
+    end
+  }
+  context "with lazy eval" do
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/lazy_dir') }
+    it "should fail before the repo is created, but work afterwards" do
+      subject.exists?.should be_false
+      L{ subject.clean? }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/lazy_dir'}.")
+      stub_repo 'lazy_dir'
+      subject.exists?.should be_true
+      subject.should be_clean
+    end
+  end
+end
+
 describe GitRepo, 'without a repo' do
-  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/nonexistent') }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/empty') }
+  before { (tmp_prefix / 'repos/empty').mkdir }
+
   it "should not exist" do
     subject.exists?.should be_false
   end
   [:clean?, :dirty?, :current_branch, :current_head, :remote_branch_exists?, :ahead?].each {|method|
     it "should raise on #{method}" do
-      L{ subject.send(method) }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/nonexistent'}.")
+      L{ subject.send(method) }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/empty'}.")
     end
   }
   context "with lazy eval" do
-    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/lazy') }
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/lazy_repo') }
     it "should fail before the repo is created, but work afterwards" do
       subject.exists?.should be_false
-      L{ subject.clean? }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/lazy'}.")
-      stub_repo 'lazy'
+      L{ subject.clean? }.should raise_error(Babushka::GitRepoError, "There is no repo at #{tmp_prefix / 'repos/lazy_repo'}.")
+      stub_repo 'lazy_repo'
       subject.exists?.should be_true
       subject.should be_clean
     end
@@ -104,7 +128,7 @@ describe GitRepo, '#clean? / #dirty?' do
     end
     context "when there are changes" do
       before {
-        cd(tmp_prefix / 'repos/a') { shell "echo dirt >> content.txt" }
+        PathHelpers.cd(tmp_prefix / 'repos/a') { ShellHelpers.shell "echo dirt >> content.txt" }
       }
       it "should be dirty" do
         subject.should_not be_clean
@@ -112,7 +136,7 @@ describe GitRepo, '#clean? / #dirty?' do
       end
       context "when the changes are staged" do
         before {
-          cd(tmp_prefix / 'repos/a') { shell "git add --update ." }
+          PathHelpers.cd(tmp_prefix / 'repos/a') { ShellHelpers.shell "git add --update ." }
         }
         it "should be dirty" do
           subject.should_not be_clean
@@ -144,21 +168,29 @@ describe GitRepo, '#branches' do
       subject.branches.should == ['master']
     end
     context "after creating another branch" do
-      before {
-        repo_context('a') { shell "git checkout -b next" }
+      before(:all) {
+        repo_context('a') { ShellHelpers.shell "git checkout -b next" }
       }
       it "should return both branches" do
         subject.branches.should == ['master', 'next']
       end
       context "after changing back to master" do
         before {
-          repo_context('a') { shell "git checkout master" }
+          repo_context('a') { ShellHelpers.shell "git checkout master" }
         }
         it "should return both branches" do
           subject.branches.should == ['master', 'next']
         end
       end
     end
+    context "with a detached HEAD" do
+      before {
+        repo_context('a') { ShellHelpers.shell "git checkout origin/next~" }
+      }
+      it "should not include the '(no branch)' entry" do
+        subject.branches.should == ['master', 'next']
+      end
+    end
   end
   context "on a repo with no commits" do
     before { stub_commitless_repo 'a' }
@@ -168,6 +200,46 @@ describe GitRepo, '#branches' do
   end
 end
 
+describe GitRepo, '#all_branches' do
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  context "on a repo with commits" do
+    before(:all) { stub_repo 'a' }
+    it "should return the only branch in a list" do
+      subject.all_branches.should == ["master", "origin/master", "origin/next"]
+    end
+    context "after creating another branch" do
+      before(:all) {
+        repo_context('a') { ShellHelpers.shell "git checkout -b next" }
+      }
+      it "should return both branches" do
+        subject.all_branches.should == ["master", "next", "origin/master", "origin/next"]
+      end
+      context "after changing back to master" do
+        before {
+          repo_context('a') { ShellHelpers.shell "git checkout master" }
+        }
+        it "should return both branches" do
+          subject.all_branches.should == ["master", "next", "origin/master", "origin/next"]
+        end
+      end
+    end
+    context "with a detached HEAD" do
+      before {
+        repo_context('a') { ShellHelpers.shell "git checkout origin/next~" }
+      }
+      it "should not include the '(no branch)' entry" do
+        subject.all_branches.should == ["master", "next", "origin/master", "origin/next"]
+      end
+    end
+  end
+  context "on a repo with no commits" do
+    before { stub_commitless_repo 'a' }
+    it "should return no branches" do
+      subject.all_branches.should == []
+    end
+  end
+end
+
 describe GitRepo, '#current_branch' do
   before(:all) { stub_repo 'a' }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
@@ -175,15 +247,15 @@ describe GitRepo, '#current_branch' do
     subject.current_branch.should == 'master'
   end
   context "after creating another branch" do
-    before {
-      repo_context('a') { shell "git checkout -b next" }
+    before(:all) {
+      repo_context('a') { ShellHelpers.shell "git checkout -b next" }
     }
     it "should return 'next'" do
       subject.current_branch.should == 'next'
     end
     context "after changing back to master" do
       before {
-        repo_context('a') { shell "git checkout master" }
+        repo_context('a') { ShellHelpers.shell "git checkout master" }
       }
       it "should return 'next'" do
         subject.current_branch.should == 'master'
@@ -192,6 +264,23 @@ describe GitRepo, '#current_branch' do
   end
 end
 
+describe GitRepo, '#current_remote_branch' do
+  before(:all) { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return the namespaced remote branch" do
+    subject.current_remote_branch.should == 'origin/master'
+  end
+  context "after switching to a custom branch" do
+    before {
+      subject.repo_shell('git checkout -b next')
+      subject.repo_shell('git config branch.next.remote upstream')
+    }
+    it "should return 'origin' when no remote is set" do
+      subject.current_remote_branch.should == 'upstream/next'
+    end
+  end
+end
+
 describe GitRepo, '#current_head' do
   before { stub_repo 'a' }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
@@ -208,11 +297,33 @@ describe GitRepo, '#current_full_head' do
   end
 end
 
+describe GitRepo, '#resolve' do
+  before { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return a full commit id" do
+    subject.resolve('master').should =~ /^[0-9a-f]{7,40}$/
+  end
+end
+
+describe GitRepo, '#remote_for' do
+  before(:all) {
+    stub_repo 'a'
+    subject.repo_shell('git config branch.next.remote upstream')
+  }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return the remote when it's set in the config" do
+    subject.remote_for('next').should == 'upstream'
+  end
+  it "should return 'origin' when no remote is set" do
+    subject.remote_for('lolbranch').should == 'origin'
+  end
+end
+
 describe GitRepo, '#ahead?' do
   before(:all) {
     stub_repo 'a'
-    cd(tmp_prefix / 'repos/a') {
-      shell "git checkout -b topic"
+    PathHelpers.cd(tmp_prefix / 'repos/a') {
+      ShellHelpers.shell "git checkout -b topic"
     }
   }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
@@ -225,10 +336,10 @@ describe GitRepo, '#ahead?' do
   end
   context "when remote branch exists" do
     before(:all) {
-      cd(tmp_prefix / 'repos/a') {
-        shell "git push origin topic"
-        shell 'echo "Ch-ch-ch-changes" >> content.txt'
-        shell 'git commit -a -m "Changes!"'
+      PathHelpers.cd(tmp_prefix / 'repos/a') {
+        ShellHelpers.shell "git push origin topic"
+        ShellHelpers.shell 'echo "Ch-ch-ch-changes" >> content.txt'
+        ShellHelpers.shell 'git commit -a -m "Changes!"'
       }
     }
     it "should have a local topic branch" do
@@ -240,14 +351,23 @@ describe GitRepo, '#ahead?' do
     end
     context "when the branch is fully pushed" do
       before {
-        cd(tmp_prefix / 'repos/a') {
-          shell "git push origin topic"
+        PathHelpers.cd(tmp_prefix / 'repos/a') {
+          ShellHelpers.shell "git push origin topic"
         }
       }
       it "should not be ahead" do
         subject.remote_branch_exists?.should be_true
         subject.should_not be_ahead
       end
+      context "when the remote doesn't exist" do
+        before {
+          subject.repo_shell('git config branch.topic.remote upstream')
+        }
+        it "should be ahead" do
+          subject.remote_branch_exists?.should be_false
+          subject.should be_ahead
+        end
+      end
     end
   end
 end
@@ -255,9 +375,9 @@ end
 describe GitRepo, '#behind?' do
   before(:all) {
     stub_repo 'a'
-    cd(tmp_prefix / 'repos/a') {
-      shell "git checkout -b next"
-      shell "git reset --hard origin/next^"
+    PathHelpers.cd(tmp_prefix / 'repos/a') {
+      ShellHelpers.shell "git checkout -b next"
+      ShellHelpers.shell "git reset --hard origin/next^"
     }
   }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
@@ -267,14 +387,23 @@ describe GitRepo, '#behind?' do
   end
   context "when the remote is merged" do
     before {
-      cd(tmp_prefix / 'repos/a') {
-        shell "git merge origin/next"
+      PathHelpers.cd(tmp_prefix / 'repos/a') {
+        ShellHelpers.shell "git merge origin/next"
       }
     }
     it "should not be behind" do
       subject.remote_branch_exists?.should be_true
       subject.should_not be_behind
     end
+    context "when the remote doesn't exist" do
+      before {
+        subject.repo_shell('git config branch.next.remote upstream')
+      }
+      it "should be ahead" do
+        subject.remote_branch_exists?.should be_false
+        subject.should be_ahead
+      end
+    end
   end
 end
 
@@ -296,7 +425,7 @@ describe GitRepo, '#clone!' do
     context "when the clone fails" do
       it "should raise" do
         L{
-          subject.clone!(tmp_prefix / 'repos/a_remote/nonexistent.git')
+          subject.clone!(tmp_prefix / 'repos/a_remote/missing.git')
         }.should raise_error(GitRepoError)
       end
     end
@@ -321,7 +450,7 @@ origin\t#{tmp_prefix / 'repos/a_remote/remote.git'} (push)
       end
     end
     after {
-      shell "rm -rf #{tmp_prefix / 'repos/b'}"
+      ShellHelpers.shell "rm -rf #{tmp_prefix / 'repos/b'}"
     }
   end
 end
@@ -332,14 +461,41 @@ describe GitRepo, '#branch!' do
   it "should not already have a next branch" do
     subject.branches.should_not include('next')
   end
-  context "after tracking" do
-    before { subject.branch! "next" }
-    it "should have created a next branch" do
+  context "after branching" do
+    before(:all) { subject.branch! "next" }
+    it "should have created the branch" do
       subject.branches.should include('next')
     end
+    it "should have pointed the branch at HEAD" do
+      subject.resolve('next').should == subject.resolve("master")
+    end
     it "should not be tracking anything" do
       subject.repo_shell('git config branch.next.remote').should be_nil
     end
+    it "should not have checked out the branch" do
+      subject.current_branch.should == "master"
+    end
+  end
+  context "after branching to a ref" do
+    before(:all) {
+      PathHelpers.cd(tmp_prefix / 'repos/a') {
+        ShellHelpers.shell 'echo "Ch-ch-ch-changes" >> content.txt'
+        ShellHelpers.shell 'git commit -a -m "Changes!"'
+      }
+      subject.branch! "another", "master~"
+    }
+    it "should have created the branch" do
+      subject.branches.should include('another')
+    end
+    it "should have pointed the branch at the right ref" do
+      subject.resolve('another').should == subject.resolve("master~")
+    end
+    it "should not be tracking anything" do
+      subject.repo_shell('git config branch.another.remote').should be_nil
+    end
+    it "should not have checked out the branch" do
+      subject.current_branch.should == "master"
+    end
   end
 end
 
@@ -350,7 +506,7 @@ describe GitRepo, '#track!' do
     subject.branches.should_not include('next')
   end
   context "after tracking" do
-    before { subject.track! "origin/next" }
+    before(:all) { subject.track! "origin/next" }
     it "should have created a next branch" do
       subject.branches.should include('next')
     end
@@ -363,28 +519,63 @@ end
 describe GitRepo, '#checkout!' do
   before(:all) {
     stub_repo 'a'
-    cd(tmp_prefix / 'repos/a') {
-      shell "git checkout -b next"
+    PathHelpers.cd(tmp_prefix / 'repos/a') {
+      ShellHelpers.shell "git checkout -b next"
     }
   }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
-  it "should already have a next branch" do
-    subject.branches.should =~ %w[master next]
-    subject.current_branch.should == 'next'
+  describe "checking out a branch" do
+    it "should already have a next branch" do
+      subject.branches.should =~ %w[master next]
+      subject.current_branch.should == 'next'
+    end
+    context "after checking out" do
+      before {
+        subject.checkout! "master"
+      }
+      it "should be on the master branch now" do
+        subject.current_branch.should == 'master'
+      end
+    end
   end
-  context "after checking out" do
-    before { subject.checkout! "master" }
-    it "should be on the master branch now" do
-      subject.current_branch.should == 'master'
+  describe "checking out a ref" do
+    before {
+      subject.checkout! 'origin/next~'
+    }
+    it "should detach the HEAD" do
+      subject.branches.should =~ %w[master next]
+      subject.current_branch.should =~ /^[0-9a-f]{40}$/
     end
   end
 end
 
+describe GitRepo, '#detach!' do
+  before(:all) {
+    stub_repo 'a'
+  }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should detach to HEAD when no ref is supplied" do
+    subject.detach!
+    subject.current_branch.should =~ /^[0-9a-f]{40}$/
+    subject.current_branch.starts_with?(subject.resolve('master')).should be_true
+  end
+  it "should detach the HEAD when a ref is supplied" do
+    subject.detach! 'origin/next'
+    subject.current_branch.should =~ /^[0-9a-f]{40}$/
+    subject.current_branch.starts_with?(subject.resolve('origin/next')).should be_true
+  end
+  it "should detach the HEAD when a branch is supplied" do
+    subject.detach! "master"
+    subject.current_branch.should =~ /^[0-9a-f]{40}$/
+    subject.current_branch.starts_with?(subject.resolve('master')).should be_true
+  end
+end
+
 describe GitRepo, '#reset_hard!' do
   before {
     stub_repo 'a'
-    cd(tmp_prefix / 'repos/a') {
-      shell "echo 'more rubies' >> lib/rubies.rb"
+    PathHelpers.cd(tmp_prefix / 'repos/a') {
+      ShellHelpers.shell "echo 'more rubies' >> lib/rubies.rb"
     }
   }
   subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }