vim-update-bundles 0.6 → 0.8

data/vim-update-bundles

@@ -3,27 +3,12 @@
 # Reads bundles to be installed from the .vimrc file then synchronizes
 # .vim/bundles by downloading new repositories as needed. It also removes
 # bundles that are no longer used.
-#
-# Specify a bundle in the .vimrc:
-#   " Bundle: https://git.wincent.com/command-t.git
-# Specify a refspec (branch, tag, hash) at the end:
-#   " Bundle: https://github.com/vim-ruby/vim-ruby.git noisy
-#   " Bundle: https://github.com/bronson/vim-closebuffer.git 0.2
-#   " Bundle: https://github.com/tpope/vim-rails.git 42bb0699
-#
-# If the .vim folder is stored in a Git repository, add bundles as submodules
-# by putting "submodule=true" in ~/.vim-update-bundles.conf.
+# This software is covered by the MIT License.
 
 require 'fileutils'
 require 'open-uri'
 
-Version = '0.6'
-
-
-def dotvim config, *path
-  # Path to files inside the .vim directory, e.g., dotvim/autoload.
-  File.join config[:vimdir_path], *path
-end
+Version = '0.8'
 
 
 def ensure_dir dir
@@ -43,21 +28,24 @@ end
 def run *cmd
   # Runs cmd, returns its stdout, and bails on error.
   # Mostly a backport of Ruby 1.9's IO.popen for 1.8.
-  options = { :acceptable_exit_codes => [0] }
+  options = { :acceptable_exit_codes => [0], :stderr => nil }
   options.merge!(cmd.pop) if cmd.last.kind_of?(Hash)
   puts "-> #{[cmd].join(" ")}" if $verbose
   outr, outw = IO::pipe
   pid = fork {
     outr.close; STDOUT.reopen outw; outw.close
+    STDERR.reopen '/dev/null', 'w' if options[:stderr] == :suppress
+    STDERR.reopen STDOUT if options[:stderr] == :merge
     exec *cmd.flatten.map { |c| c.to_s }
   }
   outw.close
   result = outr.read
   outr.close
   Process.waitpid pid
-  unless options[:acceptable_exit_codes].include?($?.exitstatus)
+  if options[:acceptable_exit_codes] != :any && !options[:acceptable_exit_codes].include?($?.exitstatus)
     raise "'#{[cmd].join(" ")}' in #{Dir.pwd} exited with code #{$?.exitstatus}"
   end
+  puts "RESULT #{$?.exitstatus}: <<#{result}>>" if $verbose && $verbose.to_i >= 2
   result
 end
 
@@ -70,15 +58,12 @@ def git *cmd
 end
 
 
-def describe_head dir
-  Dir.chdir(dir) do
-    # Don't want to use 'git describe --all' because branch names change too often.
-    # Use `` instead of git() so we don't error out if the git call fails.
-    # (might happen if there's a directory in .vim/bundle that isn't git-revisioned).
-    version = `git describe --tags 2>/dev/null`.chomp
-    version = `git rev-parse HEAD 2>/dev/null`[0..12] unless version =~ /\S/
-    version
-  end
+def describe_head
+  # Don't want to use 'git describe --all' because branch names change too often.
+  # This will fail if there's a directory in .vim/bundle that isn't git-revisioned.
+  version = git(:describe, '--tags', :acceptable_exit_codes => :any, :stderr => :suppress).chomp
+  version = git('rev-parse', 'HEAD', :acceptable_exit_codes => :any, :stderr => :suppress)[0..12] unless version =~ /\S/
+  version
 end
 
 
@@ -98,8 +83,8 @@ end
 
 
 def print_doc_entry dir, doc
-  version = describe_head dir
-  date = Dir.chdir(dir) { git(:log, '-1', '--pretty=format:%ai').chomp }
+  version = describe_head
+  date = git(:log, '-1', '--pretty=format:%ai').chomp
   doc.printf "  %-32s %-22s %s\n", "|#{dir}|", version, date.split(' ').first
 end
 
@@ -111,7 +96,14 @@ end
 
 
 def print_log_entry log, action, dir, rev, notes=""
