vim-update-bundles 0.6

data/CHANGES

@@ -0,0 +1,48 @@
+0.6     29 Jun 2011
+- Added doc/bundle-log.txt. :help bundle-log to see it.
+- Added --no-updates option to make adding/deleting bundles faster.
+- Support single-letter options (-v for --verbose, -n for --no-updates).
+- It's BundleCommand though Bundle-Command and BUNDLE COMMAND still work.
+- Added --help and --version.
+- Cleanups and doc fixes by Sorin Ionescu.
+- bugfix: changing branch name would merge instead of switching branches.
+
+0.4.1   11 May 2011
+- Support vundle-style short repo names thanks to Chris Toomey
+
+0.4.0   06 Mar 2011
+- Greatly simplify path configuration thanks to Sorin Ionescu
+- No longer use Ruby as config file format, it's just key=value now
+  ("static=1" still works but it's $HOME instead of "#{ENV['HOME']}")
+- Add the Static: directive thanks to Andreas Marienborg
+- Remove submodule entries from .gitmodules and .git/config (also Sorin)
+
+0.3.1   30 Oct 2010
+- restore Ruby 1.8 compatibility (popen doesn't accept an array)
+- promise to check rvm before releasing
+
+0.3     29 Oct 2010
+- added submodule support thanks to steeef.
+- support putting .vim and .vimrc in custom locations using config options.
+- every repo now automatically ignores doc/tags.
+- BUNDLE and BUNDLE-COMMAND are now case-insensitive.
+- If a BUNDLE-COMMAND fails, vim-update-bundles now exits immediately.
+
+0.2     27 Oct 2010
+- Added a pure ruby configuration file, ~/vim-update-bundles.rb
+- Don't clean ".vim" from repo names. a.vim is "a.vim" and not just "a".
+- Added verbose flag. Run ./vim-update-bundles --verbose=1 to hear everything.
+- bugfix: repos weren't automatically fast-forwarding to the latest commit.
+- added command line args: ./vim-update-bundles vimrc="$HOME/dots/vimrc"
+  but they're not very useful in real life, only for testing.
+- added some tests! "rake test" in the git repo to run them.
+- created a changes file.
+
+0.1     20 Sep 2010
+- add ability to create new vim environment from scratch.
+- add BUNDLE-COMMAND directive to run shell commands.
+- remove dashes from directive (it's '" BUNDLE:' now, not '" --- BUNDLE:').
+- don't ever rm -rf, move deleted bundles to ~.vim/Trashed-Bundles.
+
+0.01    14 Aug 2010
+- initial release

data/README.md

@@ -0,0 +1,147 @@
+# vim-update-bundles
+
+Use Pathogen and Git to manage your Vim plugins.
+
+[![Travis Build Status](http://travis-ci.org/bronson/vim-update-bundles.png)](http://travis-ci.org/bronson/vim-update-bundles)
+
+
+## Description
+
+To install a plugin, put lines like this in your ~/.vimrc:
+
+    " Bundle: jQuery                                      # https://github.com/vim-scripts/jQuery
+    " Bundle: scrooloose/nerdtree                         # https://github.com/scrooloose/nerdtree
+    " Bundle: https://github.com/scrooloose/nerdtree.git  # Full URL to the repository.
+
+Now, run `./vim-update-bundles`.  Your plugins are installed and ready for use.
+
+Type `:help bundles` from within Vim to show the list of plugins that you have installed.
+Hit Control-] on the bundle's name to jump to its documentation.
+Also make sure to look at the bundle-log.
+
+
+## Installation
+
+One of:
+
+* git clone: `git clone https://github.com/bronson/vim-update-bundles.git`
+* rubygem: `gem install vim-update-bundles`
+* no install: `curl -s https://raw.github.com/bronson/vim-update-bundles/master/vim-update-bundles | ruby`
+
+
+## Usage
+
+    $ ./vim-update-bundles --help
+
+If you're not already using Vim, vim-update-bundles will set up a typical vim environment.
+Edit your ~/.vimrc and run vim-update-bundles whenever you want changes to take effect.
+
+vim-update-bundles will use ~/.dotfiles if it exists; so, it works seamlessly
+with <http://github.com/ryanb/dotfiles> and friends. It also supports Git
+submodules (see the configuration section below).
+
+* _-n -\-no-updates_ Adds and deletes bundles but doesn't update them.
+  This prevents vim-update-bundles from laboriously scrubbing through every
+  bundle in your .vimrc when you just want to make a quick change.
+
+* _-s -\-submodule_ installs bundles as submodules intead of plain Git
+  repositories. You must create the parent repository to contain the
+  submodules before running vim-update bundles.
+
+* _-v -\-verbose_ prints more information about what's happening.
+
+
+## Specifying Plugins
+
+vim-update-bundles reads the plugins you want installed from your ~/.vimrc.
+Here are the directives it recognizes:
+
+#### Bundle:
+
+Any line of the format `" Bundle: URL [REV]` (not case sensitive) will be
+interpreted as a bundle to download.  _URL_ points to a Git repository and
+_REV_ is an optional refspec (Git branch, tag, or hash). This allows you to
+follow a branch or lock the bundle to a specific tag or commit, i.e.:
+
+    " Bundle: https://github.com/tpope/vim-endwise.git v1.0
+
+If the script lives on vim-scripts or GitHub, the URL can be abbreviated:
+
+    " Bundle: tpope/vim-endwise    ->    https://github.com/tpope/vim-endwise.git
+    " Bundle: endwise.vim          ->    https://github.com/vim-scripts/endwise.vim.git
+
+vim-update-bundles never deletes files.  When you uninstall a plugin, it moves it to the .vim/Trashed-Bundles directory.
+
+#### BundleCommand:
+
+Some bundles need to be built after they're installed. Place any number of
+`BundleCommand:` directives after `Bundle:` to execute shell commands within
+the bundle's directory. To install Command-T and ensure "rake make" is called
+every time it's updated:
+
+    " Bundle: https://git.wincent.com/command-t.git
+    " BundleCommand: rake make
+
+#### Static:
+
+If you have directories in ~/.vim/bundle that you'd like vim-update-bundles to
+ignore, mark them as static.
+
+     " Static: my-plugin
+
+
+## Configuration File
+
+All configuration options can be passed on the command line or placed in ~/.vim-update-bundles.conf.
+Putting "submodules=1" in the config file is the same as passing -s or --submodules on the command line.
+Blank lines and comments starting with '#' are ignored.
+
+String interpolation is performed on all values. First configuration settings
+are tried then environment variables. For instance, this would expand to
+"/home/_username_/.dotfiles/_username_/vim":
+
+    vimdir_path = $dotfiles_path/$USERNAME/vim
+
+
+## Location of .vim and .vimrc
+
+Unless you have a custom dotfiles configuration, you can probably skip this
+section.
+
+vim-update-bundles tries hard to figure out where you want to store your .vim
+directory and .vimrc file. It first looks for a dotfiles directory (~/.dotfiles
+or specified by dotfiles\_path).
+
+* dotfiles\_path = $HOME/.dotfiles
+
+If dotfiles\_path exists, then vim-update-bundles will use it; otherwise, it
+will use the default location:
+
+* vimdir\_path = $dotfiles\_path/vim
+* vimdir\_path = $HOME/.vim
+
+Finally, these are the places that vim-update-bundles will look for a .vimrc:
+
+* vimrc\_path = $dotfiles\_path/vim/vimrc
+* vimrc\_path = $dotfiles\_path/vimrc
+* vimrc\_path = $HOME/.vim/vimrc
+* vimrc\_path = $HOME/.vimrc
+
+It always updates the ~/.vim and ~/.vimrc symlinks; so, Vim can find the correct
+files.
+
+
+## Authors
+
+* [Scott Bronson](http://github.com/bronson)
+* [Sorin Ionescu](http://github.com/sorin-ionescu)
+* [steeef](http://github.com/steeef)
+* [Andreas Marienborg](http://github.com/omega)
+
+
+## Alternatives
+
+[Vundle](http://github.com/gmarik/vundle) by [gmarik](http://github.com/gmarik) is starting to look pretty awesome. 
+
+Additionally, see vim-scripts.org's [tools page](http://vim-scripts.org/vim/tools.html).
+

data/Rakefile

@@ -0,0 +1,5 @@
+task :default => [:test]
+
+task :test do
+  ruby "test.rb"
+end

data/test.rb

@@ -0,0 +1,660 @@
+require 'tempfile'
+require 'tmpdir'
+require 'test/unit'
+
+# You can specify where the tests will be run instead of mktmpdir's default:
+#   TESTDIR=/ramdisk/test ruby test.rb
+# You can also tell the tester to preserve the test directory after running:
+#   PRESERVE=1 ruby test.rb -n test_multiple_removes
+#
+# TODO: test when .vimrc and .vim/vimrc both exist, the former is preferred
+#
+# We shell to the executable; so, this isn't actually unit testing.
+# Has anyone written a functional test framework for executables?
+
+
+class TestUpdater < Test::Unit::TestCase
+  def prepare_test &block
+    # Creates a tmp dir to run the test in then yields to the test.
+    args = ['vimtest-']
+    args.push ENV['TESTDIR'] if ENV['TESTDIR']
+    if ENV['PRESERVE']
+      tmpdir = Dir.mktmpdir *args
+      prepare_test_trampoline tmpdir, block
+    else
+      Dir.mktmpdir(*args) do |tmpdir|
+        prepare_test_trampoline tmpdir, block
+      end
+    end
+  end
+
+  def prepare_test_trampoline tmpdir, block
+    create_mock_files tmpdir
+    Dir.mkdir "#{tmpdir}/home"
+    ENV['HOME']="#{tmpdir}/home"
+    ENV['TESTING']='1'
+    block.call "#{tmpdir}/home"
+  end
+
+  def write_file base, path, contents
+    File.open(File.join(base, path), 'w') { |f| f.write contents }
+  end
+
+  def create_mock_files tmpdir
+    # Creates mock files to download (it saves on bandwidth and test time).
+    write_file tmpdir, "pathogen",      "\" PATHOGEN SCRIPT"
+    write_file tmpdir, "starter-vimrc", "\" STARTER VIMRC"
+    @starter_urls = "starter_url='#{tmpdir}/starter-vimrc' pathogen_url='#{tmpdir}/pathogen'"
+  end
+
+  def create_mock_repo name
+    Dir.mkdir name
+    Dir.chdir name do
+      `git init`
+      write_file name, "first", "first"
+      `git add first`
+      `git commit -q -m first`
+    end
+  end
+
+  def update_mock_repo dir, name
+    Dir.chdir dir do
+      write_file dir, name, name
+      `git add '#{name}'`
+      `git commit -q -m '#{name}'`
+    end
+  end
+
+  def update_mock_repo_tagged dir, name, tag
+    update_mock_repo dir, name
+    Dir.chdir(dir) { `git tag -a #{tag} -m 'tag #{tag}'` }
+  end
+
+  def assert_test cmd, *files
+    files.each do |f|
+      assert test(?e, f), "#{f} does not exist!"
+      assert test(cmd, f), "#{f} is not a '#{cmd}'"
+    end
+  end
+
+  def refute_test cmd, *files
+    files.each do |f|
+      assert !test(cmd, f), "#{f} is a '#{cmd}'"
+    end
+  end
+
+  def check_tree base, vimdir='.vim', vimrc='.vimrc'
+    # Makes sure .vim, .vimrc, and the symlinks are set up correctly.
+
+    if vimdir == '.vim'
+      # No symlinks are needed.
+      assert_test ?d, "#{base}/.vim"
+    else
+      # it appears Rubinius has a bug  https://github.com/rubinius/rubinius/issues/1057
+      #assert_test ?l, "#{base}/.vim"
+      assert_equal File.readlink("#{base}/.vim"), "#{base}/#{vimdir}"
+    end
+
+    if vimrc == '.vimrc'
+      assert_test ?f, "#{base}/.vimrc"
+    else
+      # it appears Rubinius has a bug  https://github.com/rubinius/rubinius/issues/1057
+      #assert_test ?l, "#{base}/.vimrc"
+      assert_equal File.readlink("#{base}/.vimrc"), "#{base}/#{vimrc}"
+    end
+
+    assert_test ?f, "#{base}/#{vimdir}/autoload/pathogen.vim"
+    assert_test ?d, "#{base}/#{vimdir}"
+    assert_test ?f, "#{base}/#{vimrc}"
+  end
+
+  def run_vim_update_bundles *args
+    `./vim-update-bundles #{@starter_urls} #{args.join(' ')}`
+  end
+
+
+  # runs the command under test expecting there will not be an error
+  def vim_update_bundles *args
+    result = run_vim_update_bundles *args
+    raise "vim-update-bundles returned #{$?.exitstatus} RESULT: <<\n#{result}>>" unless $?.exitstatus == 0
+    result
+  end
+
+  # runs the command under test expecting that there WILL be an error
+  def vim_update_bundles__expect_error *args
+    result = run_vim_update_bundles *args + ['2>&1']
+    raise "vim-update-bundles returned #{$?.exitstatus} RESULT: <<\n#{result}>>" unless $?.exitstatus != 0
+    result
+  end
+
+
+  def test_standard_run
+    # Creates a starter environment then updates a few times.
+    prepare_test do |tmpdir|
+      vim_update_bundles
+      check_tree tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/doc/bundles.txt"
+      assert_test ?d, "#{tmpdir}/.vim/bundle"
+      assert_equal ['.', '..'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+
+      # Add a repository.
+      create_mock_repo "#{tmpdir}/repo"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      repo = "#{tmpdir}/.vim/bundle/repo" # The local repository, not the origin.
+      assert_test ?f, "#{repo}/first"
+      assert_equal 1, File.read("#{repo}/.git/info/exclude").scan("doc/tags").size
+
+      # Pull upstream changes.
+      update_mock_repo "#{tmpdir}/repo", "second"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      assert_equal 1, File.read("#{repo}/.git/info/exclude").scan("doc/tags").size
+
+      # Remove the repository.
+      write_file tmpdir, ".vimrc", ""
+      vim_update_bundles
+      refute_test ?d, repo
+    end
+  end
+
+
+  def test_dont_blow_away_existing_vimrc
+    # Do not destroy an existing .vimrc.
+    prepare_test do |tmpdir|
+      str = "don't tread on me"
+      write_file tmpdir, '.vimrc', str
+      vim_update_bundles "--vimrc_path='#{tmpdir}/.vimrc'"
+      assert_equal str, File.read("#{tmpdir}/.vimrc")
+    end
+  end
+
+
+  def test_submodule_run
+    # Creates a starter environment using submodules.
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/.vim"
+      Dir.chdir("#{tmpdir}/.vim") { `git init` }
+      vim_update_bundles
+      check_tree tmpdir, ".vim", ".vimrc"
+
+      # Add submodule.
+      create_mock_repo "#{tmpdir}/repo"
+      File.open("#{tmpdir}/.vim-update-bundles.conf", 'w') { |f| f.write "submodule = true" }
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo"
+
+      vim_update_bundles
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      repo = "#{tmpdir}/.vim/bundle/repo" # The local repository, not the origin.
+      assert_test ?f, "#{repo}/first"
+      assert_test ?f, "#{tmpdir}/.vim/.gitmodules"
+      assert_equal 1, File.read("#{repo}/.git/info/exclude").scan("doc/tags").size
+
+      # Pull upstream changes.
+      update_mock_repo "#{tmpdir}/repo", "second"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+
+      # Remove the repository.
+      write_file tmpdir, ".vimrc", ""
+      vim_update_bundles
+      refute_test ?d, repo
+
+      ['.gitmodules', '.git/config'].each do |filename|
+        text = File.read File.join(tmpdir, '.vim', filename)
+        assert_no_match /submodule.*repo/, text
+      end
+    end
+  end
+
+
+  def test_tag_checkout
+    # Ensures locking a checkout to a tag and that .vim/vimrc is used if it
+    # already exists.
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/.vim"
+      write_file tmpdir, ".vim/vimrc", ''
+      vim_update_bundles
+      check_tree tmpdir, ".vim", ".vim/vimrc"
+
+      # Make a repository with a tagged commit and commits after that.
+      create_mock_repo "#{tmpdir}/repo"
+      update_mock_repo_tagged "#{tmpdir}/repo", 'second', '0.2'
+      update_mock_repo "#{tmpdir}/repo", 'third'
+
+      # Check out the plugin locked at 0.2
+      write_file tmpdir, ".vim/vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
+
+      # Pull upstream changes, make sure we're still locked on 0.2.
+      update_mock_repo "#{tmpdir}/repo", "fourth"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/fourth"
+
+      # Switch to the branch head
+      write_file tmpdir, ".vim/vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
+
+      # Switch back to the tag
+      write_file tmpdir, ".vim/vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
+    end
+  end
+
+
+  def test_submodule_tag_checkout
+    # Ensures locking a checkout to a tag.
+    prepare_test do |tmpdir|
+      Dir.chdir(tmpdir) { `git init` }
+      vim_update_bundles '--submodule=true'
+      check_tree tmpdir
+
+      create_mock_repo "#{tmpdir}/repo"
+      update_mock_repo_tagged "#{tmpdir}/repo", 'second', '0.2'
+      update_mock_repo "#{tmpdir}/repo", 'third'
+
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles '--submodule=1'
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      assert_test ?f, "#{tmpdir}/.gitmodules"
+      repo = "#{tmpdir}/.vim/bundle/repo" # The local repository, not the origin.
+      `git ls-files --cached .vim/bundle/repo`
+      assert_test ?f, "#{repo}/first"
+      assert_test ?f, "#{repo}/second"
+      refute_test ?f, "#{repo}/third"
+
+      # Pull upstream changes.
+      update_mock_repo "#{tmpdir}/repo", "third"
+      vim_update_bundles '--submodule=1'
+      assert_test ?f, "#{repo}/second"
+      refute_test ?f, "#{repo}/third"
+      refute_test ?f, "#{repo}/fourth"
+    end
+  end
+
+
+  def test_branch_checkout
+    # Ensures new commits on a branch are followed.
+    prepare_test do |tmpdir|
+      vim_update_bundles
+      check_tree tmpdir
+
+      # Make a repository with another branch.
+      create_mock_repo "#{tmpdir}/repo"
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q -b abranch` }
+      update_mock_repo "#{tmpdir}/repo", 'b-second'
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q master` }
+      update_mock_repo "#{tmpdir}/repo", 'second'
+
+      # Clone repository on the given branch.
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      repo = "#{tmpdir}/.vim/bundle/repo" # The local repository, not the origin.
+      assert_test ?f, "#{repo}/first"
+      assert_test ?f, "#{repo}/b-second"
+      refute_test ?f, "#{repo}/second"
+
+      # Pull upstream changes.
+      update_mock_repo "#{tmpdir}/repo", "third"
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q abranch` }
+      update_mock_repo "#{tmpdir}/repo", "b-third"
+      vim_update_bundles
+      assert_test ?f, "#{repo}/b-second"
+      assert_test ?f, "#{repo}/b-third"
+      refute_test ?f, "#{repo}/second"
+      refute_test ?f, "#{repo}/third"
+
+      # Switch to the master branch
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles
+      assert_test ?f, "#{repo}/second"
+      assert_test ?f, "#{repo}/third"
+      refute_test ?f, "#{repo}/b-second"
+      refute_test ?f, "#{repo}/b-third"
+
+      # And switch back to our branch
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles
+      assert_test ?f, "#{repo}/b-second"
+      assert_test ?f, "#{repo}/b-third"
+      refute_test ?f, "#{repo}/second"
+      refute_test ?f, "#{repo}/third"
+    end
+  end
+
+
+  def test_submodule_branch_checkout
+    # Ensures locking a checkout to a tag.
+    prepare_test do |tmpdir|
+      Dir.chdir(tmpdir) { `git init` }
+      vim_update_bundles '--submodule=true'
+      check_tree tmpdir
+
+      # Make a repository with another branch.
+      create_mock_repo "#{tmpdir}/repo"
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q -b abranch` }
+      update_mock_repo "#{tmpdir}/repo", 'b-second'
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q master` }
+      update_mock_repo "#{tmpdir}/repo", 'second'
+
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles '--submodule=1'
+      assert_equal ['.', '..', 'repo'], Dir.open("#{tmpdir}/.vim/bundle") { |d| d.sort }
+      assert_test ?f, "#{tmpdir}/.gitmodules"
+      repo = "#{tmpdir}/.vim/bundle/repo" # The local repository, not the origin.
+      `git ls-files --cached .vim/bundle/repo`
+      assert_test ?f, "#{repo}/first"
+      assert_test ?f, "#{repo}/b-second"
+      refute_test ?f, "#{repo}/second"
+
+      # Pull upstream changes.
+      update_mock_repo "#{tmpdir}/repo", "third"
+      Dir.chdir("#{tmpdir}/repo") { `git checkout -q abranch` }
+      update_mock_repo "#{tmpdir}/repo", "b-third"
+      vim_update_bundles '--submodule=1'
+      assert_test ?f, "#{repo}/b-second"
+      assert_test ?f, "#{repo}/b-third"
+      refute_test ?f, "#{repo}/third"
+    end
+  end
+
+
+  def test_clone_nonexistent_branch
+    # Ensures we error out if we find a nonexistent branch or tag (same code path)
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      create_mock_repo "#{tmpdir}/repo2"
+
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo1 nobranch\n\" Bundle: #{tmpdir}/repo2"
+      vim_update_bundles__expect_error
+      refute_test ?d, "#{tmpdir}/.vim/bundle/repo2"    # ensure we didn't continue cloning repos
+    end
+  end
+
+
+  def test_update_to_nonexistent_branch
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      create_mock_repo "#{tmpdir}/repo2"
+
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo1"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/first"
+
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo1 v0.2\n\" Bundle: #{tmpdir}/repo2"
+      vim_update_bundles__expect_error
+      refute_test ?d, "#{tmpdir}/.vim/bundle/repo2"    # ensure we didn't continue cloning repos
+    end
+  end
+
+
+  def test_multiple_removes
+    # add and remove a plugin multiple times
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/plugin1"
+      4.times do
+        write_file tmpdir, '.vimrc', "\" Bundle: #{tmpdir}/plugin1"
+        vim_update_bundles
+        assert_test ?d, "#{tmpdir}/.vim/bundle/plugin1"
+
+        write_file tmpdir, '.vimrc', ''
+        vim_update_bundles
+        refute_test ?d, "#{tmpdir}/.vim/bundle/plugin1"
+      end
+    end
+  end
+
+
+  def test_bundle_command    # oops, there's some duplication with test_working_bundle_command
+    prepare_test do |tmpdir|
+      # ensure BundleCommand is called when adding a repo
+      create_mock_repo "#{tmpdir}/plugin1"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" BundleCommand: touch '#{tmpdir}/sentinel1'"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/sentinel1"
+
+      # ensure BundleCommand is called when updating a repo
+      update_mock_repo "#{tmpdir}/plugin1", "second"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" Bundle-Command: touch '#{tmpdir}/sentinel2'"
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/sentinel2"
+
+      # ensure BundleCommand is NOT called when updating a repo when --no-updates is on
+      update_mock_repo "#{tmpdir}/plugin1", "second"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" BundleCommand: touch '#{tmpdir}/sentinel3'"
+      vim_update_bundles '--no-updates'
+      refute_test ?f, "#{tmpdir}/sentinel3"
+    end
+  end
+
+
+  def test_working_bundle_command
+    prepare_test do |tmpdir|
+      vim_update_bundles
+      check_tree tmpdir
+      create_mock_repo "#{tmpdir}/repo"
+      write_file tmpdir, ".vimrc", <<-EOL
+        " Bundle: #{tmpdir}/repo
+        " Bundle command: echo hiya > #{tmpdir}/output
+      EOL
+
+      vim_update_bundles
+      assert_test ?f, "#{tmpdir}/output"
+      assert_equal "hiya\n", File.read("#{tmpdir}/output")
+    end
+  end
+
+
+  def test_failing_bundle_command
+    prepare_test do |tmpdir|
+      vim_update_bundles '#{@starter_urls}'
+      check_tree tmpdir
+
+      create_mock_repo "#{tmpdir}/repo"
+      write_file tmpdir, ".vimrc", <<-EOL
+        " Bundle: #{tmpdir}/repo
+        " Bundle-Command: oh-no-this-command-does-not-exist
+      EOL
+
+      vim_update_bundles__expect_error
+      assert $?.exitstatus == 47, "the bundle-command should have produced 47, not #{$?.exitstatus}"
+    end
+  end
+
+
+  def test_static_bundle
+    prepare_test do |tmpdir|
+      vim_update_bundles
+      Dir.mkdir "#{tmpdir}/.vim/bundle/foreign"
+      Dir.mkdir "#{tmpdir}/.vim/bundle/static"
+      write_file tmpdir, ".vimrc", '" Static: static'
+
+      vim_update_bundles
+      assert_test ?d, "#{tmpdir}/.vim/bundle/static"
+      refute_test ?d, "#{tmpdir}/.vim/bundle/foreign"
+      assert_test ?d, "#{tmpdir}/.vim/Trashed-Bundles/foreign-01"
+    end
+  end
+
+
+  def test_no_updates_run
+    # Makes sure we still add and delete even when --no-updates prevents updates
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/plugin1"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1"
+      vim_update_bundles '--no-updates'
+
+      # make sure plugin1 was added even though --no-updates was turned on
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/plugin1/second"
+
+      update_mock_repo "#{tmpdir}/plugin1", "second"
+      create_mock_repo "#{tmpdir}/plugin2"
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" Bundle: #{tmpdir}/plugin2"
+      vim_update_bundles '-n'   # test single-letter arg
+
+      # make sure plugin1 hasn't been updated but plugin2 has been added
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/plugin1/second"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin2/first"
+
+      # Remove the repository.
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1"
+      vim_update_bundles '--no-updates'
+
+      # make sure plugin1 hasn't been updated but plugin2 has been deleted
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/plugin1/second"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/plugin2/first"
+    end
+  end
+
+
+  def test_create_dotfile_environment
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/.dotfiles"
+      vim_update_bundles
+      check_tree tmpdir, '.dotfiles/vim', '.dotfiles/vimrc'
+    end
+  end
+
+
+  def test_create_dotfile_environment_with_vimrc_in_vim
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/zedots"
+      Dir.mkdir "#{tmpdir}/zedots/vim"
+      write_file tmpdir, "zedots/vim/vimrc", '" ignored'
+
+      vim_update_bundles "--dotfiles_path='#{tmpdir}/zedots'"
+      check_tree tmpdir, 'zedots/vim', 'zedots/vim/vimrc'
+      refute_test ?e, "#{tmpdir}/.dotfiles/.vimrc"
+      refute_test ?e, "#{tmpdir}/zedots/.vimrc"
+    end
+  end
+
+
+  def test_create_custom_vimrc_environment
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/mydots"
+      vim_update_bundles "vimrc_path='#{tmpdir}/mydots/vim rc'"
+      check_tree tmpdir, '.vim', 'mydots/vim rc'
+    end
+  end
+
+
+  def test_create_custom_conffile_environment
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/parent"
+      Dir.mkdir "#{tmpdir}/parent/child"
+      ENV['PARENT'] = 'parent'
+      File.open("#{tmpdir}/.vim-update-bundles.conf", 'w') { |f|
+        f.write "vimrc_path = #{tmpdir}/$PARENT/child/vv zz"
+      }
+      vim_update_bundles
+      check_tree tmpdir, '.vim', 'parent/child/vv zz'
+    end
+  end
+
+
+  def test_interpolation_works
+    prepare_test do |tmpdir|
+      vim_update_bundles "--vimdir_path='$HOME/vimmy' --vimrc_path='$vimdir_path/vimmyrc'"
+      check_tree tmpdir, 'vimmy', 'vimmy/vimmyrc'
+    end
+  end
+
+
+  def test_unknown_interpolation_fails
+    prepare_test do |tmpdir|
+      vim_update_bundles__expect_error "--verbose='$unknown'"
+      assert $?.exitstatus == 1, "the bundle-command should have produced 1, not #{$?.exitstatus}"
+      # Make sure it didn't create any files.
+      refute_test ?e, "#{tmpdir}/.vim"
+      refute_test ?e, "#{tmpdir}/.vimrc"
+    end
+  end
+
+
+  def ensure_marker log, marker_string
+    # ensure marker is still in file but not at the top
+    assert_match /#{marker_string}/, log
+    assert_equal "*bundle-log.txt*", log[0..15]
+    # also ensure the header only appears once
+    assert_no_match /\*bundle-log\.txt\*/, log[15..-1]
+  end
+
+
+  def test_bundles_txt_and_logfile
+    # ensures .vim/doc/bundles.txt and bundle-log.txt are filled in
+    prepare_test do |tmpdir|
+
+      # test logfiles with an empty .vimrc
+      Dir.mkdir "#{tmpdir}/.vim"
+      write_file tmpdir, ".vimrc", ''
+      vim_update_bundles
+
+      assert_test ?f, "#{tmpdir}/.vim/doc/bundles.txt"
+      assert_test ?f, "#{tmpdir}/.vim/doc/bundle-log.txt"
+
+      # Make a repository with a tagged commit and commits after that.
+      create_mock_repo "#{tmpdir}/repo"
+      update_mock_repo_tagged "#{tmpdir}/repo", 'second', '0.2'
+      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles
+
+      list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+
+      assert_match /\|repo\|\s*0\.2/, list
+      assert_no_match /\|repo\|\s*0\.3/, list # duh
+      assert_match /Add\s*\|repo\|\s*0\.2/, log
+
+      marker_string = "A marker to ensure the logfile is not changed"
+      File.open("#{tmpdir}/.vim/doc/bundle-log.txt", "a") { |f| f.puts marker_string }
+
+      # Pull upstream changes.
+      update_mock_repo_tagged "#{tmpdir}/repo", 'third', '0.3'
+      vim_update_bundles
+
+      list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+
+      assert_no_match /\|repo\|\s*0\.2/, list
+      assert_match /\|repo\|\s*0\.3/, list
+      assert_match /Add\s*\|repo\|\s*0\.2/, log
+      assert_match /up\s*\|repo\|\s*0\.2\s*->\s*0\.3/, log
+      ensure_marker log, marker_string
+
+      # won't bother changing the remote since vim-update-bundles handles it
+      # as a delete followed by an add.  might be worth testing though.
+
+      write_file tmpdir, ".vimrc", ''
+      vim_update_bundles
+
+      list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+
+      assert_no_match /\|repo\|\s*0\.2/, list
+      assert_no_match /\|repo\|\s*0\.3/, list
+      assert_match /Add\s*\|repo\|\s*0\.2/, log
+      assert_match /up\s*\|repo\|\s*0\.2\s*->\s*0\.3/, log
+      assert_match /Del\s*\|repo\|\s*0\.3/, log
+      ensure_marker log, marker_string
+    end
+  end
+end
+