rubycut-babushka 0.10.6

data/spec/babushka/dep_support.rb

@@ -0,0 +1,29 @@
+def setup_yield_counts
+  @yield_counts = Hash.new {|hsh,k| hsh[k] = Hash.new {|hsh,k| 0 } }
+
+  @yield_counts_none = {}
+  @yield_counts_met_run = {:setup => 1, :met? => 1}
+  @yield_counts_meet_run = {:setup => 1, :met? => 2, :prepare => 1, :before => 1, :meet => 1, :after => 1}
+  @yield_counts_dep_failed = {:setup => 1}
+  @yield_counts_failed_meet_run = {:setup => 1, :met? => 2, :prepare => 1, :before => 1, :meet => 1, :after => 1}
+  @yield_counts_early_exit_meet_run = {:setup => 1, :met? => 1, :prepare => 1, :before => 1, :meet => 1}
+  @yield_counts_already_met = {:setup => 1, :met? => 1}
+  @yield_counts_failed_at_before = {:setup => 1, :met? => 2, :prepare => 1, :before => 1}
+end
+
+def make_counter_dep opts = {}
+  incrementers = DepContext.accepted_blocks.inject({}) {|lambdas,key|
+    lambdas[key] = L{ @yield_counts[opts[:name]][key] += 1 }
+    lambdas
+  }
+  dep opts[:name] do
+    requires opts[:requires]
+    requires_when_unmet opts[:requires_when_unmet]
+    DepContext.accepted_blocks.each {|dep_method|
+      send dep_method do
+        incrementers[dep_method].call
+        (opts[dep_method] || default_block_for(dep_method)).call
+      end
+    }
+  end
+end

data/spec/babushka/deps_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'dep_support'
+
+shared_examples_for "met?" do
+  describe "met?" do
+    before { Dep('a').met? }
+    it "should met?-check each dep exactly once" 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
+      @yield_counts['g'].should == @yield_counts_none
+    end
+  end
+end
+
+describe "an already met dep tree" do
+  before {
+    setup_yield_counts
+    make_counter_dep :name => 'a', :requires => %w[b c]
+    make_counter_dep :name => 'b', :requires => %w[c d e]
+    make_counter_dep :name => 'c', :requires => %w[f]
+    make_counter_dep :name => 'd', :requires => %w[e f], :requires_when_unmet => %w[g]
+    make_counter_dep :name => 'e', :requires => %w[f]
+    make_counter_dep :name => 'f'
+    make_counter_dep :name => 'g'
+  }
+  it_should_behave_like "met?"
+  describe "meet" do
+    before { Dep('a').meet }
+    it "should meet no deps" 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
+      @yield_counts['g'].should == @yield_counts_none
+    end
+  end
+  after { Base.sources.anonymous.deps.clear! }
+end
+
+describe "an unmeetable dep tree" do
+  before {
+    setup_yield_counts
+    make_counter_dep :name => 'a', :met? => L{ false }, :requires => %w[b c]
+    make_counter_dep :name => 'b', :met? => L{ false }, :requires => %w[c d e]
+    make_counter_dep :name => 'c', :met? => L{ false }, :requires => %w[f], :requires_when_unmet => %w[g]
+    make_counter_dep :name => 'd', :met? => L{ false }, :requires => %w[e f]
+    make_counter_dep :name => 'e', :met? => L{ false }, :requires => %w[f]
+    make_counter_dep :name => 'f', :met? => L{ false }
+    make_counter_dep :name => 'g', :met? => L{ false }
+  }
+  it_should_behave_like "met?"
+  describe "meet" do
+    before { Dep('a').meet }
+    it "should fail on the bootom-most dep" do
+      %w[f].each {|i| @yield_counts[i].should == @yield_counts_failed_meet_run }
+    end
+    it "should bubble the fail back up" do
+      %w[a b c].each {|i| @yield_counts[i].should == @yield_counts_dep_failed }
+    end
+    it "shouldn't run any deps after the fail" do
+      %w[d e g].each {|i| @yield_counts[i].should == @yield_counts_none }
+    end
+  end
+  after { Base.sources.anonymous.deps.clear! }
+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 }
+  }
+  it_should_behave_like "met?"
+  describe "meet" do
+    before { Dep('a').meet }
+    it "should meet each dep exactly once" do
+      Base.sources.anonymous.deps.names.each {|i| @yield_counts[i].should == @yield_counts_meet_run }
+    end
+  end
+  after { Base.sources.anonymous.deps.clear! }
+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 => '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 }
+  }
+  it_should_behave_like "met?"
+  describe "meet" do
+    before { Dep('a').meet }
+    it "should meet deps until one fails" do
+      %w[c f g].each {|i| @yield_counts[i].should == @yield_counts_meet_run }
+    end
+    it "should fail on the unmeetable dep" do
+      %w[e].each {|i| @yield_counts[i].should == @yield_counts_failed_meet_run }
+    end
+    it "should bubble the fail up" do
+      %w[a b d].each {|i| @yield_counts[i].should == @yield_counts_dep_failed }
+    end
+  end
+  after { Base.sources.anonymous.deps.clear! }
+end