-  log.printf " %-3s %-26s %-18s %s\n", action, "|#{dir}|", rev, notes
+  message = " %-3s %-26s %-18s %s" % [action, "|#{dir}|", rev, notes]
+  log.puts message.sub /\s+$/, ''
+end
+
+
+def log_error log, message
+  log.print " #{message}\n\n"  # puts suppresses trailing newline
+  STDERR.puts message
 end
 
 
@@ -125,14 +117,30 @@ def ignore_doc_tags
 end
 
 
-def in_git_root inpath=nil
+# Work around Ruby's useless "conflicting chdir during another chdir block" warning
+# A better_chdir block can contain a Dir.chdir block,
+# but a Dir.chdir block can't contain better_chdir.
+def better_chdir dir
+  orig = Dir.pwd
+  begin
+    Dir.chdir dir
+    yield
+  ensure
+    # If the last bundle is removed, git will remove ~/.vim/bundle too.
+    ensure_dir orig
+    Dir.chdir orig
+  end
+end
+
+
+def in_submodule_root config, inpath=nil
   # Submodules often require the CWD to be the Git root. If a path relative to
   # the CWD is passed, the block receives it relative to the root.
   path = File.join Dir.pwd, inpath if inpath
-  Dir.chdir("./" + git('rev-parse', '--show-cdup').chomp) do
+  better_chdir("./" + git('rev-parse', '--show-cdup').chomp) do
     path.sub! /^#{Dir.pwd}\/?/, '' if path
     yield path
-  end rescue nil # Git deletes the bundle dir if it's empty.
+  end
 end
 
 
@@ -142,26 +150,29 @@ def clone_bundle config, dir, url, tagstr, log
     git :clone, url, dir
   else
     puts "adding submodule #{dir} from #{url}#{tagstr}"
-    in_git_root(dir) { |mod| git :submodule, :add, url, mod }
+    in_submodule_root(config, dir) { |mod| git :submodule, :add, url, mod }
   end
-  print_log_entry log, 'Add', dir, describe_head(dir), "#{url}#{tagstr}"
+  Dir.chdir(dir) { print_log_entry log, 'Add', dir, describe_head, "#{url}#{tagstr}" }
+  $bundles_added += 1
 end
 
 
 def remove_bundle_to config, dir, destination
-  puts "Erasing #{dir}, find it in #{destination}"
+  puts "Removing #{dir}, find it in #{destination}"
   FileUtils.mv dir, destination
   if config[:submodule]
-    in_git_root(dir) do |mod|
+    in_submodule_root(config, dir) do |mod|
       git :rm, mod
+      fn = nil
       ['.gitmodules', '.git/config'].each do |filename|
         begin
