vim-update-bundles 0.6 → 0.8

data/CHANGES

@@ -1,3 +1,13 @@
+0.8     15 Jul 2011
+- Support Vundle directives so both tools can read the same .vimrc.
+- When pull fails, remove and re-clone the repo instead of aborting.
+- vim-update-bundles no longer symlinks .vim and .vimrc into $HOME.
+- Remove the dotfile_path option, it's not necessary anymore.
+- Finding .vim and .vimrc has been simplified, see the readme.
+- No longer trim 'vim-' from the front of repo names in ~/.vim/bundle.
+- We now check for duplicate and conflicting Bundle entries.
+- All known tests written, all todos fixed.  1.0 is close.
+
 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.

data/README.md

@@ -7,17 +7,22 @@ Use Pathogen and Git to manage your Vim plugins.
 
 ## Description
 
-To install a plugin, put lines like this in your ~/.vimrc:
+To install plugins, 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.
+    " Bundle: jQuery                                  # https://github.com/vim-scripts/jQuery
+    " Bundle: scrooloose/nerdtree                     # https://github.com/scrooloose/nerdtree
+    " Bundle: git://git.wincent.com/command-t.git     # Full URL to the repo to clone
 
-Now, run `./vim-update-bundles`.  Your plugins are installed and ready for use.
+When you run `./vim-update-bundles`, your plugins will be 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.
+Also look at `:help bundle-log`.
+
+It works with [~/.dotfiles](http://github.com/ryanb/dotfiles) and Git submodules.
+
+If you're not already using Vim, just run `./vim-update-bundles` and a full environment
+will be set up for you.
 
 
 ## Installation
@@ -31,14 +36,10 @@ One of:
 
 ## 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).
+Just run `./vim-update-bundles` to install and remove plugins to match
+the ones named in your ~/.vimrc.
+If you're not already using Vim, vim-update-bundles will also install
+Pathogen, a sample .vimrc, and get everything ready to go.
 
 * _-n -\-no-updates_ Adds and deletes bundles but doesn't update them.
   This prevents vim-update-bundles from laboriously scrubbing through every
@@ -49,11 +50,19 @@ submodules (see the configuration section below).
   submodules before running vim-update bundles.
 
 * _-v -\-verbose_ prints more information about what's happening.
+  Pass multiple -v -v -v for more verbosity.
+
+* _-\-vimdir-path=path_ specifies the .vim directory that will contain
+  your autoload and bundles.
+
+* _\-vimrc-path_ specifies the location of your ~/.vimrc file.
+
+* _-\-help_ prints usage information.
 
 
 ## Specifying Plugins
 
-vim-update-bundles reads the plugins you want installed from your ~/.vimrc.
+vim-update-bundles reads the plugins you want installed from comments in your ~/.vimrc.
 Here are the directives it recognizes:
 
 #### Bundle:
@@ -90,49 +99,51 @@ ignore, mark them as static.
      " Static: my-plugin
 
 
-## Configuration File
+### Vundle
 
-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.
+vim-update-bundles also supports Vundle-style directives.  This allows you to use
+either tool to manage your bundles, whichever is more convenient at the time.
+This is brand new so problems are not unexpected.
 
-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
+## 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 --submodules on the command line.
 
-## Location of .vim and .vimrc
+Blank lines and comments starting with # are ignored.
 
-Unless you have a custom dotfiles configuration, you can probably skip this
-section.
+String interpolation is performed on all values.
+First configuration settings are tried, then environment variables.
+Here's an example vim-update-bundles.conf file:
 
-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).
+    # use shared vim environment
+    vimdir_path = $HOME/vim/$USERNAME
+    vimrc_path = $vimdir_path/vimrc
 
-* dotfiles\_path = $HOME/.dotfiles
 
-If dotfiles\_path exists, then vim-update-bundles will use it; otherwise, it
-will use the default location:
+## Location of .vim and .vimrc
+
+vim-update-bundles will use ~/.vim and ~/.vimrc if they exist.
+Since this is also what Vim uses, most people can stop reading here.
 
-* vimdir\_path = $dotfiles\_path/vim
-* vimdir\_path = $HOME/.vim
+If ~/.dotfiles exists, vim-update-bundles will look for .dotfiles/vim and .dotfiles/vimrc.
 
-Finally, these are the places that vim-update-bundles will look for a .vimrc:
+If your dotfiles are in a custom place, you can specify --vimdir-path and --vimrc-path
+on the command line or in vim-update-bundles.conf.
 