data/spec/babushka/gem_helper_spec.rb

@@ -0,0 +1,90 @@
+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
+  before {
+    stub_versions_of
+  }
+  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')
+  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
+  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
+      )
+    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
+    end
+
+    context "when the bin dir is writable" do
+      before {
+        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
+      end
+      context "when the gem dir exists" do
+        before {
+          Babushka::GemHelper.gem_root.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
+        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
+        end
+      end
+    end
+  end
+end

data/spec/babushka/git_repo_spec.rb

@@ -0,0 +1,396 @@
+require 'spec_helper'
+
+def stub_commitless_repo name
+  (tmp_prefix / 'repos' / name).rm
+  cd tmp_prefix / 'repos' / name, :create => true do
+    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'}"
+  end
+
+  (tmp_prefix / 'repos' / name).rm
+  cd tmp_prefix / 'repos' do
+    shell "git clone #{name}_remote/remote.git #{name}"
+  end
+end
+
+def repo_context name, &block
+  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
+  end
+  it "should return nil on non-repo paths" do
+    Babushka::GitRepo.new(tmp_prefix / 'repos').root.should == nil
+  end
+  it "should recognise the repo path as a string" do
+    Babushka::GitRepo.new((tmp_prefix / 'repos/a').to_s).root.should == tmp_prefix / 'repos/a'
+  end
+  it "should recognise the repo path as a Fancypath" do
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a').root.should == tmp_prefix / 'repos/a'
+  end
+  it "should find the parent when called on the subdir" do
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a/lib').root.should == tmp_prefix / 'repos/a'
+  end
+  it "should find the git dir within the repo" do
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a').git_dir.should == tmp_prefix / 'repos/a/.git'
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a/lib').git_dir.should == tmp_prefix / 'repos/a/.git'
+  end
+  it "should store path as a Fancypath" do
+    Babushka::GitRepo.new((tmp_prefix / 'repos/a').to_s).path.should be_an_instance_of(Fancypath)
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a').path.should be_an_instance_of(Fancypath)
+  end
+  it "should return the repo path as a Fancypath" do
+    Babushka::GitRepo.new((tmp_prefix / 'repos/a').to_s).root.should be_an_instance_of(Fancypath)
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a').root.should be_an_instance_of(Fancypath)
+  end
+end
+
+describe GitRepo, 'without a repo' do
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/nonexistent') }
+  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'}.")
+    end
+  }
+  context "with lazy eval" do
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/lazy') }
+    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'
+      subject.exists?.should be_true
+      subject.should be_clean
+    end
+  end
+end
+
+describe GitRepo, "with a repo" do
+  before(:all) { stub_repo 'a' }
+  it "should exist with string path" do
+    Babushka::GitRepo.new((tmp_prefix / 'repos/a').to_s).exists?.should be_true
+  end
+  it "should exist with Fancypath path" do
+    Babushka::GitRepo.new(tmp_prefix / 'repos/a').exists?.should be_true
+  end
+end
+
+describe GitRepo, '#clean? / #dirty?' do
+  context "on commitless repos" do
+    before(:all) { stub_commitless_repo 'a' }
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+    it "should be clean" do
+      subject.should be_clean
+      subject.should_not be_dirty
+    end
+  end
+  context "on normal repos" do
+    before(:all) { stub_repo 'a' }
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+    it "should be clean" do
+      subject.should be_clean
+      subject.should_not be_dirty
+    end
+    context "when there are changes" do
+      before {
+        cd(tmp_prefix / 'repos/a') { shell "echo dirt >> content.txt" }
+      }
+      it "should be dirty" do
+        subject.should_not be_clean
+        subject.should be_dirty
+      end
+      context "when the changes are staged" do
+        before {
+          cd(tmp_prefix / 'repos/a') { shell "git add --update ." }
+        }
+        it "should be dirty" do
+          subject.should_not be_clean
+          subject.should be_dirty
+        end
+      end
+    end
+  end
+end
+
+describe GitRepo, '#include?' do
+  before(:all) { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return true for valid commits" do
+    subject.include?('20758f2d9d696c51ac83a0fd36626d421057b24d').should be_true
+    subject.include?('20758f2').should be_true
+  end
+  it "should return false for nonexistent commits" do
+    subject.include?('20758f2d9d696c51ac83a0fd36626d421057b24e').should be_false
+    subject.include?('20758f3').should be_false
+  end
+end
+
+describe GitRepo, '#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.branches.should == ['master']
+    end
+    context "after creating another branch" do
+      before {
+        repo_context('a') { 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" }
+        }
+        it "should return both branches" do
+          subject.branches.should == ['master', 'next']
+        end
+      end
+    end
+  end
+  context "on a repo with no commits" do
+    before { stub_commitless_repo 'a' }
+    it "should return no branches" do
+      subject.branches.should == []
+    end
+  end
+end
+
+describe GitRepo, '#current_branch' do
+  before(:all) { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return 'master'" do
+    subject.current_branch.should == 'master'
+  end
+  context "after creating another branch" do
+    before {
+      repo_context('a') { 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" }
+      }
+      it "should return 'next'" do
+        subject.current_branch.should == 'master'
+      end
+    end
+  end
+end
+
+describe GitRepo, '#current_head' do
+  before { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return a short commit id" do
+    subject.current_head.should =~ /^[0-9a-f]{7}$/
+  end
+end
+
+describe GitRepo, '#current_full_head' do
+  before { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return a full commit id" do
+    subject.current_full_head.should =~ /^[0-9a-f]{40}$/
+  end
+end
+
+describe GitRepo, '#ahead?' do
+  before(:all) {
+    stub_repo 'a'
+    cd(tmp_prefix / 'repos/a') {
+      shell "git checkout -b topic"
+    }
+  }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should have a local topic branch" do
+    subject.current_branch.should == 'topic'
+  end
+  it "should return true if the current branch has no remote" do
+    subject.remote_branch_exists?.should be_false
+    subject.should be_ahead
+  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!"'
+      }
+    }
+    it "should have a local topic branch" do
+      subject.current_branch.should == 'topic'
+    end
+    it "should return true if there are unpushed commits on the current branch" do
+      subject.remote_branch_exists?.should be_true
+      subject.should be_ahead
+    end
+    context "when the branch is fully pushed" do
+      before {
+        cd(tmp_prefix / 'repos/a') {
+          shell "git push origin topic"
+        }
+      }
+      it "should not be ahead" do
+        subject.remote_branch_exists?.should be_true
+        subject.should_not be_ahead
+      end
+    end
+  end
+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^"
+    }
+  }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should return true if there are new commits on the remote" do
+    subject.remote_branch_exists?.should be_true
+    subject.should be_behind
+  end
+  context "when the remote is merged" do
+    before {
+      cd(tmp_prefix / 'repos/a') {
+        shell "git merge origin/next"
+      }
+    }
+    it "should not be behind" do
+      subject.remote_branch_exists?.should be_true
+      subject.should_not be_behind
+    end
+  end
+end
+
+describe GitRepo, '#clone!' do
+  before(:all) { stub_repo 'a' }
+  context "for existing repos" do
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+    it "should raise" do
+      L{
+        subject.clone!('a_remote/remote.git')
+      }.should raise_error(GitRepoExists, "Can't clone a_remote/remote.git to existing path #{tmp_prefix / 'repos/a'}.")
+    end
+  end
+  context "for non-existent repos" do
+    subject { Babushka::GitRepo.new(tmp_prefix / 'repos/b') }
+    it "should not exist yet" do
+      subject.exists?.should be_false
+    end
+    context "when the clone fails" do
+      it "should raise" do
+        L{
+          subject.clone!(tmp_prefix / 'repos/a_remote/nonexistent.git')
+        }.should raise_error(GitRepoError)
+      end
+    end
+    context "after cloning" do
+      before { subject.clone! "a_remote/remote.git" }
+      it "should exist now" do
+        subject.exists?.should be_true
+      end
+      it "should have the correct remote" do
+        subject.repo_shell("git remote -v").should == %Q{
+origin\t#{tmp_prefix / 'repos/a_remote/remote.git'} (fetch)
+origin\t#{tmp_prefix / 'repos/a_remote/remote.git'} (push)
+        }.strip
+      end
+      it "should have the remote branch" do
+        subject.repo_shell("git branch -a").should == %Q{
+* master
+  remotes/origin/HEAD -> origin/master
+  remotes/origin/master
+  remotes/origin/next
+        }.strip
+      end
+    end
+    after {
+      shell "rm -rf #{tmp_prefix / 'repos/b'}"
+    }
+  end
+end
+
+describe GitRepo, '#branch!' do
+  before(:all) { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  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
+      subject.branches.should include('next')
+    end
+    it "should not be tracking anything" do
+      subject.repo_shell('git config branch.next.remote').should be_nil
+    end
+  end
+end
+
+describe GitRepo, '#track!' do
+  before(:all) { stub_repo 'a' }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should not already have a next branch" do
+    subject.branches.should_not include('next')
+  end
+  context "after tracking" do
+    before { subject.track! "origin/next" }
+    it "should have created a next branch" do
+      subject.branches.should include('next')
+    end
+    it "should be tracking origin/next" do
+      subject.repo_shell('git config branch.next.remote').should == 'origin'
+    end
+  end
+end
+
+describe GitRepo, '#checkout!' do
+  before(:all) {
+    stub_repo 'a'
+    cd(tmp_prefix / 'repos/a') {
+      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'
+  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
+
+describe GitRepo, '#reset_hard!' do
+  before {
+    stub_repo 'a'
+    cd(tmp_prefix / 'repos/a') {
+      shell "echo 'more rubies' >> lib/rubies.rb"
+    }
+  }
+  subject { Babushka::GitRepo.new(tmp_prefix / 'repos/a') }
+  it "should make a dirty repo clean" do
+    subject.should be_dirty
+    subject.reset_hard!
+    subject.should be_clean
+  end
+end