+          fn = filename
           text = File.read filename
           File.open(filename, 'w+') do |file|
             file.puts text.gsub(/\[submodule "#{mod}"\][^\[]+/m,'')
           end
-        rescue
-          puts "  Could not delete submodule entries from .gitmodules and .git/config"
+        rescue Exception => e
+          raise "could not delete #{dir} from #{fn}: #{e}"
         end
       end
     end
@@ -170,13 +181,15 @@ end
 
 
 def remove_bundle config, dir, log
-  print_log_entry log, 'Del', dir, describe_head(dir)
-  trash_dir = dotvim(config, "Trashed-Bundles")
+  Dir.chdir(dir) { print_log_entry log, 'Del', dir, describe_head }
+  trash_dir = "#{config[:vimdir_path]}/Trashed-Bundles"
   ensure_dir trash_dir
-  1.upto(100) do |i|
-    destination = "#{trash_dir}/#{dir}-#{'%02d' % i}"
+  suffixes = [''] + (1..99).map { |i| "-#{"%02d" % i}" }
+  suffixes.each do |suffix|
+    destination = "#{trash_dir}/#{dir}#{suffix}"
     unless test ?d, destination
       remove_bundle_to config, dir, destination
+      $bundles_removed += 1
       return
     end
   end
@@ -184,47 +197,54 @@ def remove_bundle config, dir, log
 end
 
 
-def update_bundle config, dir, tag, tagstr, previous_version, log
-  Dir.chdir(dir) do
-    git :checkout, tag || :master
-    if system 'git symbolic-ref HEAD -q >/dev/null'
-      # only pull if symbolic-ref is true, otherwise it's detached head
-      git :pull, '--ff-only', :origin, tag || :master
-    end
-    ignore_doc_tags
-  end
+def reset_bundle config, dir, url, tagstr, log
+  remove_bundle config, dir, log
+  ensure_dir "#{config[:vimdir_path]}/bundle"
+  clone_bundle config, dir, url, tagstr, log
+end
+
 
-  if previous_version
-    new_version = describe_head dir
-    if new_version != previous_version
-      print_log_entry log, 'up', dir, previous_version, "-> #{new_version}#{tagstr}"
+def pull_bundle dir, tag, log
+  git :fetch, :origin, :stderr => :suppress  # git prints some needless warnings during fetch
+  git :checkout, tag || :master
+
+  # if it's a branch, we need to merge in upstream changes
+  if system 'git symbolic-ref HEAD -q >/dev/null'
+    output = git(:merge, '--ff-only', "origin/#{tag || :master}", :acceptable_exit_codes => :any, :stderr => :merge)
+    unless $?.success?
+      log_error log, output.gsub(/\s+/, ' ')
+      return false   # bundle is not OK and needs to be reset
     end
   end
 
-  in_git_root(dir) { |mod| git :add, mod } if config[:submodule]
+  return true   # bundle is good, let's continue
 end
 
 
-def download_bundle config, dir, url, tag, doc, log
+def install_bundle config, dir, url, tag, doc, log
   tagstr = " at #{tag}" if tag
   previous_version = nil
   only_updating = false
 
+  if url.match /^[A-Za-z0-9-]+\/[A-Za-z0-9._-]+$/  # User/repository.
+    url = "https://github.com/#{url}.git"
+  end
+  if url.match /^[A-Za-z0-9._-]+$/                 # Plain repository.
+    url = "https://github.com/vim-scripts/#{url}.git"
+  end
+
   # fetch bundle
   if test ?d, dir
     remote = Dir.chdir(dir)  { git(:config, '--get', 'remote.origin.url').chomp }
     if remote == url
       only_updating = true
       unless config[:no_updates]
-        previous_version = describe_head dir
+        Dir.chdir(dir) { previous_version = describe_head }
         puts "updating #{dir} from #{url}#{tagstr}"
-        Dir.chdir(dir) { git :fetch }
       end
     else
-      puts "repo has changed from #{remote} to #{url}"
-      remove_bundle config, dir, log
-      ensure_dir dotvim(config, 'bundle')
-      clone_bundle config, dir, url, tagstr, log
+      log_error log, "bundle for #{dir} changed from #{remote} to #{url}"
+      reset_bundle config, dir, url, tagstr, log
     end
   else
     clone_bundle config, dir, url, tagstr, log
@@ -232,10 +252,24 @@ def download_bundle config, dir, url, tag, doc, log
 
   # pull bundle
   unless only_updating && config[:no_updates]
-    update_bundle config, dir, tag, tagstr, previous_version, log
+    unless Dir.chdir(dir) { pull_bundle dir, tag, log }
+      reset_bundle config, dir, url, tagstr, log
+    end
+    Dir.chdir(dir) do
+      ignore_doc_tags
+      if previous_version
+        new_version = describe_head
+        if new_version != previous_version
+          print_log_entry log, 'up', dir, "#{new_version}#{tagstr}", "<- #{previous_version}"
+          $bundles_updated += 1 if only_updating
+        end
+      end
+    end
   end
 
-  print_doc_entry dir, doc
+  Dir.chdir(dir) { print_doc_entry dir, doc }
+  in_submodule_root(config, dir) { |mod| git :add, mod } if config[:submodule]
+
   only_updating
 end
 
@@ -260,33 +294,51 @@ def run_bundle_command dir, cmd
 end
 
 
+def vim_string str
+  if str.slice(0,1) == "'"
+    str =~ /^\s*'(.*)'\s*$/
+    return $1.gsub "''", "'"
+  elsif str.slice(0,1) == '"'
+    str =~ /^\s*"(.*)"\s*$/
+    return $1    # could do escape substitution here
+  else
+    return str
+  end
+end
+
+
 def update_bundles config, doc, log
   existing_bundles = Dir['*']
+  updated_bundles = {}
 
   # Ignore files in the bundle directory, e.g., READMEs.
   existing_bundles.reject! { |path| FileTest.file? path }
 
   dir = only_updating = nil
   puts "# reading vimrc" if config[:verbose]
+  string_re = %q{'([^']+|'')*'|"[^"]*"}  # captures single and double quoted Vim strings
   read_vimrc(config) do |line|
-    if line =~ /^\s*"\s*bundle:\s*(.*)$/i
-      url, tag = $1.split
+    if line =~ /^\s*"\s*bundle:\s*(.*)$/i ||
+       line =~ /^\s*Bundle\s*(#{string_re})/
+      url, tag = vim_string($1).split
       puts "# processing '#{url}' at '#{tag}'" if config[:verbose]
-      dir = url.split('/').last.gsub(/^vim-|\.git$/, '')
-      if url.match /^[A-Za-z0-9-]+\/[A-Za-z0-9._-]+$/  # User/repository.
-        url = "https://github.com/#{url}.git"
-      end
-      if url.match /^[A-Za-z0-9._-]+$/                 # Plain repository.
-        url = "https://github.com/vim-scripts/#{url}.git"
-      end
-      only_updating = download_bundle config, dir, url, tag, doc, log
+      dir = url.split('/').last.sub(/\.git$/, '')
+
+      # quick sanity check
+      raise "duplicate entry for #{url}" if updated_bundles[dir] == url
+      raise "urls map to the same bundle: #{updated_bundles[dir]} and #{url}" if updated_bundles[dir]
+
+      only_updating = install_bundle config, dir, url, tag, doc, log
+      updated_bundles[dir] = url
       existing_bundles.delete dir
-    elsif line =~ /^\s*"\s*bundle[ -]?command:\s*(.*)$/i
+    elsif line =~ /^\s*"\s*bundle[ -]?command:\s*(.*)$/i ||
+          line =~ /^\s*BundleCommand\s*(#{string_re})$/
       # Want BundleCommand but BUNDLE COMMAND and Bundle-Command used to be legal too
       raise "BundleCommand must come after Bundle" if dir.nil?
-      run_bundle_command dir, $1 unless only_updating && config[:no_updates]
-    elsif line =~ /^\s*"\s*static:\s*(.*)$/i
-      dir = $1
+      run_bundle_command dir, vim_string($1) unless only_updating && config[:no_updates]
+    elsif line =~ /^\s*"\s*static:\s*(.*)$/i ||
+          line =~ /^\s*Bundle!\s*(#{string_re})$/i
+      dir = vim_string $1
       puts "  leaving #{dir} alone"
       existing_bundles.delete dir
     end
@@ -294,7 +346,7 @@ def update_bundles config, doc, log
   existing_bundles.each { |dir| remove_bundle config, dir, log }
 
   if config[:submodule]
-    in_git_root do
+    in_submodule_root(config) do
       puts "  updating submodules"
       git :submodule, :init
       git :submodule, :update
@@ -303,27 +355,45 @@ def update_bundles config, doc, log
 end
 
 
+def bundleize count
+  "#{count} bundle#{count != 1 ? 's' : ''}"
+end
+
+def bundle_count_string
+  str = []
+  str << "#{bundleize $bundles_added} added" if $bundles_added > 0
+  str << "#{bundleize $bundles_removed} removed" if $bundles_removed > 0
+  str << "#{bundleize $bundles_updated} updated" if $bundles_updated > 0
+  return "no updates" if str.empty?
+
+  str[-1] = "and #{str[-1]}" if str.size > 2
+  str.join(", ")
+end
+
+
 def update_bundles_and_docs config
-  ensure_dir dotvim(config, 'doc')
-  bundle_dir = dotvim(config, 'bundle')
+  ensure_dir "#{config[:vimdir_path]}/doc"
+  bundle_dir = "#{config[:vimdir_path]}/bundle"
   ensure_dir bundle_dir
+  $bundles_added = $bundles_removed = $bundles_updated = 0
 
-  File.open(dotvim(config, 'doc', 'bundles.txt'), "w") do |doc|
+  File.open("#{config[:vimdir_path]}/doc/bundles.txt", "w") do |doc|
     print_doc_header doc
-    logfile = dotvim(config, 'doc', 'bundle-log.txt')
+    logfile = "#{config[:vimdir_path]}/doc/bundle-log.txt"
     log_already_exists = test ?f, logfile
     File.open(logfile, 'a') do |log|
       print_log_header log unless log_already_exists
-      log.puts "Updating on #{current_date}"
+      log.puts "#{current_date} by vim-update-bundles #{Version}"
       begin
-        Dir.chdir(bundle_dir) { update_bundles config, doc, log }
+        better_chdir(bundle_dir) { update_bundles config, doc, log }
       rescue Exception => e
         message = e.is_a?(Interrupt) ? "Interrupted" : "Aborted: #{e.message}"
-        log.print " #{message}\n\n"  # puts suppresses trailing newline
+        log_error log, message
         doc.puts message
-        STDERR.puts message
+        STDERR.puts e.backtrace if ENV['TRACE']
         exit e.respond_to?(:exit_code) ? e.exit_code : 1
       end
+      log.puts "   " + bundle_count_string
       log.puts
     end
     doc.puts
@@ -333,7 +403,7 @@ end
 
 def interpolate options, val, message, i
   raise "Interpolation is now $#{$1} instead of ENV[#{$1}] #{message} #{i}" if val =~ /ENV\[['"]?([^\]]*)['"]?\]/
-  STDERR.puts "WARNING: quotes in a config item are probably a mistake #{message} #{i}" if val =~ /["']/
+  STDERR.puts "WARNING: putting quotes in a config item is probably a mistake #{message} #{i}" if val =~ /["']/
 
   val.gsub(/\$([A-Za-z0-9_]+)/) { options[$1.to_sym] || ENV[$1] || raise("$#{$1} is not defined #{message} #{i}") }
 end
@@ -349,56 +419,36 @@ def process_options options, args, message
     k.gsub! '-', '_'             # underscorize args, 'no-updates' -> 'no_updates'
 
     unless options.has_key? k.to_sym
-      puts "Unknown option: #{k.inspect} #{message} #{i}"
+      STDERR.puts "Unknown option: #{k.inspect} #{message} #{i}"
       puts "Usage: #{help}" if args.equal? ARGV
       exit 1
     end
 
     v = options[k.to_sym].call(v) if options[k.to_sym].is_a? Proc
-    options[k.to_sym] = v ? interpolate(options,v,message,i).split("'").join("\\'") : true
+    options[k.to_sym] = v ? interpolate(options,v,message,i).split("'").join("\\'") : 1 + (options[k.to_sym] || 0)
   end
 end
 
 
 # Returns the first path that exists or the last one if nothing exists.
-def choose_file *paths
-  paths.find { |p| test ?f, p } || paths[-1]
-end
-
-
-def set_default_options opts
-  dotfiles = File.join(ENV['HOME'], '.dotfiles')
-  opts[:dotfiles_path] ||= dotfiles if test(?d, dotfiles)
-
-  if opts[:dotfiles_path]
-    raise "#{opts[:dotfiles_path]} doesn't exist!" unless test(?d, opts[:dotfiles_path])
-    opts[:vimdir_path] ||= File.join(opts[:dotfiles_path], 'vim')
-    opts[:vimrc_path] ||= choose_file(File.join([opts[:dotfiles_path], 'vim', 'vimrc']),
-                                      File.join([opts[:dotfiles_path], 'vimrc']))
-  else
-    opts[:vimdir_path] ||= File.join(ENV['HOME'], '.vim')
-    opts[:vimrc_path] ||= choose_file(File.join([ENV['HOME'], '.vim', 'vimrc']),
-                                      File.join([ENV['HOME'], '.vimrc']))
-  end
+def choose_path *paths
+  paths.find { |p| test ?e, p } || paths[-1]
 end
 
 
 def ensure_vim_environment config
-  ensure_dir dotvim(config)
-  ensure_dir dotvim(config, 'autoload')
+  ensure_dir config[:vimdir_path]
+  ensure_dir "#{config[:vimdir_path]}/autoload"
 
-  unless test ?f, dotvim(config, 'autoload', 'pathogen.vim')
+  unless test ?f, "#{config[:vimdir_path]}/autoload/pathogen.vim"
     puts "Downloading Pathogen..."
-    download_file config[:pathogen_url], dotvim(config, 'autoload', 'pathogen.vim')
+    download_file config[:pathogen_url], "#{config[:vimdir_path]}/autoload/pathogen.vim"
   end
 
   unless test(?f, config[:vimrc_path])
     puts "Downloading starter vimrc..."
     download_file config[:starter_url], config[:vimrc_path]
   end
-
-  run :ln, '-s', config[:vimdir_path], "#{ENV['HOME']}/.vim"  unless test ?e, "#{ENV['HOME']}/.vim"
-  run :ln, '-s', config[:vimrc_path], "#{ENV['HOME']}/.vimrc" unless test ?e, "#{ENV['HOME']}/.vimrc"
 end
 
 
@@ -409,15 +459,32 @@ def generate_helptags
 end
 
 
+def locate_vim_files config
+  vimdir_guess = choose_path "#{ENV['HOME']}/.dotfiles/vim", "#{ENV['HOME']}/.vim"
+
+  vimrc_guesses = []
+  if config[:vimdir_path]
+    vimrc_guesses.push "#{config[:vimdir_path]}/.vimrc", "#{config[:vimdir_path]}/vimrc" 
+  end
+  vimrc_guesses.push "#{ENV['HOME']}/.dotfiles/vimrc", "#{ENV['HOME']}/.vimrc"
+  vimrc_guess = choose_path *vimrc_guesses
+
+  config[:vimdir_path] ||= vimdir_guess
+  config[:vimrc_path] ||= vimrc_guess
+end
+
+
 def read_configuration config
   conf_file = File.join ENV['HOME'], '.vim-update-bundles.conf'
   process_options config, File.open(conf_file).readlines, "in #{conf_file} line" if test(?f, conf_file)
   process_options config, ARGV, "in command line argument"
 
-  set_default_options config
+  locate_vim_files config
 
-  config.keys.sort.each { |k| puts "# option #{k} = #{config[k].inspect}" } if config[:verbose]
-  config.delete :dotfiles_path       # Ensure it is not used accidentally later.
+  actual_keys = config.keys.reject { |k| config[k].is_a? Proc or config[k].is_a? Symbol }
+  actual_keys.map { |k| k.to_s }.sort.each do |k|
+    puts "# option #{k} = #{config[k.to_sym].inspect}"
+  end if config[:verbose]
 end
 
 
@@ -427,12 +494,11 @@ vim-update-bundles [options...]
   Updates the installed Vim plugins.
     -n --no-updates: don't update bundles, only add or delete (faster)
     -h -? --help:    print this message
-    -v --verbose:    print exactly what's happening
+    -v --verbose:    print what's happening (multiple -v for more verbose)
   optional configurations:
     -s --submodule:  store bundles as git submodules
     --vimdir-path:   path to ~/.vim directory
     --vimrc-path:    path to ~/.vimrc directory
-    --dotfiles-path: path to your dotfiles if different than $HOME.
 EOL
 end
 
@@ -449,9 +515,8 @@ config = {
   :v => :verbose, :s => :submodule, :n => :no_updates,
   :h => :help, :'?' => :help, :V => :version,
 
-  :dotfiles_path => nil,     # Full path to the dot files directory.
-  :vimdir_path   => nil,     # Full path to ~/.vim (creates symlink if not in $HOME).
-  :vimrc_path    => nil,     # Full path to ~/.vimrc (creates symlink if not in $HOME).
+  :vimdir_path   => nil,     # Full path to ~/.vim
+  :vimrc_path    => nil,     # Full path to ~/.vimrc
 
   # Used when spinning up a new Vim environment.
   :starter_url   => "https://github.com/bronson/dotfiles/raw/master/.vimrc",