-* vimrc\_path = $dotfiles\_path/vim/vimrc
-* vimrc\_path = $dotfiles\_path/vimrc
-* vimrc\_path = $HOME/.vim/vimrc
-* vimrc\_path = $HOME/.vimrc
+If vim-update-bundles still can't find a Vim environment, it will create one for you.
+It creates the ~/.vim directory and gives you a default ~/.vimrc, downloads and installs Pathogen,
+and leaves everything ready to roll.
 
-It always updates the ~/.vim and ~/.vimrc symlinks; so, Vim can find the correct
-files.
+If you're unsure which vimdir_path and vimrc_path are being used,
+`vim-update-bundles --verbose` will tell you.
 
 
 ## Authors
 
+This software is released under the [MIT License](http://en.wikipedia.org/wiki/Mit_license).
+
 * [Scott Bronson](http://github.com/bronson)
 * [Sorin Ionescu](http://github.com/sorin-ionescu)
 * [steeef](http://github.com/steeef)

data/Rakefile

@@ -1,5 +1,28 @@
+require 'rake/clean'
+
+coverage_file = "aggregate.rcov"
+CLEAN.include('vim-update-bundles-*.gem', 'coverage', coverage_file)
+
 task :default => [:test]
 
 task :test do
   ruby "test.rb"
 end
+
+task :rcov do
+  system "rm -rf coverage #{coverage_file}"
+  ENV['RCOV'] = coverage_file
+  ruby "test.rb"
+  system "rcov -x analyzer --aggregate #{coverage_file} -t"
+  puts 'Open coverage/index.html to see rcov results.'
+end
+
+task :build  do
+  system 'gem build vim-update-bundles.gemspec'
+end
+
+task :release do
+  $load_only = true
+  Kernel.load 'vim-update-bundles'
+  system "gem push vim-update-bundles-#{Version}.gem"
+end

data/test.rb

@@ -1,16 +1,14 @@
+require 'test/unit'
 require 'tempfile'
 require 'tmpdir'
-require 'test/unit'
+require 'fileutils'
 
 # 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?
+#   PRESERVE=1 VERBOSE=1 ruby test.rb -n test_multiple_removes
+# VERBOSE=1 causes the vim-update-bundles commands to be printed.
+# TRACE=1 forces vim-update-bundles to include a stack trace in any errors.
 
 
 class TestUpdater < Test::Unit::TestCase
@@ -31,42 +29,43 @@ class TestUpdater < Test::Unit::TestCase
   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 }
+  def write_file path, contents
+    File.open(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"
+    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
+  def create_mock_repo name, author=nil
     Dir.mkdir name
     Dir.chdir name do
       `git init`
-      write_file name, "first", "first"
+      write_file "#{name}/first", "first"
       `git add first`
-      `git commit -q -m first`
+
+      command = "git commit -q -m first"
+      command = "sh -c 'GIT_AUTHOR_NAME='\\''#{author}'\\'' #{command}'" if author
+      `#{command}`
     end
   end
 
-  def update_mock_repo dir, name
+  def update_mock_repo dir, name="second", contents=nil
     Dir.chdir dir do
-      write_file dir, name, name
+      write_file "#{dir}/#{name}", contents || name
       `git add '#{name}'`
       `git commit -q -m '#{name}'`
     end
   end
 
-  def update_mock_repo_tagged dir, name, tag
-    update_mock_repo dir, name
+  def update_mock_repo_tagged dir, name, tag, contents=nil
+    update_mock_repo dir, name, contents
     Dir.chdir(dir) { `git tag -a #{tag} -m 'tag #{tag}'` }
   end
 
@@ -83,47 +82,37 @@ class TestUpdater < Test::Unit::TestCase
     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"
+  def check_tree base, vimdir='.vim', vimrc='.vimrc'
     assert_test ?d, "#{base}/#{vimdir}"
+    assert_test ?f, "#{base}/#{vimdir}/autoload/pathogen.vim"
     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 and check the exit status
+  def vim_update_bundles tmpdir, *args
+    options = { :acceptable_exit_codes => [0], :stderr => nil }
+    options.merge!(args.pop) if args.last.kind_of?(Hash)
 
-  # 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
+    runner = prearg = ''
+    if ENV['RCOV']
+      # run 'rake rcov' to run the coverage of all tests
+      runner = "rcov -x analyzer --aggregate '#{ENV['RCOV']}' --no-html "
+      prearg = ' -- '
+    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
+    redirects = ' 2>/dev/null' if options[:stderr] == :suppress
+    redirects = ' 2>&1' if options[:stderr] == :merge
+    command = "HOME='#{tmpdir}' TESTING=1 #{runner} ./vim-update-bundles #{prearg} #{@starter_urls} #{args.join(' ')} #{redirects}"
+    STDERR.puts "Running: #{command}" if ENV['VERBOSE']
+    result = `#{command}`
+
+    unless options[:acceptable_exit_codes].include?($?.exitstatus)
+      raise "vim-update-bundles returned #{$?.exitstatus} " +
+        "instead of #{options[:acceptable_exit_codes].inspect} " +
+        "RESULT: <<\n#{result}>>"
+    end
     result
   end
 
@@ -131,7 +120,7 @@ class TestUpdater < Test::Unit::TestCase
   def test_standard_run
     # Creates a starter environment then updates a few times.
     prepare_test do |tmpdir|
-      vim_update_bundles
+      vim_update_bundles tmpdir
       check_tree tmpdir
       assert_test ?f, "#{tmpdir}/.vim/doc/bundles.txt"
       assert_test ?d, "#{tmpdir}/.vim/bundle"
@@ -139,23 +128,29 @@ class TestUpdater < Test::Unit::TestCase
 
       # Add a repository.
       create_mock_repo "#{tmpdir}/repo"
-      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo"
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles tmpdir
       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
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+      assert_match /1 bundle added$/, log
 
       # Pull upstream changes.
       update_mock_repo "#{tmpdir}/repo", "second"
-      vim_update_bundles
+      vim_update_bundles tmpdir
       assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
       assert_equal 1, File.read("#{repo}/.git/info/exclude").scan("doc/tags").size
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+      assert_match /1 bundle updated$/, log
 
       # Remove the repository.
-      write_file tmpdir, ".vimrc", ""
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", ""
+      vim_update_bundles tmpdir
       refute_test ?d, repo
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+      assert_match /1 bundle removed$/, log
     end
   end
 
@@ -164,8 +159,8 @@ class TestUpdater < Test::Unit::TestCase
     # 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'"
+      write_file "#{tmpdir}/.vimrc", str
+      vim_update_bundles tmpdir, "--vimrc_path='#{tmpdir}/.vimrc'"
       assert_equal str, File.read("#{tmpdir}/.vimrc")
     end
   end
@@ -176,15 +171,15 @@ class TestUpdater < Test::Unit::TestCase
     prepare_test do |tmpdir|
       Dir.mkdir "#{tmpdir}/.vim"
       Dir.chdir("#{tmpdir}/.vim") { `git init` }
-      vim_update_bundles
+      vim_update_bundles tmpdir
       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"
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
 
-      vim_update_bundles
+      vim_update_bundles tmpdir
       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"
@@ -193,12 +188,12 @@ class TestUpdater < Test::Unit::TestCase
 
       # Pull upstream changes.
       update_mock_repo "#{tmpdir}/repo", "second"
-      vim_update_bundles
+      vim_update_bundles tmpdir
       assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
 
       # Remove the repository.
-      write_file tmpdir, ".vimrc", ""
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", ""
+      vim_update_bundles tmpdir
       refute_test ?d, repo
 
       ['.gitmodules', '.git/config'].each do |filename|
@@ -214,9 +209,9 @@ class TestUpdater < Test::Unit::TestCase
     # already exists.
     prepare_test do |tmpdir|
       Dir.mkdir "#{tmpdir}/.vim"
-      write_file tmpdir, ".vim/vimrc", ''
-      vim_update_bundles
-      check_tree tmpdir, ".vim", ".vim/vimrc"
+      write_file "#{tmpdir}/.vimrc", ''
+      vim_update_bundles tmpdir
+      check_tree tmpdir, ".vim", ".vimrc"
 
       # Make a repository with a tagged commit and commits after that.
       create_mock_repo "#{tmpdir}/repo"
@@ -224,8 +219,8 @@ class TestUpdater < Test::Unit::TestCase
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles tmpdir
       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"
@@ -233,21 +228,21 @@ class TestUpdater < Test::Unit::TestCase
 
       # Pull upstream changes, make sure we're still locked on 0.2.
       update_mock_repo "#{tmpdir}/repo", "fourth"
-      vim_update_bundles
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles tmpdir
       assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
       assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
       refute_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
@@ -259,15 +254,15 @@ class TestUpdater < Test::Unit::TestCase
     # Ensures locking a checkout to a tag.
     prepare_test do |tmpdir|
       Dir.chdir(tmpdir) { `git init` }
-      vim_update_bundles '--submodule=true'
+      vim_update_bundles tmpdir, '--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'
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo 0.2"
+      vim_update_bundles tmpdir, '--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.
@@ -278,7 +273,7 @@ class TestUpdater < Test::Unit::TestCase
 
       # Pull upstream changes.
       update_mock_repo "#{tmpdir}/repo", "third"
-      vim_update_bundles '--submodule=1'
+      vim_update_bundles tmpdir, '--submodule=1'
       assert_test ?f, "#{repo}/second"
       refute_test ?f, "#{repo}/third"
       refute_test ?f, "#{repo}/fourth"
@@ -289,7 +284,7 @@ class TestUpdater < Test::Unit::TestCase
   def test_branch_checkout
     # Ensures new commits on a branch are followed.
     prepare_test do |tmpdir|
-      vim_update_bundles
+      vim_update_bundles tmpdir
       check_tree tmpdir
 
       # Make a repository with another branch.
@@ -300,8 +295,8 @@ class TestUpdater < Test::Unit::TestCase
       update_mock_repo "#{tmpdir}/repo", 'second'
 
       # Clone repository on the given branch.
-      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo abranch"
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles tmpdir
       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"
@@ -312,23 +307,23 @@ class TestUpdater < Test::Unit::TestCase
       update_mock_repo "#{tmpdir}/repo", "third"
       Dir.chdir("#{tmpdir}/repo") { `git checkout -q abranch` }
       update_mock_repo "#{tmpdir}/repo", "b-third"
-      vim_update_bundles
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles tmpdir
       assert_test ?f, "#{repo}/b-second"
       assert_test ?f, "#{repo}/b-third"
       refute_test ?f, "#{repo}/second"
@@ -341,7 +336,7 @@ class TestUpdater < Test::Unit::TestCase
     # Ensures locking a checkout to a tag.
     prepare_test do |tmpdir|
       Dir.chdir(tmpdir) { `git init` }
-      vim_update_bundles '--submodule=true'
+      vim_update_bundles tmpdir, '--submodule=true'
       check_tree tmpdir
 
       # Make a repository with another branch.
@@ -351,8 +346,8 @@ class TestUpdater < Test::Unit::TestCase
       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'
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo abranch"
+      vim_update_bundles tmpdir, '--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.
@@ -365,7 +360,7 @@ class TestUpdater < Test::Unit::TestCase
       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'
+      vim_update_bundles tmpdir, '--submodule=1'
       assert_test ?f, "#{repo}/b-second"
       assert_test ?f, "#{repo}/b-third"
       refute_test ?f, "#{repo}/third"
@@ -379,8 +374,8 @@ class TestUpdater < Test::Unit::TestCase
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1 nobranch\n\" Bundle: #{tmpdir}/repo2"
+      vim_update_bundles tmpdir, :acceptable_exit_codes => [1], :stderr => :suppress
       refute_test ?d, "#{tmpdir}/.vim/bundle/repo2"    # ensure we didn't continue cloning repos
     end
   end
@@ -391,52 +386,263 @@ class TestUpdater < Test::Unit::TestCase
       create_mock_repo "#{tmpdir}/repo1"
       create_mock_repo "#{tmpdir}/repo2"
 
-      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/repo1"
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1"
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1 v0.2\n\" Bundle: #{tmpdir}/repo2"
+      vim_update_bundles tmpdir, :acceptable_exit_codes => [1], :stderr => :suppress
       refute_test ?d, "#{tmpdir}/.vim/bundle/repo2"    # ensure we didn't continue cloning repos
     end
   end
 
 
+  def test_duplicate_bundle_entries
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      write_file "#{tmpdir}/.vimrc",
+        "\" Bundle: #{tmpdir}/repo1\n" +
+        "\" Bundle: #{tmpdir}/repo1\n"
+      output = vim_update_bundles tmpdir, :acceptable_exit_codes => [1], :stderr => :merge
+      assert_match /duplicate entry for .*repo1/, output
+    end
+  end
+
+
+  def test_bundles_with_conflicting_names
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/one"
+      Dir.mkdir "#{tmpdir}/two"
+      create_mock_repo "#{tmpdir}/one/repo"
+      create_mock_repo "#{tmpdir}/two/repo"
+
+      # write a single .vimrc with conflicting bundles
+      write_file "#{tmpdir}/.vimrc",
+        "\" Bundle: #{tmpdir}/one/repo\n" +
+        "\" Bundle: #{tmpdir}/two/repo\n"
+      output = vim_update_bundles tmpdir, :acceptable_exit_codes => [1], :stderr => :merge
+      assert_match /urls map to the same bundle: .*repo and .*repo/, output
+    end
+  end
+
+
+  def test_remote_for_repo_is_changed
+    # plugin name stays the same but the Git url changes
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/one"
+      Dir.mkdir "#{tmpdir}/two"
+      create_mock_repo "#{tmpdir}/one/repo"
+      create_mock_repo "#{tmpdir}/two/repo"
+      update_mock_repo "#{tmpdir}/two/repo"
+
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/one/repo"
+      vim_update_bundles tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/two/repo"
+      output = vim_update_bundles tmpdir, :stderr => :merge
+      assert_match /bundle for repo changed/, output
+
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
+      assert_match /bundle for repo changed/, log
+    end
+  end
+
+
+  def git_sha repo, branch='HEAD'
+    # returns the sha of the topmost commit in the named branch
+    sha = `git --git-dir='#{repo}/.git' rev-parse #{branch}`.chomp
+    assert_match /^[0-9A-Fa-f]{40}/, sha
+    sha
+  end
+
+
+  def test_upstream_regenerates_ancestry_resets_repo
+    # Test what happens when the checked out git branch loses its ancestry.
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1"
+      vim_update_bundles tmpdir
+
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/first"
+      orig_head = git_sha("#{tmpdir}/.vim/bundle/repo1")
+      assert_equal orig_head, git_sha("#{tmpdir}/repo1")
+
+      # delete/regen repo so it looks identical but all SHAs are different
+      FileUtils.rm_rf "#{tmpdir}/repo1"
+      create_mock_repo "#{tmpdir}/repo1", "Invalid .-. Second Author"
+      vim_update_bundles tmpdir, :stderr => :merge
+
+      new_head = git_sha("#{tmpdir}/.vim/bundle/repo1")
+      assert_not_equal orig_head, new_head
+      assert_equal new_head, git_sha("#{tmpdir}/repo1")
+      assert_test ?d, "#{tmpdir}/.vim/Trashed-Bundles/repo1"  # make sure old was trashed
+    end
+  end
+
+
+  def test_pull_with_local_changes_resets_repo
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1"
+      vim_update_bundles tmpdir
+      # make sure repo was successfully cloned
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/first"
+      assert_equal "first", File.read("#{tmpdir}/.vim/bundle/repo1/first")
+
+      # make a conflicting local change and pull again
+      update_mock_repo "#{tmpdir}/repo1", "first", "second commit to first file"
+      write_file "#{tmpdir}/.vim/bundle/repo1/first", "local change"
+      vim_update_bundles tmpdir, :stderr => :merge
+
+      # make sure the local repo matches the latest upstream
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/first"
+      assert_equal "second commit to first file", File.read("#{tmpdir}/.vim/bundle/repo1/first")
+      # and also verify user's changes are preserved in .Trashed-Bundles
+      assert_test ?f, "#{tmpdir}/.vim/Trashed-Bundles/repo1/first"
+      assert_equal "local change", File.read("#{tmpdir}/.vim/Trashed-Bundles/repo1/first")
+    end
+  end
+
+
+  def test_pull_with_conflicting_local_file_resets_repo
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo1"
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo1"
+      vim_update_bundles tmpdir
+      # make sure repo was successfully cloned
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/first"
+      assert_equal "first", File.read("#{tmpdir}/.vim/bundle/repo1/first")
+
+      # make a conflicting local change and pull again
+      update_mock_repo "#{tmpdir}/repo1", "second"
+      write_file "#{tmpdir}/.vim/bundle/repo1/second", "changed!"
+      output = vim_update_bundles tmpdir, :stderr => :merge
+
+      # make sure the local repo matches the latest upstream
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo1/second"
+      assert_equal "second", File.read("#{tmpdir}/.vim/bundle/repo1/second")
+      # and also verify user's changes are preserved in .Trashed-Bundles
+      assert_test ?f, "#{tmpdir}/.vim/Trashed-Bundles/repo1/second"
+      assert_equal "changed!", File.read("#{tmpdir}/.vim/Trashed-Bundles/repo1/second")
+    end
+  end
+
+
+  def clone_and_delete_repo tmpdir, suffix
+    write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1"
+    vim_update_bundles tmpdir
+    assert_test ?d, "#{tmpdir}/.vim/bundle/plugin1"
+
+    write_file "#{tmpdir}/.vimrc", ''
+    vim_update_bundles tmpdir
+    refute_test ?d, "#{tmpdir}/.vim/bundle/plugin1"
+    assert_test ?d, "#{tmpdir}/.vim/Trashed-Bundles/plugin1#{suffix}"
+  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
+      clone_and_delete_repo tmpdir, ''
+      1.upto(5) { |i| clone_and_delete_repo tmpdir, "-#{"%02d" % i}" }
     end
   end
 
 
-  def test_bundle_command    # oops, there's some duplication with test_working_bundle_command
+  def test_multiple_remove_failure
+    # Plug up Trashed-Bundles so a bundle can't be removed to ensure
+    # that vim-update-bundles bails out and prints a decent error.
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/plugin1"
+      Dir.mkdir "#{tmpdir}/.vim"
+      Dir.mkdir "#{tmpdir}/.vim/Trashed-Bundles"
+      Dir.mkdir "#{tmpdir}/.vim/Trashed-Bundles/plugin1"
+      1.upto(99) { |i| Dir.mkdir "#{tmpdir}/.vim/Trashed-Bundles/plugin1-%02d" % i }
+
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1"
+      vim_update_bundles tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
+
+      write_file "#{tmpdir}/.vimrc", ''
+      output = vim_update_bundles tmpdir, :acceptable_exit_codes => [1], :stderr => :merge
+      assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
+      assert_match /unable to remove plugin1/, output
+    end
+  end
+
+
+  def test_submodule_remove_failure
+    prepare_test do |tmpdir|
+      Dir.mkdir "#{tmpdir}/.vim"
+      Dir.chdir("#{tmpdir}/.vim") { `git init` }
+      create_mock_repo "#{tmpdir}/repo"
+      # add plugin as a submodule
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles tmpdir, '--submodule'
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/.gitmodules"
+
+      # remove plugin but write-protect .gitmodules to force failure
+      write_file "#{tmpdir}/.vimrc", ''
+      File.chmod 0444, "#{tmpdir}/.vim/.gitmodules"
+      output = vim_update_bundles tmpdir, '--submodule', :acceptable_exit_codes => [1], :stderr => :merge
+      assert_match /could not delete repo from \.gitmodules/, output
+    end
+  end
+
+
+  def test_vundle_directives
+    # ensure vundle directives work
+    prepare_test do |tmpdir|
+      create_mock_repo "#{tmpdir}/repo"
+      # test Bundle and BundleCommand
+      write_file "#{tmpdir}/.vimrc", "Bundle '#{tmpdir}/repo'\n" +
+        "BundleCommand 'echo \"yep''s\" > ''#{tmpdir}/sentinel'''\n"
+      vim_update_bundles tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_equal "yep's\n", File.read("#{tmpdir}/sentinel")
+
+      # make sure Bundle accepts a branch/tag to check out
+      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 tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/second"
+      refute_test ?f, "#{tmpdir}/.vim/bundle/repo/third"
+
+      # mark the bundle as static, make sure it isn't removed
+      write_file "#{tmpdir}/.vimrc", "Bundle! 'repo'\n"
+      vim_update_bundles tmpdir
+      assert_test ?f, "#{tmpdir}/.vim/bundle/repo/first"
+    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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" BundleCommand: touch '#{tmpdir}/sentinel1'"
+      vim_update_bundles tmpdir
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" Bundle-Command: touch '#{tmpdir}/sentinel2'"
+      vim_update_bundles tmpdir
       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'
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" BundleCommand: touch '#{tmpdir}/sentinel3'"
+      vim_update_bundles tmpdir, '--no-updates'
       refute_test ?f, "#{tmpdir}/sentinel3"
     end
   end
@@ -444,15 +650,15 @@ class TestUpdater < Test::Unit::TestCase
 
   def test_working_bundle_command
     prepare_test do |tmpdir|
-      vim_update_bundles
+      vim_update_bundles tmpdir
       check_tree tmpdir
       create_mock_repo "#{tmpdir}/repo"
-      write_file tmpdir, ".vimrc", <<-EOL
+      write_file "#{tmpdir}/.vimrc", <<-EOL
         " Bundle: #{tmpdir}/repo
         " Bundle command: echo hiya > #{tmpdir}/output
       EOL
 
-      vim_update_bundles
+      vim_update_bundles tmpdir
       assert_test ?f, "#{tmpdir}/output"
       assert_equal "hiya\n", File.read("#{tmpdir}/output")
     end
@@ -461,32 +667,31 @@ class TestUpdater < Test::Unit::TestCase
 
   def test_failing_bundle_command
     prepare_test do |tmpdir|
-      vim_update_bundles '#{@starter_urls}'
+      vim_update_bundles tmpdir, '#{@starter_urls}'
       check_tree tmpdir
 
       create_mock_repo "#{tmpdir}/repo"
-      write_file tmpdir, ".vimrc", <<-EOL
+      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}"
+      vim_update_bundles tmpdir, :acceptable_exit_codes => [47], :stderr => :suppress
     end
   end
 
 
   def test_static_bundle
     prepare_test do |tmpdir|
-      vim_update_bundles
+      vim_update_bundles tmpdir
       Dir.mkdir "#{tmpdir}/.vim/bundle/foreign"
       Dir.mkdir "#{tmpdir}/.vim/bundle/static"
-      write_file tmpdir, ".vimrc", '" Static: static'
+      write_file "#{tmpdir}/.vimrc", '" Static: static'
 
-      vim_update_bundles
+      vim_update_bundles tmpdir
       assert_test ?d, "#{tmpdir}/.vim/bundle/static"
       refute_test ?d, "#{tmpdir}/.vim/bundle/foreign"
-      assert_test ?d, "#{tmpdir}/.vim/Trashed-Bundles/foreign-01"
+      assert_test ?d, "#{tmpdir}/.vim/Trashed-Bundles/foreign"
     end
   end
 
@@ -495,8 +700,8 @@ class TestUpdater < Test::Unit::TestCase
     # 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'
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1"
+      vim_update_bundles tmpdir, '--no-updates'
 
       # make sure plugin1 was added even though --no-updates was turned on
       assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
@@ -504,8 +709,8 @@ class TestUpdater < Test::Unit::TestCase
 
       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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1\n\" Bundle: #{tmpdir}/plugin2"
+      vim_update_bundles tmpdir, '-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"
@@ -513,8 +718,8 @@ class TestUpdater < Test::Unit::TestCase
       assert_test ?f, "#{tmpdir}/.vim/bundle/plugin2/first"
 
       # Remove the repository.
-      write_file tmpdir, ".vimrc", "\" Bundle: #{tmpdir}/plugin1"
-      vim_update_bundles '--no-updates'
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/plugin1"
+      vim_update_bundles tmpdir, '--no-updates'
 
       # make sure plugin1 hasn't been updated but plugin2 has been deleted
       assert_test ?f, "#{tmpdir}/.vim/bundle/plugin1/first"
@@ -524,25 +729,25 @@ class TestUpdater < Test::Unit::TestCase
   end
 
 
-  def test_create_dotfile_environment
+  def test_create_skips_dotfile_environment
     prepare_test do |tmpdir|
       Dir.mkdir "#{tmpdir}/.dotfiles"
-      vim_update_bundles
-      check_tree tmpdir, '.dotfiles/vim', '.dotfiles/vimrc'
+      vim_update_bundles tmpdir
+      check_tree tmpdir, '.vim', '.vimrc'
     end
   end
 
 
-  def test_create_dotfile_environment_with_vimrc_in_vim
+  def test_dotfiles_are_used_if_present
     prepare_test do |tmpdir|
-      Dir.mkdir "#{tmpdir}/zedots"
-      Dir.mkdir "#{tmpdir}/zedots/vim"
-      write_file tmpdir, "zedots/vim/vimrc", '" ignored'
+      Dir.mkdir "#{tmpdir}/.dotfiles"
+      Dir.mkdir "#{tmpdir}/.dotfiles/vim"
+      write_file "#{tmpdir}/.dotfiles/vimrc", ''
+      vim_update_bundles tmpdir
 
-      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"
+      check_tree tmpdir, '.dotfiles/vim', '.dotfiles/vimrc'
+      refute_test ?d, "#{tmpdir}/.vim"
+      refute_test ?f, "#{tmpdir}/.vimrc"
     end
   end
 
@@ -550,7 +755,7 @@ class TestUpdater < Test::Unit::TestCase
   def test_create_custom_vimrc_environment
     prepare_test do |tmpdir|
       Dir.mkdir "#{tmpdir}/mydots"
-      vim_update_bundles "vimrc_path='#{tmpdir}/mydots/vim rc'"
+      vim_update_bundles tmpdir, "vimrc_path='#{tmpdir}/mydots/vim rc'"
       check_tree tmpdir, '.vim', 'mydots/vim rc'
     end
   end
@@ -564,7 +769,7 @@ class TestUpdater < Test::Unit::TestCase
       File.open("#{tmpdir}/.vim-update-bundles.conf", 'w') { |f|
         f.write "vimrc_path = #{tmpdir}/$PARENT/child/vv zz"
       }
-      vim_update_bundles
+      vim_update_bundles tmpdir
       check_tree tmpdir, '.vim', 'parent/child/vv zz'
     end
   end
@@ -572,7 +777,7 @@ class TestUpdater < Test::Unit::TestCase
 
   def test_interpolation_works
     prepare_test do |tmpdir|
-      vim_update_bundles "--vimdir_path='$HOME/vimmy' --vimrc_path='$vimdir_path/vimmyrc'"
+      vim_update_bundles tmpdir, "--vimdir_path='$HOME/vimmy' --vimrc_path='$vimdir_path/vimmyrc'"
       check_tree tmpdir, 'vimmy', 'vimmy/vimmyrc'
     end
   end
@@ -580,8 +785,7 @@ class TestUpdater < Test::Unit::TestCase
 
   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}"
+      vim_update_bundles tmpdir, "--verbose='$unknown'", :acceptable_exit_codes => [1], :stderr => :suppress
       # Make sure it didn't create any files.
       refute_test ?e, "#{tmpdir}/.vim"
       refute_test ?e, "#{tmpdir}/.vimrc"
@@ -604,8 +808,8 @@ class TestUpdater < Test::Unit::TestCase
 
       # test logfiles with an empty .vimrc
       Dir.mkdir "#{tmpdir}/.vim"
-      write_file tmpdir, ".vimrc", ''
-      vim_update_bundles
+      write_file "#{tmpdir}/.vimrc", ''
+      vim_update_bundles tmpdir
 
       assert_test ?f, "#{tmpdir}/.vim/doc/bundles.txt"
       assert_test ?f, "#{tmpdir}/.vim/doc/bundle-log.txt"
@@ -613,8 +817,8 @@ class TestUpdater < Test::Unit::TestCase
       # 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
+      write_file "#{tmpdir}/.vimrc", "\" Bundle: #{tmpdir}/repo"
+      vim_update_bundles tmpdir
 
       list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
       log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
@@ -628,7 +832,7 @@ class TestUpdater < Test::Unit::TestCase
 
       # Pull upstream changes.
       update_mock_repo_tagged "#{tmpdir}/repo", 'third', '0.3'
-      vim_update_bundles
+      vim_update_bundles tmpdir
 
       list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
       log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
@@ -636,14 +840,14 @@ class TestUpdater < Test::Unit::TestCase
       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
+      assert_match /up\s*\|repo\|\s*0\.3\s*<-\s*0\.2/, 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
+      write_file "#{tmpdir}/.vimrc", ''
+      vim_update_bundles tmpdir
 
       list = File.read "#{tmpdir}/.vim/doc/bundles.txt"
       log = File.read "#{tmpdir}/.vim/doc/bundle-log.txt"
@@ -651,10 +855,43 @@ class TestUpdater < Test::Unit::TestCase
       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 /up\s*\|repo\|\s*0\.3\s*<-\s*0\.2/, log
       assert_match /Del\s*\|repo\|\s*0\.3/, log
       ensure_marker log, marker_string
     end
   end
+
+  def test_unknown_argument
+    result = vim_update_bundles '/dev/null', '--yarg', :acceptable_exit_codes => [1], :stderr => :merge
+    assert_match /Unknown option.*"yarg"/, result
+
+    result = vim_update_bundles '/dev/null', '-y', :acceptable_exit_codes => [1], :stderr => :merge
+    assert_match /Unknown option.*"y"/, result
+
+    result = vim_update_bundles '/dev/null', 'y', :acceptable_exit_codes => [1], :stderr => :merge
+    assert_match /Unknown option.*"y"/, result
+  end
+
+  def test_usage
+    result = vim_update_bundles '/dev/null', '--help'
+    assert_match /--no-updates/, result
+  end
+
+  def test_version
+    $load_only = true
+    Kernel.load 'vim-update-bundles'
+    result = vim_update_bundles '/dev/null', '--version'
+    assert_match /vim-update-bundles #{Version}/, result
+  end
+
+  def test_verbose
+    prepare_test do |tmpdir|
+      result = vim_update_bundles tmpdir, '--verbose'
+      assert_match /submodule = false/, result
+      assert_match /verbose = 1/, result
+      assert_match /vimdir_path = "#{tmpdir}\/\.vim"/, result
+      assert_match /vimrc_path = "#{tmpdir}\/\.vimrc"/, result
+    end
+  end
 end