utils 0.0.67 → 0.0.68

data/lib/utils/config/vim/plugin/lusty-explorer.vim

@@ -1,1509 +0,0 @@
-"    Copyright: Copyright (C) 2007-2010 Stephen Bach
-"               Permission is hereby granted to use and distribute this code,
-"               with or without modifications, provided that this copyright
-"               notice is copied with it. Like anything else that's free,
-"               lusty-explorer.vim is provided *as is* and comes with no
-"               warranty of any kind, either expressed or implied. In no
-"               event will the copyright holder be liable for any damages
-"               resulting from the use of this software.
-"
-" Name Of File: lusty-explorer.vim
-"  Description: Dynamic Filesystem and Buffer Explorer Vim Plugin
-"  Maintainers: Stephen Bach <this-file@sjbach.com>
-"               Matt Tolton <matt-lusty-explorer@tolton.com>
-" Contributors: Raimon Grau, Sergey Popov, Yuichi Tateno, Bernhard Walle,
-"               Rajendra Badapanda, cho45, Simo Salminen, Sami Samhuri,
-"               Matt Tolton, Björn Winckler, sowill
-"
-" Release Date: March 3, 2010
-"      Version: 2.1.3
-"               Inspired by Viewglob, Emacs, and by Jeff Lanzarotta's Buffer
-"               Explorer plugin.
-"
-"        Usage: To launch the explorers:
-"
-"                 <Leader>lf  - Opens the filesystem explorer.
-"                 <Leader>lr  - Opens the filesystem explorer from the parent
-"                               directory of the current file.
-"                 <Leader>lb  - Opens the buffer explorer.
-"
-"               You can also use the commands:
-"
-"                 ":FilesystemExplorer"
-"                 ":FilesystemExplorerFromHere"
-"                 ":BufferExplorer"
-"
-"               (Personally, I map these to ,f and ,r and ,b)
-"
-"               The interface is intuitive.  When one of the explorers is
-"               launched, a new window appears at bottom presenting a list of
-"               files/dirs or buffers, and in the status bar is a prompt:
-"
-"                 >>
-"
-"               As you type, the list updates for possible matches using a
-"               fuzzy matching algorithm.  Special keys include:
-"
-"                 <Enter>  open the selected match
-"                 <Tab>    open the selected match
-"                 <Esc>    cancel
-"                 <C-c>    cancel
-"                 <C-g>    cancel
-"
-"                 <C-t>    open the selected match in a new tab
-"                 <C-n>    select the next match
-"                 <C-p>    select the previous match
-"                 <C-w>    ascend one directory at prompt
-"                 <C-u>    clear the prompt
-"
-"               Additional shortcuts for the filesystem explorer:
-"
-"                 <C-r>    refresh directory contents
-"                 <C-a>    open all files in the current list
-"                 <C-e>    create a new file with the given name
-"
-" Buffer Explorer:
-"  - The currently active buffer is highlighted.
-"  - Buffers are listed without path unless needed to differentiate buffers of
-"    the same name.
-"
-" Filesystem Explorer:
-"  - Directory contents are memoized.
-"  - You can recurse into and out of directories by typing the directory name
-"    and a slash, e.g. "stuff/" or "../".
-"  - Variable expansion, e.g. "$D" -> "/long/dir/path/".
-"  - Tilde (~) expansion, e.g. "~/" -> "/home/steve/".
-"  - Dotfiles are hidden by default, but are shown if the current search term
-"    begins with a '.'.  To show these file at all times, set this option:
-"
-"       let g:LustyExplorerAlwaysShowDotFiles = 1
-"
-"  You can prevent certain files from appearing in the directory listings with
-"  the following variable:
-"
-"    set wildignore=*.o,*.fasl,CVS
-"
-"  The above example will mask all object files, compiled lisp files, and
-"  files/directories named CVS from appearing in the filesystem explorer.
-"  Note that they can still be opened by being named explicitly.
-"
-"  See :help 'wildignore' for more information.
-"
-"
-" Install Details:
-"
-" Copy this file into your $HOME/.vim/plugin directory so that it will be
-" sourced on startup automatically.
-"
-" Note! This plugin requires Vim be compiled with Ruby interpretation.  If you
-" don't know if your build of Vim has this functionality, you can check by
-" running "vim --version" from the command line and looking for "+ruby".
-" Alternatively, just try sourcing this script.
-"
-" If your version of Vim does not have "+ruby" but you would still like to
-" use this plugin, you can fix it.  See the "Check for Ruby functionality"
-" comment below for instructions.
-"
-" If you are using the same Vim configuration and plugins for multiple
-" machines, some of which have Ruby and some of which don't, you may want to
-" turn off the "Sorry, LustyExplorer requires ruby" warning.  You can do so
-" like this (in .vimrc):
-"
-"   let g:LustyExplorerSuppressRubyWarning = 1
-"
-" GetLatestVimScripts: 1890 1 :AutoInstall: lusty-explorer.vim
-"
-" TODO:
-" - when an edited file is in nowrap mode and the explorer is called while the
-"   current window is scrolled to the right, name truncation occurs.
-" - bug: NO ENTRIES is not red when input is a space
-"   - happens because LustyExpMatch declares after LustyExpNoEntries.
-" - if new_hash == previous_hash, don't bother 'repainting'.
-
-" Exit quickly when already loaded.
-if exists("g:loaded_lustyexplorer")
-  finish
-endif
-
-if exists("g:FuzzyFinderMode.TextMate")
-  echohl WarningMsg
-  echo "Warning: LustyExplorer detects the presence of fuzzyfinder_textmate;"
-  echo "that plugin sometimes interacts poorly with other Ruby plugins."
-  echohl none
-endif
-
-" Check for Ruby functionality.
-if !has("ruby") || version < 700
-  if !exists("g:LustyExplorerSuppressRubyWarning") ||
-     \ g:LustyExplorerSuppressRubyWarning == "0"
-  if !exists("g:LustyJugglerSuppressRubyWarning") ||
-      \ g:LustyJugglerSuppressRubyWarning == "0"
-    echohl ErrorMsg
-    echon "Sorry, LustyExplorer requires ruby.  "
-    echon "Here are some tips for adding it:\n"
-
-    echo "Debian / Ubuntu:"
-    echo "    # apt-get install vim-ruby\n"
-
-    echo "Fedora:"
-    echo "    # yum install vim-enhanced\n"
-
-    echo "Gentoo:"
-    echo "    # USE=\"ruby\" emerge vim\n"
-
-    echo "FreeBSD:"
-    echo "    # pkg_add -r vim+ruby\n"
-
-    echo "Windows:"
-    echo "    1. Download and install Ruby from here:"
-    echo "       http://www.ruby-lang.org/"
-    echo "    2. Install a Vim binary with Ruby support:"
-    echo "       http://segfault.hasno.info/vim/gvim72.zip\n"
-
-    echo "Manually (including Cygwin):"
-    echo "    1. Install Ruby."
-    echo "    2. Download the Vim source package (say, vim-7.0.tar.bz2)"
-    echo "    3. Build and install:"
-    echo "         # tar -xvjf vim-7.0.tar.bz2"
-    echo "         # ./configure --enable-rubyinterp"
-    echo "         # make && make install"
-
-    echo "(If you just wish to stifle this message, set the following option:"
-    echo "  let g:LustyJugglerSuppressRubyWarning = 1)"
-    echohl none
-  endif
-  endif
-  finish
-endif
-
-let g:loaded_lustyexplorer = "yep"
-
-" Commands.
-command BufferExplorer :call <SID>BufferExplorerStart()
-command FilesystemExplorer :call <SID>FilesystemExplorerStart()
-command FilesystemExplorerFromHere :call <SID>FilesystemExplorerStartFromHere()
-
-" Default mappings.
-nmap <silent> <Leader>lf :FilesystemExplorer<CR>
-nmap <silent> <Leader>lr :FilesystemExplorerFromHere<CR>
-nmap <silent> <Leader>lb :BufferExplorer<CR>
-
-" Old mappings (from DynamicExplorer).
-nmap <silent> <Leader>df :FilesystemExplorer<CR>
-nmap <silent> <Leader>db :BufferExplorer<CR>
-
-" Vim-to-ruby function calls.
-function! s:FilesystemExplorerStart()
-  ruby $filesystem_explorer.run_from_wd
-endfunction
-
-function! s:FilesystemExplorerStartFromHere()
-  ruby $filesystem_explorer.run_from_here
-endfunction
-
-function! s:BufferExplorerStart()
-  ruby $buffer_explorer.run
-endfunction
-
-function! FilesystemExplorerCancel()
-  ruby $filesystem_explorer.cancel
-endfunction
-
-function! BufferExplorerCancel()
-  ruby $buffer_explorer.cancel
-endfunction
-
-function! FilesystemExplorerKeyPressed(code_arg)
-  ruby $filesystem_explorer.key_pressed
-endfunction
-
-function! BufferExplorerKeyPressed(code_arg)
-  ruby $buffer_explorer.key_pressed
-endfunction
-
-" Setup the autocommands that handle buffer MRU ordering.
-"augroup LustyExplorer
-"  autocmd!
-"  autocmd BufEnter * ruby Window.buffer_stack.push
-"  autocmd BufDelete * ruby Window.buffer_stack.pop
-"  autocmd BufWipeout * ruby Window.buffer_stack.pop
-"augroup End
-
-ruby << EOF
-require 'pathname'
-# Needed for String#each_char in Ruby 1.8 on some platforms
-require 'jcode' unless "".respond_to? :each_char
-
-$PROFILING = false
-
-if $PROFILING
-  require 'rubygems'
-  require 'ruby-prof'
-end
-
-class String
-  def ends_with?(s)
-    tail = self[-s.length, s.length]
-    tail == s
-  end
-
-  def starts_with?(s)
-    head = self[0, s.length]
-    head == s
-  end
-end
-
-class IO
-  def ready_for_read?
-    result = IO.select([self], nil, nil, 0)
-    result && (result.first.first == self)
-  end
-end
-
-class File
-  def self.simplify_path(s)
-    begin
-      if s[0] == '~'[0]
-        s = File.expand_path(s.sub(/\/.*/,'')) + \
-            s.sub(/^[^\/]+/,'')
-      end
-
-      if s.ends_with?(File::SEPARATOR)
-        File.expand_path(s) + File::SEPARATOR
-      else
-        File.expand_path(File.dirname(s)) + File::SEPARATOR + File.basename(s)
-      end
-    rescue ArgumentError
-      s
-    end
-  end
-end
-
-module VIM
-  def self.zero?(var)
-    # In Vim 7.2 and older, VIM::evaluate returns Strings for boolean
-    # expressions; in later versions, Fixnums.
-    case var
-    when String
-      var == "0"
-    when Fixnum
-      var == 0
-    else
-      assert(false, "unexpected type: #{var.class}")
-    end
-  end
-
-  def self.nonzero?(var)
-    not(self.zero? var)
-  end
-
-  def self.has_syntax?
-    VIM::nonzero? eva('has("syntax")')
-  end
-
-  def self.columns
-    eva("&columns").to_i
-  end
-
-  def self.lines
-    eva("&lines").to_i
-  end
-
-  def self.getcwd
-    eva("getcwd()")
-  end
-
-  def self.single_quote_escape(s)
-    # Everything in a Vim single quoted string is literal, except single quotes.
-    # Single quotes are escaped by doubling them.
-    s.gsub("'", "''")
-  end
-
-  def self.filename_escape(s)
-    # Escape slashes, open square braces, spaces, sharps, and double quotes.
-    s.gsub(/\\/, '\\\\\\').gsub(/[\[ #"]/, '\\\\\0')
-  end
-
-  def self.regex_escape(s)
-    s.gsub(/[\]\[.~"^$\\*]/,'\\\\\0')
-  end
-
-  class Buffer
-    def modified?
-      VIM::nonzero? eva("getbufvar(#{number()}, '&modified')")
-    end
-  end
-end
-
-def lusty_option_set?(opt_name)
-  opt_name = "g:LustyExplorer" + opt_name
-  VIM::nonzero? eva("exists('#{opt_name}') && #{opt_name} != '0'")
-end
-
-# Port of Ryan McGeary's LiquidMetal fuzzy matching algorithm found at:
-#   http://github.com/rmm5t/liquidmetal/tree/master.
-class LiquidMetal
-  @@SCORE_NO_MATCH = 0.0
-  @@SCORE_MATCH = 1.0
-  @@SCORE_TRAILING = 0.8
-  @@SCORE_TRAILING_BUT_STARTED = 0.90
-  @@SCORE_BUFFER = 0.85
-
-  def self.score(string, abbrev)
-
-    return @@SCORE_TRAILING if abbrev.empty?
-    return @@SCORE_NO_MATCH if abbrev.length > string.length
-
-    scores = buildScoreArray(string, abbrev)
-
-    sum = scores.inject { |a, b| a + b }
-
-    return sum / scores.length;
-  end
-
-  def self.buildScoreArray(string, abbrev)
-    scores = Array.new(string.length)
-    lower = string.downcase()
-
-    lastIndex = -1
-    started = false
-
-    abbrev.downcase().each_char do |c|
-      index = lower.index(c, lastIndex + 1)
-      return scores.fill(@@SCORE_NO_MATCH, 0..-1) if index.nil?
-      started = true if index == 0
-
-      if index > 0 and " \t/._-".include?(string[index - 1])
-        scores[index - 1] = @@SCORE_MATCH
-        scores.fill(@@SCORE_BUFFER, (lastIndex + 1)...(index - 1))
-      elsif string[index] >= "A"[0] and string[index] <= "Z"[0]
-        scores.fill(@@SCORE_BUFFER, (lastIndex + 1)...index)
-      else
-        scores.fill(@@SCORE_NO_MATCH, (lastIndex + 1)...index)
-      end
-
-      scores[index] = @@SCORE_MATCH
-      lastIndex = index
-    end
-
-    trailing_score = started ? @@SCORE_TRAILING_BUT_STARTED : @@SCORE_TRAILING
-    scores.fill(trailing_score, lastIndex + 1)
-    return scores
-  end
-end
-
-# Used in FilesystemExplorer
-class Entry
-  attr_accessor :name, :current_score
-  def initialize(name)
-    @name = name
-    @current_score = 0.0
-  end
-end
-
-# Used in BufferExplorer
-class BufferEntry < Entry
-  attr_accessor :full_name, :vim_buffer
-  def initialize(vim_buffer)
-    @full_name = vim_buffer.name
-    @vim_buffer = vim_buffer
-    @name = "::UNSET::"
-    @current_score = 0.0
-  end
-end
-
-class LustyExplorer
-  public
-    def initialize
-      @settings = SavedSettings.new
-      @displayer = Displayer.new title()
-      @prompt = nil
-      @ordered_matching_entries = []
-      @running = false
-    end
-
-    def run
-      return if @running
-
-      if $PROFILING
-        RubyProf.measure_mode = RubyProf::WALL_TIME
-      end
-
-      @settings.save
-      @running = true
-      @calling_window = $curwin
-      @saved_alternate_bufnum = if VIM::nonzero? eva("expand('#') == ''")
-                                  nil
-                                else
-                                  eva("bufnr(expand('#'))")
-                                end
-      @selected_index = 0
-      create_explorer_window()
-      refresh(:full)
-    end
-
-    def key_pressed()
-      # Grab argument from the Vim function.
-      i = eva("a:code_arg").to_i
-      refresh_mode = :full
-
-      case i
-        when 32..126          # Printable characters
-          c = i.chr
-          @prompt.add! c
-          @selected_index = 0
-        when 8                # Backspace/Del/C-h
-          @prompt.backspace!
-          @selected_index = 0
-        when 9, 13            # Tab and Enter
-          choose(:current_tab)
-          @selected_index = 0
-        when 23               # C-w (delete 1 dir backward)
-          @prompt.up_one_dir!
-          @selected_index = 0
-        when 14               # C-n (select next)
-          @selected_index = \
-            (@selected_index + 1) % @ordered_matching_entries.size
-          refresh_mode = :no_recompute
-        when 16               # C-p (select previous)
-          @selected_index = \
-            (@selected_index - 1) % @ordered_matching_entries.size
-          refresh_mode = :no_recompute
-        when 20               # C-t choose in new tab
-          choose(:new_tab)
-          @selected_index = 0
-        when 21               # C-u clear prompt
-          @prompt.clear!
-          @selected_index = 0
-      end
-
-      refresh(refresh_mode)
-    end
-
-    def cancel
-      if @running
-        cleanup()
-        # fix alternate file
-        if @saved_alternate_bufnum
-          cur = $curbuf
-          exe "silent b #{@saved_alternate_bufnum}"
-          exe "silent b #{cur.number}"
-        end
-
-        if $PROFILING
-          #outfile = File.new('rbprof.txt', 'a')
-          #RubyProf::CallTreePrinter.new(RubyProf.stop).print(outfile)
-          outfile = File.new('rbprof.html', 'a')
-          RubyProf::GraphHtmlPrinter.new(RubyProf.stop).print(outfile)
-        end
-      end
-    end
-
-  private
-    def refresh(mode)
-      return if not @running
-
-      if mode == :full
-        @ordered_matching_entries = compute_ordered_matching_entries()
-      end
-
-      on_refresh()
-      highlight_selected_index()
-      @displayer.print @ordered_matching_entries.map { |x| x.name }
-      @prompt.print
-    end
-
-    def create_explorer_window
-
-      @displayer.create
-
-      # Setup key mappings to reroute user input.
-
-      # Non-special printable characters.
-      printables =  '/!"#$%&\'()*+,-.0123456789:<=>?#@"' \
-                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
-                    '[]^_`abcdefghijklmnopqrstuvwxyz{}~'
-
-      map_command = "noremap <silent> <buffer> "
-
-      printables.each_byte do |b|
-        exe "#{map_command} <Char-#{b}> :call #{self.class}KeyPressed(#{b})<CR>"
-      end
-
-      # Special characters
-      exe "#{map_command} <Tab>    :call #{self.class}KeyPressed(9)<CR>"
-      exe "#{map_command} <Bslash> :call #{self.class}KeyPressed(92)<CR>"
-      exe "#{map_command} <Space>  :call #{self.class}KeyPressed(32)<CR>"
-      exe "#{map_command} \026|    :call #{self.class}KeyPressed(124)<CR>"
-
-      exe "#{map_command} <BS>     :call #{self.class}KeyPressed(8)<CR>"
-      exe "#{map_command} <Del>    :call #{self.class}KeyPressed(8)<CR>"
-      exe "#{map_command} <C-h>    :call #{self.class}KeyPressed(8)<CR>"
-
-      exe "#{map_command} <CR>     :call #{self.class}KeyPressed(13)<CR>"
-      exe "#{map_command} <S-CR>   :call #{self.class}KeyPressed(10)<CR>"
-      exe "#{map_command} <C-a>    :call #{self.class}KeyPressed(1)<CR>"
-
-      exe "#{map_command} <Esc>    :call #{self.class}Cancel()<CR>"
-      exe "#{map_command} <C-c>    :call #{self.class}Cancel()<CR>"
-      exe "#{map_command} <C-g>    :call #{self.class}Cancel()<CR>"
-
-      exe "#{map_command} <C-w>    :call #{self.class}KeyPressed(23)<CR>"
-      exe "#{map_command} <C-n>    :call #{self.class}KeyPressed(14)<CR>"
-      exe "#{map_command} <C-p>    :call #{self.class}KeyPressed(16)<CR>"
-      exe "#{map_command} <C-t>    :call #{self.class}KeyPressed(20)<CR>"
-      exe "#{map_command} <C-e>    :call #{self.class}KeyPressed(5)<CR>"
-      exe "#{map_command} <C-r>    :call #{self.class}KeyPressed(18)<CR>"
-      exe "#{map_command} <C-u>    :call #{self.class}KeyPressed(21)<CR>"
-    end
-
-    def highlight_selected_index
-      return unless VIM::has_syntax?
-
-      entry = @ordered_matching_entries[@selected_index]
-      return if entry.nil?
-
-      exe "syn clear LustyExpSelected"
-      exe "syn match LustyExpSelected " \
-	  "\"#{Displayer.vim_match_string(entry.name, false)}\" "
-    end
-
-    def compute_ordered_matching_entries
-      abbrev = current_abbreviation()
-      unordered = matching_entries()
-
-      # Sort alphabetically if there's just a dot or we have no abbreviation,
-      # otherwise it just looks weird.
-      if abbrev.length == 0 or abbrev == '.'
-        unordered.sort! { |x, y| x.name <=> y.name }
-      else
-        # Sort by score.
-        unordered.sort! { |x, y| y.current_score <=> x.current_score }
-      end
-    end
-
-    def matching_entries
-      all_entries().select { |x|
-        x.current_score = LiquidMetal.score(x.name, current_abbreviation())
-        x.current_score != 0.0
-      }
-    end
-
-    def choose(open_mode)
-      entry = @ordered_matching_entries[@selected_index]
-      return if entry.nil?
-      @selected_index = 0
-      open_entry(entry, open_mode)
-    end
-
-    def cleanup
-      @displayer.close
-      Window.select @calling_window
-      @settings.restore
-      @running = false
-      msg ""
-      assert(@calling_window == $curwin)
-    end
-end
-
-
-class BufferExplorer < LustyExplorer
-  public
-    def initialize
-      super
-      @prompt = Prompt.new
-      @buffer_entries = []
-    end
-
-    def run
-      unless @running
-        @prompt.clear!
-        @curbuf_at_start = VIM::Buffer.current
-        fill_buffer_entries()
-        super
-      end
-    end
-
-  private
-    def title
-      '[LustyExplorer-Buffers]'
-    end
-
-    def curbuf_match_string
-      curbuf = @buffer_entries.find { |x| x.vim_buffer == @curbuf_at_start }
-      if curbuf
-        Displayer.vim_match_string(curbuf.name, @prompt.insensitive?)
-      else
-        ""
-      end
-    end
-
-    def on_refresh
-      # Highlighting for the current buffer name.
-      if VIM::has_syntax?
-        exe 'syn clear LustyExpCurrentBuffer'
-        exe "syn match LustyExpCurrentBuffer \"#{curbuf_match_string()}\" " \
-            'contains=LustyExpModified'
-      end
-    end
-
-    def common_prefix(entries)
-      prefix = entries[0].full_name
-      entries.each do |entry|
-        full_name = entry.full_name
-        for i in 0...prefix.length
-          if full_name.length <= i or prefix[i] != full_name[i]
-            prefix = prefix[0...i]
-            prefix = prefix[0..(prefix.rindex('/') or -1)]
-            break
-          end
-        end
-      end
-      return prefix
-    end
-
-    def fill_buffer_entries
-      @buffer_entries.clear
-      (0..VIM::Buffer.count-1).each do |i|
-        @buffer_entries << BufferEntry.new(VIM::Buffer[i])
-      end
-
-      # Shorten each buffer name by removing all path elements which are not
-      # needed to differentiate a given name from other names.  This usually
-      # results in only the basename shown, but if several buffers of the
-      # same basename are opened, there will be more.
-
-      # Group the buffers by common basename
-      common_base = Hash.new { |hash, k| hash[k] = [] }
-      @buffer_entries.each do |entry|
-        if entry.full_name
-          basename = Pathname.new(entry.full_name).basename.to_s
-          common_base[basename] << entry
-        end
-      end
-
-      # Determine the longest common prefix for each basename group.
-      basename_to_prefix = {}
-      common_base.each do |base, entries|
-        if entries.length > 1
-          basename_to_prefix[base] = common_prefix(entries)
-        end
-      end
-
-      # Compute shortened buffer names by removing prefix, if possible.
-      @buffer_entries.each do |entry|
-        full_name = entry.full_name
-
-        short_name = if full_name.nil?
-                       '[No Name]'
-                     elsif full_name.starts_with?("scp://")
-                       full_name
-                     else
-                       base = Pathname.new(full_name).basename.to_s
-                       prefix = basename_to_prefix[base]
-
-                       prefix ? full_name[prefix.length..-1] \
-                              : base
-                     end
-
-        # Disabled: show buffer number next to name
-        #short_name += ' ' + buffer.number.to_s
-
-        # Show modification indicator
-        short_name += entry.vim_buffer.modified? ? " [+]" : ""
-
-        entry.name = short_name
-      end
-    end
-
-    def current_abbreviation
-      @prompt.input
-    end
-
-    def all_entries
-      @buffer_entries
-    end
-
-    def open_entry(entry, open_mode)
-      cleanup()
-      assert($curwin == @calling_window)
-
-      number = entry.vim_buffer.number
-      assert(number)
-
-      cmd = case open_mode
-            when :current_tab
-              "b"
-            when :new_tab
-              # For some reason just using tabe or e gives an error when
-              # the alternate-file isn't set.
-              "tab split | b"
-            else
-              assert(false, "bad open mode")
-            end
-
-      exe "silent #{cmd} #{number}"
-    end
-end
-
-def time
-  if $PROFILING
-    RubyProf.resume
-  end
-  begin
-    yield
-  rescue Exception => e
-    puts e
-    puts e.backtrace
-  end
-  if $PROFILING
-    RubyProf.pause
-  end
-end
-
-class FilesystemExplorer < LustyExplorer
-  public
-    def initialize
-      super
-      @prompt = FilesystemPrompt.new
-      @memoized_entries = {}
-    end
-
-    def run
-      FileMasks.create_glob_masks()
-      @vim_swaps = VimSwaps.new
-      super
-    end
-
-    def run_from_here
-      start_path = if $curbuf.name.nil?
-                     VIM::getcwd()
-                   else
-                     eva("expand('%:p:h')")
-                   end
-
-      @prompt.set!(start_path + File::SEPARATOR)
-      run()
-    end
-
-    def run_from_wd
-      @prompt.set!(VIM::getcwd() + File::SEPARATOR)
-      run()
-    end
-
-    def key_pressed()
-      time do
-      i = eva("a:code_arg").to_i
-
-      case i
-      when 1, 10  # <C-a>, <Shift-Enter>
-        cleanup()
-        # Open all non-directories currently in view.
-        @ordered_matching_entries.each do |e|
-          path_str = \
-            if @prompt.at_dir?
-              @prompt.input + e.name
-            else
-              @prompt.dirname + File::SEPARATOR + e.name
-            end
-
-          load_file(path_str, :current_tab) unless File.directory?(path_str)
-        end
-      when 5      # <C-e> edit file, create it if necessary
-        if not @prompt.at_dir?
-          cleanup()
-          # Force a reread of this directory so that the new file will
-          # show up (as long as it is saved before the next run).
-          @memoized_entries.delete(view_path())
-          load_file(@prompt.input, :current_tab)
-        end
-      when 18     # <C-r> refresh
-        @memoized_entries.delete(view_path())
-        refresh(:full)
-      else
-        super
-      end
-      end
-    end
-
-  private
-    def title
-    '[LustyExplorer-Files]'
-    end
-
-    def on_refresh
-      if VIM::has_syntax?
-        exe 'syn clear LustyExpFileWithSwap'
-
-        view = view_path()
-        @vim_swaps.file_names.each do |file_with_swap|
-          if file_with_swap.dirname == view
-            base = file_with_swap.basename
-            match_str = Displayer.vim_match_string(base.to_s, false)
-            exe "syn match LustyExpFileWithSwap \"#{match_str}\""
-          end
-        end
-      end
-
-      # TODO: restore highlighting for open buffers?
-    end
-
-    def current_abbreviation
-      if @prompt.at_dir?
-        ""
-      else
-        File.basename(@prompt.input)
-      end
-    end
-
-    def view_path
-      input = @prompt.input
-
-      path = \
-        if @prompt.at_dir? and \
-           input.length > 1         # Not root
-          # The last element in the path is a directory + '/' and we want to
-          # see what's in it instead of what's in its parent directory.
-
-          Pathname.new(input[0..-2])  # Canonicalize by removing trailing '/'
-        else
-          Pathname.new(input).dirname
-        end
-
-      return path
-    end
-
-    def all_entries
-      view = view_path()
-
-      if not view.exist?
-        return []
-      elsif not view.readable?
-        # TODO: show "-- PERMISSION DENIED --"
-        return []
-      end
-
-      unless @memoized_entries.has_key?(view)
-        # Generate an array of the files
-        entries = []
-        view.each_entry do |file|
-          name = file.basename.to_s
-          next if name == "."   # Skip pwd
-          next if name == ".." and lusty_option_set?("AlwaysShowDotFiles")
-
-          # Hide masked files.
-          next if FileMasks.masked?(name)
-
-          if (view + file).directory?
-            # ^^ bug in Pathname.each_entry -- block variable has no dir.
-            name += File::SEPARATOR
-          end
-          entries << Entry.new(name)
-        end
-        @memoized_entries[view] = entries
-      end
-
-      all = @memoized_entries[view]
-
-      if lusty_option_set?("AlwaysShowDotFiles") or \
-         current_abbreviation()[0] == '.'[0]
-        all
-      else
-        # Filter out dotfiles if the current abbreviation doesn't start with
-        # '.'.
-        all.select { |x| x.name[0] != '.'[0] }
-      end
-    end
-
-    def open_entry(entry, open_mode)
-      path = view_path() + entry.name
-
-      if File.directory?(path)
-        # Recurse into the directory instead of opening it.
-        @prompt.set!(path.to_s)
-      elsif entry.name.include?(File::SEPARATOR)
-        # Don't open a fake file/buffer with "/" in its name.
-        return
-      else
-        cleanup()
-        load_file(path.to_s, open_mode)
-      end
-    end
-
-    def load_file(path_str, open_mode)
-      assert($curwin == @calling_window)
-      # Escape for Vim and remove leading ./ for files in pwd.
-      escaped = VIM::filename_escape(path_str).sub(/^\.\//,"")
-      sanitized = eva "fnamemodify('#{escaped}', ':.')"
-      cmd = case open_mode
-            when :current_tab
-              "e"
-            when :new_tab
-              "tabe"
-            else
-              assert(false, "bad open mode")
-            end
-
-      exe "silent #{cmd} #{sanitized}"
-    end
-end
-
-
-class Prompt
-  private
-    @@PROMPT = ">> "
-
-  public
-    def initialize
-      clear!
-    end
-
-    def clear!
-      @input = ""
-    end
-
-    def print
-      pretty_msg("Comment", @@PROMPT, "None", @input, "Underlined", " ")
-    end
-
-    def set!(s)
-      @input = s
-    end
-
-    def input
-      @input
-    end
-
-    def insensitive?
-      @input == @input.downcase
-    end
-
-    def ends_with?(c)
-      @input.ends_with? c
-    end
-
-    def add!(s)
-      @input += s
-    end
-
-    def backspace!
-      @input.chop!
-    end
-
-    def up_one_dir!
-      @input.chop!
-      while !@input.empty? and @input[-1] != '/'[0]
-        @input.chop!
-      end
-    end
-end
-
-class FilesystemPrompt < Prompt
-
-  def initialize
-    super
-    @memoized = nil
-    @dirty = true
-  end
-
-  def clear!
-    @dirty = true
-    super
-  end
-
-  def set!(s)
-    @dirty = true
-    # On Windows, Vim will return paths with a '\' separator, but
-    # we want to use '/'.
-    super(s.gsub('\\', '/'))
-  end
-
-  def backspace!
-    @dirty = true
-    super
-  end
-
-  def up_one_dir!
-    @dirty = true
-    super
-  end
-
-  def at_dir?
-    # We have not typed anything yet or have just typed the final '/' on a
-    # directory name in pwd.  This check is interspersed throughout
-    # FilesystemExplorer because of the conventions of basename and dirname.
-    input().empty? or input().ends_with?(File::SEPARATOR)
-    # Don't think the File.directory? call is necessary, but leaving this
-    # here as a reminder.
-    #(File.directory?(input()) and input().ends_with?(File::SEPARATOR))
-  end
-
-  def insensitive?
-    at_dir? or (basename() == basename().downcase)
-  end
-
-  def add!(s)
-    # Assumption: add!() will only receive enough chars at a time to complete
-    # a single directory level, e.g. foo/, not foo/bar/
-
-    @input += s
-    @dirty = true
-  end
-
-  def input
-    if @dirty
-      @memoized = variable_expansion(File.simplify_path(@input))
-      @dirty = false
-    end
-
-    @memoized
-  end
-
-  def basename
-    File.basename input()
-  end
-
-  def dirname
-    File.dirname input()
-  end
-
-  private
-    def variable_expansion (input_str)
-      # FIXME does this still work?
-      strings = input_str.split('$', -1)
-      return "" if strings.nil? or strings.length == 0
-
-      first = strings.shift
-
-      # Try to expand each instance of $<word>.
-      strings.inject(first) { |str, s|
-        if s =~ /^(\w+)/ and ENV[$1]
-          str + s.sub($1, ENV[$1])
-        else
-          str + "$" + s
-        end
-      }
-    end
-end
-
-# Simplify switching between windows.
-class Window
-    def Window.select(window)
-      return true if window == $curwin
-
-      start = $curwin
-
-      # Try to select the given window.
-      begin
-        exe "wincmd w"
-      end while ($curwin != window) and ($curwin != start)
-
-      if $curwin == window
-        return true
-      else
-        # Failed -- re-select the starting window.
-        exe("wincmd w") while $curwin != start
-        pretty_msg("ErrorMsg", "Cannot find the correct window!")
-        return false
-      end
-    end
-end
-
-# Save and restore settings when creating the explorer buffer.
-class SavedSettings
-  def initialize
-    save()
-  end
-
-  def save
-    @timeoutlen = eva "&timeoutlen"
-
-    @splitbelow = VIM::nonzero? eva("&splitbelow")
-    @insertmode = VIM::nonzero? eva("&insertmode")
-    @showcmd = VIM::nonzero? eva("&showcmd")
-    @list = VIM::nonzero? eva("&list")
-
-    @report = eva "&report"
-    @sidescroll = eva "&sidescroll"
-    @sidescrolloff = eva "&sidescrolloff"
-  end
-
-  def restore
-    set "timeoutlen=#{@timeoutlen}"
-
-    if @splitbelow
-      set "splitbelow"
-    else
-      set "nosplitbelow"
-    end
-
-    if @insertmode
-      set "insertmode"
-    else
-      set "noinsertmode"
-    end
-
-    if @showcmd
-      set "showcmd"
-    else
-      set "noshowcmd"
-    end
-
-    if @list
-      set "list"
-    else
-      set "nolist"
-    end
-
-    exe "set report=#{@report}"
-    exe "set sidescroll=#{@sidescroll}"
-    exe "set sidescrolloff=#{@sidescrolloff}"
-  end
-end
-
-# Manage the explorer buffer.
-class Displayer
-  private
-    @@COLUMN_SEPARATOR = "    "
-    @@NO_ENTRIES_STRING = "-- NO ENTRIES --"
-    @@TRUNCATED_STRING = "-- TRUNCATED --"
-
-  public
-    def Displayer.vim_match_string(s, case_insensitive)
-      # Create a match regex string for the given s.  This is for a Vim regex,
-      # not for a Ruby regex.
-
-      str = '\%(^\|' + @@COLUMN_SEPARATOR + '\)' \
-            '\zs' + VIM::regex_escape(s) + '\%( \[+\]\)\?' + '\ze' \
-            '\%(\s*$\|' + @@COLUMN_SEPARATOR + '\)'
-
-      str += '\c' if case_insensitive
-
-      return str
-    end
-
-    def initialize(title)
-      @title = title
-      @window = nil
-      @buffer = nil
-    end
-
-    def create
-      # Make a window for the displayer and move there.
-      exe "silent! botright split #{@title}"
-
-      @window = $curwin
-      @buffer = $curbuf
-
-      # Displayer buffer is special.
-      exe "setlocal bufhidden=delete"
-      exe "setlocal buftype=nofile"
-      exe "setlocal nomodifiable"
-      exe "setlocal noswapfile"
-      exe "setlocal nowrap"
-      exe "setlocal nonumber"
-      exe "setlocal foldcolumn=0"
-      exe "setlocal nocursorline"
-      exe "setlocal nospell"
-      exe "setlocal nobuflisted"
-      exe "setlocal textwidth=0"
-
-      # (Update SavedSettings if adding to below.)
-      set "timeoutlen=0"
-      set "noinsertmode"
-      set "noshowcmd"
-      set "nolist"
-      set "report=9999"
-      set "sidescroll=0"
-      set "sidescrolloff=0"
-
-      # TODO -- cpoptions?
-
-      if VIM::has_syntax?
-        exe 'syn match LustyExpSlash "/" contained'
-        exe 'syn match LustyExpDir "\zs\%(\S\+ \)*\S\+/\ze" ' \
-                                   'contains=LustyExpSlash'
-
-        exe 'syn match LustyExpModified " \[+\]"'
-
-        exe 'syn match LustyExpNoEntries "\%^\s*' \
-                                         "#{@@NO_ENTRIES_STRING}" \
-                                         '\s*\%$"'
-
-        exe 'syn match LustyExpTruncated "^\s*' \
-                                         "#{@@TRUNCATED_STRING}" \
-                                         '\s*$"'
-
-        exe 'highlight link LustyExpDir Directory'
-        exe 'highlight link LustyExpSlash Function'
-        exe 'highlight link LustyExpSelected Type'
-        exe 'highlight link LustyExpModified Special'
-        exe 'highlight link LustyExpCurrentBuffer Constant'
-        exe 'highlight link LustyExpOpenedFile PreProc'
-        exe 'highlight link LustyExpFileWithSwap WarningMsg'
-        exe 'highlight link LustyExpNoEntries ErrorMsg'
-        exe 'highlight link LustyExpTruncated Visual'
-      end
-    end
-
-    def print(strings)
-      Window.select(@window) || return
-
-      if strings.empty?
-        print_no_entries()
-        return
-      end
-
-      # Perhaps truncate the results to just over the upper bound of
-      # displayable strings.  This isn't exact, but it's close enough.
-      max = VIM::lines * (VIM::columns / (1 + @@COLUMN_SEPARATOR.length))
-      if strings.length > max
-        strings.slice!(max, strings.length - max)
-      end
-
-      # Get a high upper bound on the number of columns to display to optimize
-      # the following algorithm a little.
-      col_count = column_count_upper_bound(strings)
-
-      # Figure out the actual number of columns to use (yuck)
-      cols = nil
-      widths = nil
-      while col_count > 1 do
-
-        cols = columnize(strings, col_count);
-
-        widths = cols.map { |col|
-          col.max { |a, b| a.length <=> b.length }.length
-        }
-
-        full_width = widths.inject { |sum, n| sum + n }
-        full_width += @@COLUMN_SEPARATOR.length * (col_count - 1)
-
-        if full_width <= $curwin.width
-          break
-        end
-
-        col_count -= 1
-      end
-
-      if col_count <= 1
-        cols = [strings]
-        widths = [0]
-      end
-
-      print_columns(cols, widths)
-    end
-
-    def close
-      # Only wipe the buffer if we're *sure* it's the explorer.
-      if Window.select @window and \
-         $curbuf == @buffer and \
-         $curbuf.name =~ /#{Regexp.escape(@title)}$/
-          exe "bwipeout!"
-          @window = nil
-          @buffer = nil
-      end
-    end
-
-  private
-    def print_columns(cols, widths)
-      unlock_and_clear()
-
-      # Set the height to the height of the longest column.
-      $curwin.height = cols.max { |a, b| a.length <=> b.length }.length
-
-      (0..$curwin.height-1).each do |i|
-
-        string = ""
-        (0..cols.length-1).each do |j|
-          break if cols[j][i].nil?
-          string += cols[j][i]
-          string += " " * [(widths[j] - cols[j][i].length), 0].max
-          string += @@COLUMN_SEPARATOR
-        end
-
-        # Stretch the line to the length of the window with whitespace so that
-        # we can "hide" the cursor in the corner.
-        string += " " * [($curwin.width - string.length), 0].max
-
-        $curwin.cursor = [i+1, 1]
-        $curbuf.append(i, string)
-      end
-
-      # Check for result truncation.
-      if cols[0][$curwin.height]
-        # Show a truncation indicator.
-        $curbuf.delete($curbuf.count - 1)
-        $curwin.cursor = [$curbuf.count, 1]
-        $curbuf.append($curbuf.count - 1, \
-                       @@TRUNCATED_STRING.center($curwin.width, " "))
-      end
-
-      # There's a blank line at the end of the buffer because of how
-      # VIM::Buffer.append works.
-      $curbuf.delete $curbuf.count
-      lock()
-    end
-
-    def print_no_entries
-      unlock_and_clear()
-      $curwin.height = 1
-
-      $curbuf[1] = @@NO_ENTRIES_STRING.center($curwin.width, " ")
-      lock()
-    end
-
-    def unlock_and_clear
-      exe "setlocal modifiable"
-
-      # Clear the explorer (black hole register)
-      exe "silent %d _"
-    end
-
-    def lock
-      exe "setlocal nomodifiable"
-
-      # Hide the cursor
-      exe "normal! Gg$"
-    end
-
-    # Get a starting upper bound on the number of columns
-    def column_count_upper_bound(strings)
-      column_count = 0
-      length = 0
-
-      sorted_by_length = strings.sort {|x, y| x.length <=> y.length }
-
-      sorted_by_length.each do |e|
-        length += e.length
-        break unless length < $curwin.width
-
-        column_count += 1
-        length += @@COLUMN_SEPARATOR.length
-      end
-
-      return column_count
-    end
-
-    def columnize(strings, n_cols)
-      n_rows = (strings.length.to_f / n_cols).ceil
-
-      # Break the array into sub arrays representing columns
-      cols = []
-      0.step(strings.size-1, n_rows) do |i|
-        cols << strings[i..(i + n_rows - 1)]
-      end
-      return cols
-    end
-end
-
-
-class FileMasks
-  private
-    @@glob_masks = []
-
-  public
-    def FileMasks.create_glob_masks
-      @@glob_masks = \
-        if VIM::nonzero? eva('exists("g:LustyExplorerFileMasks")')
-          # Note: this variable deprecated.
-          eva("g:LustyExplorerFileMasks").split(',')
-        elsif VIM::nonzero? eva('exists("&wildignore")')
-          eva("&wildignore").split(',')
-        else
-          []
-        end
-    end
-
-    def FileMasks.masked?(str)
-      @@glob_masks.each do |mask|
-        return true if File.fnmatch(mask, str)
-      end
-
-      return false
-    end
-end
-
-class VimSwaps
-  def initialize
-    if VIM::has_syntax?
-# FIXME: vvv disabled
-#      @vim_r = IO.popen("vim -r 2>&1")
-#      @files_with_swaps = nil
-      @files_with_swaps = []
-    else
-      @files_with_swaps = []
-    end
-  end
-
-  def file_names
-    if @files_with_swaps.nil?
-      if @vim_r.ready_for_read?
-        @files_with_swaps = []
-        @vim_r.each_line do |line|
-          if line =~ /^ +file name: (.*)$/
-            file = $1.chomp
-            @files_with_swaps << Pathname.new(File.simplify_path(file))
-          end
-        end
-      else
-        return []
-      end
-    end
-
-    @files_with_swaps
-  end
-end
-
-
-def d(s)
-  # (Debug print)
-  $stderr.puts s
-end
-
-# Simple mappings to decrease typing.
-def exe(s)
-  VIM.command s
-end
-
-def eva(s)
-  VIM.evaluate s
-end
-
-def set(s)
-  VIM.set_option s
-end
-
-def msg(s)
-  VIM.message s
-end
-
-def pretty_msg(*rest)
-  return if rest.length == 0
-  return if rest.length % 2 != 0
-
-  exe "redraw"  # see :help echo-redraw
-  i = 0
-  while i < rest.length do
-    exe "echohl #{rest[i]}"
-    exe "echon '#{rest[i+1]}'"
-    i += 2
-  end
-
-  exe 'echohl None'
-end
-
-class AssertionError < StandardError
-end
-
-def assert(condition, message = 'assertion failure')
-  raise AssertionError.new(message) unless condition
-end
-
-
-$buffer_explorer = BufferExplorer.new
-$filesystem_explorer = FilesystemExplorer.new
-
-EOF
-
-" vim: set sts=2 sw=2: