Fix submodules

76 files changed, 0 insertions, 3062 deletions

diff --git a/vim/bundle/vim-gitgutter b/vim/bundle/vim-gitgutter
new file mode 160000
+Subproject b5f23e986747a6f4b1dc1196d2a5bd3dc7c8c2b
diff --git a/vim/bundle/vim-gitgutter/.gitignore b/vim/bundle/vim-gitgutter/.gitignore
deleted file mode 100644
index 82fb253..0000000
--- a/vim/bundle/vim-gitgutter/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-/doc/tags
-/misc
-/test/*.actual
-*.log
-
diff --git a/vim/bundle/vim-gitgutter/README.mkd b/vim/bundle/vim-gitgutter/README.mkd
deleted file mode 100644
index 6fc92ae..0000000
--- a/vim/bundle/vim-gitgutter/README.mkd
+++ /dev/null
@@ -1,499 +0,0 @@
-## vim-gitgutter
-
-A Vim plugin which shows a git diff in the 'gutter' (sign column).  It shows whether each line has been added, modified, and where lines have been removed.  You can also stage and undo individual hunks.
-
-Features:
-
-* Shows signs for added, modified, and removed lines.
-* Runs the diffs asynchronously in terminal Vim/MacVim (7.4.1826+), gVim (7.4.1850+), MacVim GUI (7.4.1832+), and NeoVim.
-* Ensures signs are always as up to date as possible (but without running more than necessary).
-* Quick jumping between blocks of changed lines ("hunks").
-* Stage/undo/preview individual hunks.
-* Provides a hunk text object.
-* Diffs against index (default) or any commit.
-* Handles line endings correctly, even with repos that do CRLF conversion.
-* Optional line highlighting.
-* Fully customisable (signs, sign column, line highlights, mappings, extra git-diff arguments, etc).
-* Can be toggled on/off.
-* Preserves signs from other plugins.
-* Easy to integrate diff stats into status line; built-in integration with [vim-airline](https://github.com/bling/vim-airline/).
-* Works with fish shell (in addition to the usual shells).
-
-Constraints:
-
-* Supports git only.
-
-If you work with other version control systems, I recommend [vim-signify](https://github.com/mhinz/vim-signify).
-
-
-### Screenshot
-
-![screenshot](https://raw.github.com/airblade/vim-gitgutter/master/screenshot.png)
-
-In the screenshot above you can see:
-
-* Line 15 has been modified.
-* Lines 21-24 are new.
-* A line or lines were removed between lines 25 and 26.
-
-
-### Installation
-
-Before installation, please check your Vim supports signs by running `:echo has('signs')`.  `1` means you're all set; `0` means you need to install a Vim with signs support.  If you're compiling Vim yourself you need the 'big' or 'huge' feature set.  [MacVim][] supports signs.
-
-You install vim-gitgutter like any other vim plugin.
-
-##### Pathogen
-
-```
-cd ~/.vim/bundle
-git clone git://github.com/airblade/vim-gitgutter.git
-```
-
-##### Voom
-
-Edit your plugin manifest (`voom edit`) and add:
-
-```
-airblade/vim-gitgutter
-```
-
-##### VimPlug
-
-Place this in your .vimrc:
-
-```viml
-Plug 'airblade/vim-gitgutter'
-```
-
-Then run the following in Vim:
-
-```
-:source %
-:PlugInstall
-```
-
-##### NeoBundle
-
-Place this in your .vimrc:
-
-```viml
-NeoBundle 'airblade/vim-gitgutter'
-```
-
-Then run the following in Vim:
-
-```
-:source %
-:NeoBundleInstall
-```
-
-##### No plugin manager
-
-Copy vim-gitgutter's subdirectories into your vim configuration directory:
-
-```
-cd /tmp && git clone git://github.com/airblade/vim-gitgutter.git
-cp -r vim-gitgutter/* ~/.vim/
-```
-
-See `:help add-global-plugin`.
-
-
-If you are on Windows you may find the command prompt pops up briefly every time vim-gitgutter runs.  You can avoid this by installing both [vim-misc](https://github.com/xolox/vim-misc) and [vim-shell](https://github.com/xolox/vim-shell).  If you have those two plugins but don't want vim-gitgutter to use them, you can opt out with `let g:gitgutter_avoid_cmd_prompt_on_windows = 0` in your `~/.vimrc`.
-
-
-### Getting started
-
-When you make a change to a file tracked by git, the diff markers should appear automatically.  The delay is governed by vim's `updatetime` option; the default value is 4 seconds but I suggest reducing it to around 250ms (add `set updatetime=250` to your vimrc).
-
-You can jump between hunks with `[c` and `]c`.  You can preview, stage, and undo hunks with `<leader>hp`, `<leader>hs`, and `<leader>hu` respectively.
-
-You cannot currently unstage a staged hunk.
-
-
-#### Activation
-
-You can explicitly turn vim-gitgutter off and on (defaults to on):
-
-* turn off with `:GitGutterDisable`
-* turn on with `:GitGutterEnable`
-* toggle with `:GitGutterToggle`.
-
-You can turn the signs on and off (defaults to on):
-
-* turn on with `:GitGutterSignsEnable`
-* turn off with `:GitGutterSignsDisable`
-* toggle with `:GitGutterSignsToggle`.
-
-And you can turn line highlighting on and off (defaults to off):
-
-* turn on with `:GitGutterLineHighlightsEnable`
-* turn off with `:GitGutterLineHighlightsDisable`
-* toggle with `:GitGutterLineHighlightsToggle`.
-
-Note that if you have line highlighting on and signs off, you will have an empty sign column – more accurately, a sign column with invisible signs.  This is because line highlighting requires signs and Vim always shows the sign column even if the signs are invisible.
-
-If you switch off both line highlighting and signs, you won't see the sign column.  That is unless you have set `let g:gitgutter_sign_column_always = 1` so it's always there.
-
-To keep your Vim snappy, vim-gitgutter will suppress itself when a file has more than 500 changes.  As soon as the number of changes falls below the limit vim-gitgutter will show the signs again.  You can configure the threshold with:
-
-```viml
-let g:gitgutter_max_signs = 500  " default value
-```
-
-#### Hunks
-
-You can jump between hunks:
-
-* jump to next hunk (change): `]c`
-* jump to previous hunk (change): `[c`.
-
-Both of those take a preceding count.
-
-To set your own mappings for these, for example `]h` and `[h`:
-
-```viml
-nmap ]h <Plug>GitGutterNextHunk
-nmap [h <Plug>GitGutterPrevHunk
-```
-
-You can stage or undo an individual hunk when your cursor is in it:
-
-* stage the hunk with `<Leader>hs` or
-* undo it with `<Leader>hu`.
-
-See the FAQ if you want to unstage staged changes.
-
-The `.` command will work with both these if you install [repeat.vim](https://github.com/tpope/vim-repeat).
-
-To set your own mappings for these, for example if you prefer the mnemonics hunk-add and hunk-revert:
-
-```viml
-nmap <Leader>ha <Plug>GitGutterStageHunk
-nmap <Leader>hr <Plug>GitGutterUndoHunk
-```
-
-And you can preview a hunk's changes with `<Leader>hp`.  You can of course change this mapping, e.g:
-
-```viml
-nmap <Leader>hv <Plug>GitGutterPreviewHunk
-```
-
-A hunk text object is provided which works in visual and operator-pending modes.
-
-- `ic` operates on all lines in the current hunk.
-- `ac` operates on all lines in the current hunk and any trailing empty lines.
-
-To re-map these, for example to `ih` and `ah`:
-
-```viml
-omap ih <Plug>GitGutterTextObjectInnerPending
-omap ah <Plug>GitGutterTextObjectOuterPending
-xmap ih <Plug>GitGutterTextObjectInnerVisual
-xmap ah <Plug>GitGutterTextObjectOuterVisual
-```
-
-If you don't want vim-gitgutter to set up any mappings at all, use this:
-
-```viml
-let g:gitgutter_map_keys = 0
-```
-
-Finally, you can force vim-gitgutter to update its signs across all visible buffers with `:GitGutterAll`.
-
-See the customisation section below for how to change the defaults.
-
-
-### When are the signs updated?
-
-By default the signs are updated as follows:
-
-| Event                     | Reason for update                    | Configuration          |
-|---------------------------|--------------------------------------|------------------------|
-| Stop typing               | So the signs are real time           | `g:gitgutter_realtime` |
-| Switch buffer             | To notice change to git index        | `g:gitgutter_eager`    |
-| Switch tab                | To notice change to git index        | `g:gitgutter_eager`    |
-| Focus the GUI             | To notice change to git index        | `g:gitgutter_eager` (not gVim on Windows) |
-| Read a file into a buffer | To display initial signs             | [always]               |
-| Save a buffer             | So non-realtime signs are up to date | [always]               |
-| Change a file outside Vim | To notice `git stash`                | [always]               |
-
-The length of time Vim waits after you stop typing before it triggers the plugin is governed by the setting `updatetime`.  This defaults to `4000` milliseconds which is rather too long.  I recommend around `250` milliseconds but it depends on your system and your preferences.  Note that in terminal Vim pre-7.4.427 an `updatetime` of less than approximately `1000` milliseconds can lead to random highlighting glitches; the lower the `updatetime`, the more glitches.
-
-If you experience a lag, you can trade speed for accuracy:
-
-```viml
-let g:gitgutter_realtime = 0
-let g:gitgutter_eager = 0
-```
-
-Note the realtime updating requires Vim 7.3.105 or higher.
-
-
-### Customisation
-
-You can customise:
-
-* The sign column's colours
-* Whether or not the sign column is shown when there aren't any signs (defaults to no)
-* The signs' colours and symbols
-* Line highlights
-* The base of the diff
-* Extra arguments for `git diff`
-* Key mappings
-* Whether or not vim-gitgutter is on initially (defaults to on)
-* Whether or not signs are shown (defaults to yes)
-* Whether or not line highlighting is on initially (defaults to off)
-* Whether or not vim-gitgutter runs in "realtime" (defaults to yes)
-* Whether or not vim-gitgutter runs eagerly (defaults to yes)
-* Whether or not vim-gitgutter runs asynchronously (defaults to yes)
-
-Please note that vim-gitgutter won't override any colours or highlights you've set in your colorscheme.
-
-
-#### Sign column
-
-By default vim-gitgutter will make the sign column look like the line number column.
-
-To customise your sign column's background color, first tell vim-gitgutter to leave it alone:
-
-```viml
-let g:gitgutter_override_sign_column_highlight = 0
-```
-
-And then either update your colorscheme's `SignColumn` highlight group or set it in your vimrc:
-
-```viml
-highlight SignColumn ctermbg=whatever    " terminal Vim
-highlight SignColumn guibg=whatever      " gVim/MacVim
-```
-
-By default the sign column will appear when there are signs to show and disappear when there aren't.  If you would always like the sign column to be there, add `let g:gitgutter_sign_column_always = 1` to your `~/.vimrc`.
-
-
-#### Signs' colours and symbols
-
-To customise the colours, set up the following highlight groups in your colorscheme or `~/.vimrc`:
-
-```viml
-GitGutterAdd          " an added line
-GitGutterChange       " a changed line
-GitGutterDelete       " at least one removed line
-GitGutterChangeDelete " a changed line followed by at least one removed line
-```
-
-You can either set these with `highlight GitGutterAdd {key}={arg}...` or link them to existing highlight groups with, say, `highlight link GitGutterAdd DiffAdd`.
-
-To customise the symbols, add the following to your `~/.vimrc`:
-
-```viml
-let g:gitgutter_sign_added = 'xx'
-let g:gitgutter_sign_modified = 'yy'
-let g:gitgutter_sign_removed = 'zz'
-let g:gitgutter_sign_removed_first_line = '^^'
-let g:gitgutter_sign_modified_removed = 'ww'
-```
-
-
-#### Line highlights
-
-Similarly to the signs' colours, set up the following highlight groups in your colorscheme or `~/.vimrc`:
-
-```viml
-GitGutterAddLine          " default: links to DiffAdd
-GitGutterChangeLine       " default: links to DiffChange
-GitGutterDeleteLine       " default: links to DiffDelete
-GitGutterChangeDeleteLine " default: links to GitGutterChangeLineDefault, i.e. DiffChange
-```
-
-
-#### The base of the diff
-
-By default buffers are diffed against the index.  However you can diff against any commit by setting:
-
-```viml
-let g:gitgutter_diff_base = '<commit SHA>'
-```
-
-
-#### Extra arguments for `git diff`
-
-If you want to pass extra arguments to `git diff`, for example to ignore whitespace, do so like this:
-
-```viml
-let g:gitgutter_diff_args = '-w'
-```
-
-#### Key mappings
-
-To disable all key mappings:
-
-```viml
-let g:gitgutter_map_keys = 0
-```
-
-See above for configuring maps for hunk-jumping and staging/undoing.
-
-
-#### Use a custom `grep` command
-
-If you use an alternative to grep, or your grep does not support the `color` flag, you can tell vim-gitgutter to use it here. It only needs to support extended POSIX regex.
-
-```viml
-" Default:
-let g:gitgutter_grep_command = 'grep --color=never -e'
-```
-
-#### To turn off vim-gitgutter by default
-
-Add `let g:gitgutter_enabled = 0` to your `~/.vimrc`.
-
-
-#### To turn off signs by default
-
-Add `let g:gitgutter_signs = 0` to your `~/.vimrc`.
-
-
-#### To turn on line highlighting by default
-
-Add `let g:gitgutter_highlight_lines = 1` to your `~/.vimrc`.
-
-
-#### To turn off asynchronous updates
-
-By default diffs are run asynchronously.  To run diffs synchronously instead:
-
-```viml
-let g:gitgutter_async = 0
-```
-
-
-### Extensions
-
-#### Operate on every line in a hunk
-
-You can map an operator to do whatever you want to every line in a hunk.
-
-Let's say, for example, you want to remove trailing whitespace.
-
-```viml
-function! CleanUp(...)
-  if a:0  " opfunc
-    let [first, last] = [line("'["), line("']")]
-  else
-    let [first, last] = [line("'<"), line("'>")]
-  endif
-  for lnum in range(first, last)
-    let line = getline(lnum)
-
-    " clean up the text, e.g.:
-    let line = substitute(line, '\s\+$', '', '')
-
-    call setline(lnum, line)
-  endfor
-endfunction
-
-nmap <silent> <Leader>x :set opfunc=CleanUp<CR>g@
-```
-
-Then place your cursor in a hunk and type `\xic` (assuming a leader of `\`).
-
-Alternatively you could place your cursor in a hunk, type `vic` to select it, then `:call CleanUp()`.
-
-
-#### Operate on every changed line in a file
-
-You can write a command to do whatever you want to every changed line in a file.
-
-```viml
-function! GlobalChangedLines(ex_cmd)
-  for hunk in GitGutterGetHunks()
-    for lnum in range(hunk[2], hunk[2]+hunk[3]-1)
-      let cursor = getcurpos()
-      silent! execute lnum.a:ex_cmd
-      call setpos('.', cursor)
-    endfor
-  endfor
-endfunction
-
-command -nargs=1 Glines call GlobalChangedLines(<q-args>)
-```
-
-Let's say, for example, you want to remove trailing whitespace from all changed lines:
-
-```viml
-:Glines s/\s\+$//
-```
-
-
-### FAQ
-
-> Why can't I unstage staged changes?
-
-Unstaging staged hunks is feasible but not quite as easy as it sounds.  There are three relevant versions of a file at any one time:
-
-1. The version at HEAD in the repo.
-2. The version staged in the index.
-3. The version in the working tree, in your vim buffer.
-
-`git-diff` without arguments shows you how 3 and 2 differ; this is what vim-gitgutter shows too.
-
-`git-diff --staged` shows you how 2 and 1 differ.
-
-Let's say your are looking at a file in vim which has some unstaged changes.  Now you stage a hunk, either via vim-gitgutter or another means.  The hunk is no longer marked in vim-gitgutter because it is the same in 3 and 2.
-
-Now you want to unstage that hunk.  To see it, you need the difference between 2 and 1.  For vim-gitgutter to shows those differences, it would need to show you 2 instead of 3 in your vim buffer.  But 2 is virtual so vim-gitgutter would need to handle it without touching 3.
-
-I intend to implement this but I can't commit to any deadline.
-
-> Why are the colours in the sign column weird?
-
-Your colorscheme is configuring the `SignColumn` highlight group weirdly.  Please see the section above on customising the sign column.
-
-> There's a noticeable lag when vim-gitter runs; how can I avoid it?
-
-By default vim-gitgutter runs often so the signs are as accurate as possible.  The delay is governed by `updatetime`; see [above](#when-are-the-signs-updated) for more information.
-
-If you don't want realtime updates and would like to trade a little accuracy for speed, add this to your `~/.vimrc`:
-
-```viml
-let g:gitgutter_realtime = 0
-let g:gitgutter_eager = 0
-```
-
-> What happens if I also use another plugin which uses signs (e.g. Syntastic)?
-
-Vim only allows one sign per line.  Before adding a sign to a line, vim-gitgutter checks whether a sign has already been added by somebody else.  If so it doesn't do anything.  In other words vim-gitgutter won't overwrite another plugin's signs.  It also won't remove another plugin's signs.
-
-> Why aren't any signs showing at all?
-
-Here are some things you can check:
-
-* `:echo system("git --version")` succeeds.
-* Your git config is compatible with the version of git returned by the command above.
-* Your Vim supports signs (`:echo has('signs')` should give `1`).
-* Your file is being tracked by git and has unstaged changes.
-* If your grep does not support the `color` flag, add `let g:gitgutter_grep_command = 'grep -e'` to your `~/.vimrc`.
-
-
-### Shameless Plug
-
-If this plugin has helped you, or you'd like to learn more about Vim, why not check out this screencast I wrote for PeepCode:
-
-* [Smash Into Vim][siv]
-
-This was one of PeepCode's all-time top three bestsellers and is now available at Pluralsight.
-
-You can read reviews on my [website][airblade].
-
-
-### Intellectual Property
-
-Copyright Andrew Stewart, AirBlade Software Ltd.  Released under the MIT licence.
-
-
-  [pathogen]: https://github.com/tpope/vim-pathogen
-  [siv]: http://pluralsight.com/training/Courses/TableOfContents/smash-into-vim
-  [airblade]: http://airbladesoftware.com/peepcode-vim
-  [macvim]: http://code.google.com/p/macvim/
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter.vim
deleted file mode 100644
index 3b1770a..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter.vim
+++ /dev/null
@@ -1,253 +0,0 @@
-let s:nomodeline = (v:version > 703 || (v:version == 703 && has('patch442'))) ? '<nomodeline>' : ''
-
-" Primary functions {{{
-
-function! gitgutter#all() abort
-  for buffer_id in tabpagebuflist()
-    let file = expand('#' . buffer_id . ':p')
-    if !empty(file)
-      call gitgutter#process_buffer(buffer_id, 0)
-    endif
-  endfor
-endfunction
-
-" bufnr: (integer) the buffer to process.
-" realtime: (boolean) when truthy, do a realtime diff; otherwise do a disk-based diff.
-function! gitgutter#process_buffer(bufnr, realtime) abort
-  call gitgutter#utility#use_known_shell()
-
-  call gitgutter#utility#set_buffer(a:bufnr)
-  if gitgutter#utility#is_active()
-    if g:gitgutter_sign_column_always
-      call gitgutter#sign#add_dummy_sign()
-    endif
-    try
-      if !a:realtime || gitgutter#utility#has_fresh_changes()
-        let diff = gitgutter#diff#run_diff(a:realtime || gitgutter#utility#has_unsaved_changes(), 0)
-        if diff != 'async'
-          call gitgutter#handle_diff(diff)
-        endif
-      endif
-    catch /diff failed/
-      call gitgutter#debug#log('diff failed')
-      call gitgutter#hunk#reset()
-    endtry
-    execute "silent doautocmd" s:nomodeline "User GitGutter"
-  else
-    call gitgutter#hunk#reset()
-  endif
-
-  call gitgutter#utility#restore_shell()
-endfunction
-
-
-function! gitgutter#handle_diff(diff) abort
-  call gitgutter#debug#log(a:diff)
-
-  call setbufvar(gitgutter#utility#bufnr(), 'gitgutter_tracked', 1)
-
-  call gitgutter#hunk#set_hunks(gitgutter#diff#parse_diff(a:diff))
-  let modified_lines = gitgutter#diff#process_hunks(gitgutter#hunk#hunks())
-
-  if len(modified_lines) > g:gitgutter_max_signs
-    call gitgutter#utility#warn_once('exceeded maximum number of signs (configured by g:gitgutter_max_signs).', 'max_signs')
-    call gitgutter#sign#clear_signs()
-    return
-  endif
-
-  if g:gitgutter_signs || g:gitgutter_highlight_lines
-    call gitgutter#sign#update_signs(modified_lines)
-  endif
-
-  call gitgutter#utility#save_last_seen_change()
-endfunction
-
-function! gitgutter#disable() abort
-  " get list of all buffers (across all tabs)
-  let buflist = []
-  for i in range(tabpagenr('$'))
-    call extend(buflist, tabpagebuflist(i + 1))
-  endfor
-
-  for buffer_id in buflist
-    let file = expand('#' . buffer_id . ':p')
-    if !empty(file)
-      call gitgutter#utility#set_buffer(buffer_id)
-      call gitgutter#sign#clear_signs()
-      call gitgutter#sign#remove_dummy_sign(1)
-      call gitgutter#hunk#reset()
-    endif
-  endfor
-
-  let g:gitgutter_enabled = 0
-endfunction
-
-function! gitgutter#enable() abort
-  let g:gitgutter_enabled = 1
-  call gitgutter#all()
-endfunction
-
-function! gitgutter#toggle() abort
-  if g:gitgutter_enabled
-    call gitgutter#disable()
-  else
-    call gitgutter#enable()
-  endif
-endfunction
-
-" }}}
-
-" Line highlights {{{
-
-function! gitgutter#line_highlights_disable() abort
-  let g:gitgutter_highlight_lines = 0
-  call gitgutter#highlight#define_sign_line_highlights()
-
-  if !g:gitgutter_signs
-    call gitgutter#sign#clear_signs()
-    call gitgutter#sign#remove_dummy_sign(0)
-  endif
-
-  redraw!
-endfunction
-
-function! gitgutter#line_highlights_enable() abort
-  let old_highlight_lines = g:gitgutter_highlight_lines
-
-  let g:gitgutter_highlight_lines = 1
-  call gitgutter#highlight#define_sign_line_highlights()
-
-  if !old_highlight_lines && !g:gitgutter_signs
-    call gitgutter#all()
-  endif
-
-  redraw!
-endfunction
-
-function! gitgutter#line_highlights_toggle() abort
-  if g:gitgutter_highlight_lines
-    call gitgutter#line_highlights_disable()
-  else
-    call gitgutter#line_highlights_enable()
-  endif
-endfunction
-
-" }}}
-
-" Signs {{{
-
-function! gitgutter#signs_enable() abort
-  let old_signs = g:gitgutter_signs
-
-  let g:gitgutter_signs = 1
-  call gitgutter#highlight#define_sign_text_highlights()
-
-  if !old_signs && !g:gitgutter_highlight_lines
-    call gitgutter#all()
-  endif
-endfunction
-
-function! gitgutter#signs_disable() abort
-  let g:gitgutter_signs = 0
-  call gitgutter#highlight#define_sign_text_highlights()
-
-  if !g:gitgutter_highlight_lines
-    call gitgutter#sign#clear_signs()
-    call gitgutter#sign#remove_dummy_sign(0)
-  endif
-endfunction
-
-function! gitgutter#signs_toggle() abort
-  if g:gitgutter_signs
-    call gitgutter#signs_disable()
-  else
-    call gitgutter#signs_enable()
-  endif
-endfunction
-
-" }}}
-
-" Hunks {{{
-
-function! gitgutter#stage_hunk() abort
-  call gitgutter#utility#use_known_shell()
-  if gitgutter#utility#is_active()
-    " Ensure the working copy of the file is up to date.
-    " It doesn't make sense to stage a hunk otherwise.
-    noautocmd silent write
-    let diff = gitgutter#diff#run_diff(0, 1)
-    call gitgutter#handle_diff(diff)
-
-    if empty(gitgutter#hunk#current_hunk())
-      call gitgutter#utility#warn('cursor is not in a hunk')
-    else
-      let diff_for_hunk = gitgutter#diff#generate_diff_for_hunk(diff, 'stage')
-      call gitgutter#utility#system(gitgutter#utility#command_in_directory_of_file(g:gitgutter_git_executable.' apply --cached --unidiff-zero - '), diff_for_hunk)
-
-      " refresh gitgutter's view of buffer
-      silent execute "GitGutter"
-    endif
-
-    silent! call repeat#set("\<Plug>GitGutterStageHunk", -1)<CR>
-  endif
-  call gitgutter#utility#restore_shell()
-endfunction
-
-function! gitgutter#undo_hunk() abort
-  call gitgutter#utility#use_known_shell()
-  if gitgutter#utility#is_active()
-    " Ensure the working copy of the file is up to date.
-    " It doesn't make sense to stage a hunk otherwise.
-    noautocmd silent write
-    let diff = gitgutter#diff#run_diff(0, 1)
-    call gitgutter#handle_diff(diff)
-
-    if empty(gitgutter#hunk#current_hunk())
-      call gitgutter#utility#warn('cursor is not in a hunk')
-    else
-      let diff_for_hunk = gitgutter#diff#generate_diff_for_hunk(diff, 'undo')
-      call gitgutter#utility#system(gitgutter#utility#command_in_directory_of_file(g:gitgutter_git_executable.' apply --reverse --unidiff-zero - '), diff_for_hunk)
-
-      " reload file preserving screen line position
-      let wl = winline()
-      silent edit
-      let offset = wl - winline()
-      execute "normal ".offset."\<C-Y>"
-    endif
-
-    silent! call repeat#set("\<Plug>GitGutterUndoHunk", -1)<CR>
-  endif
-  call gitgutter#utility#restore_shell()
-endfunction
-
-function! gitgutter#preview_hunk() abort
-  call gitgutter#utility#use_known_shell()
-  if gitgutter#utility#is_active()
-    " Ensure the working copy of the file is up to date.
-    " It doesn't make sense to stage a hunk otherwise.
-    noautocmd silent write
-    let diff = gitgutter#diff#run_diff(0, 1)
-    call gitgutter#handle_diff(diff)
-
-    if empty(gitgutter#hunk#current_hunk())
-      call gitgutter#utility#warn('cursor is not in a hunk')
-    else
-      let diff_for_hunk = gitgutter#diff#generate_diff_for_hunk(diff, 'preview')
-
-      silent! wincmd P
-      if !&previewwindow
-        execute 'bo ' . &previewheight . ' new'
-        set previewwindow
-      endif
-
-      setlocal noro modifiable filetype=diff buftype=nofile bufhidden=delete noswapfile
-      execute "%delete_"
-      call append(0, split(diff_for_hunk, "\n"))
-
-      wincmd p
-    endif
-  endif
-  call gitgutter#utility#restore_shell()
-endfunction
-
-" }}}
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/async.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/async.vim
deleted file mode 100644
index 78e725f..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/async.vim
+++ /dev/null
@@ -1,196 +0,0 @@
-let s:jobs = {}
-
-" Nvim has always supported async commands.
-"
-" Vim introduced async in 7.4.1826.
-"
-" gVim didn't support aync until 7.4.1850 (though I haven't been able to
-" verify this myself).
-"
-" MacVim-GUI didn't support async until 7.4.1832 (actually commit
-" 88f4fe0 but 7.4.1832 was the first subsequent patch release).
-let s:available = has('nvim') || (
-      \ (has('patch-7-4-1826') && !has('gui_running')) ||
-      \ (has('patch-7-4-1850') &&  has('gui_running')) ||
-      \ (has('patch-7-4-1832') &&  has('gui_macvim'))
-      \ )
-
-function! gitgutter#async#available()
-  return s:available
-endfunction
-
-function! gitgutter#async#execute(cmd) abort
-  let bufnr = gitgutter#utility#bufnr()
-
-  if has('nvim')
-    if has('unix')
-      let command = ["/bin/sh", "-c", a:cmd]
-    elseif has('win32')
-      let command = ["cmd.exe", "/c", a:cmd]
-    else
-      throw 'unknown os'
-    endif
-    " Make the job use a shell while avoiding (un)quoting problems.
-    let job_id = jobstart(command, {
-          \ 'buffer':    bufnr,
-          \ 'on_stdout': function('gitgutter#async#handle_diff_job_nvim'),
-          \ 'on_stderr': function('gitgutter#async#handle_diff_job_nvim'),
-          \ 'on_exit':   function('gitgutter#async#handle_diff_job_nvim')
-          \ })
-    call gitgutter#debug#log('[nvim job: '.job_id.', buffer: '.bufnr.'] '.a:cmd)
-    if job_id < 1
-      throw 'diff failed'
-    endif
-
-    " Note that when `cmd` doesn't produce any output, i.e. the diff is empty,
-    " the `stdout` event is not fired on the job handler.  Therefore we keep
-    " track of the jobs ourselves so we can spot empty diffs.
-    call s:job_started(job_id)
-
-  else
-    " Make the job use a shell.
-    "
-    " Pass a handler for stdout but not for stderr so that errors are
-    " ignored (and thus signs are not updated; this assumes that an error
-    " only occurs when a file is not tracked by git).
-
-    if has('unix')
-      let command = ["/bin/sh", "-c", a:cmd]
-    elseif has('win32')
-      " Help docs recommend {command} be a string on Windows.  But I think
-      " they also say that will run the command directly, which I believe would
-      " mean the redirection and pipe stuff wouldn't work.
-      " let command = "cmd.exe /c ".a:cmd
-      let command = ["cmd.exe", "/c", a:cmd]
-    else
-      throw 'unknown os'
-    endif
-
-    let job = job_start(command, {
-          \ 'out_cb':   'gitgutter#async#handle_diff_job_vim',
-          \ 'close_cb': 'gitgutter#async#handle_diff_job_vim_close'
-          \ })
-    call gitgutter#debug#log('[vim job: '.string(job_info(job)).', buffer: '.bufnr.'] '.a:cmd)
-
-    call s:job_started(s:channel_id(job_getchannel(job)), bufnr)
-  endif
-endfunction
-
-
-function! gitgutter#async#handle_diff_job_nvim(job_id, data, event) abort
-  call gitgutter#debug#log('job_id: '.a:job_id.', event: '.a:event.', buffer: '.self.buffer)
-
-  let current_buffer = gitgutter#utility#bufnr()
-  call gitgutter#utility#set_buffer(self.buffer)
-
-  if a:event == 'stdout'
-    " a:data is a list
-    call s:job_finished(a:job_id)
-    call gitgutter#handle_diff(gitgutter#utility#stringify(a:data))
-
-  elseif a:event == 'exit'
-    " If the exit event is triggered without a preceding stdout event,
-    " the diff was empty.
-    if s:is_job_started(a:job_id)
-      call gitgutter#handle_diff("")
-      call s:job_finished(a:job_id)
-    endif
-
-  else  " a:event is stderr
-    call gitgutter#hunk#reset()
-    call s:job_finished(a:job_id)
-
-  endif
-
-  call gitgutter#utility#set_buffer(current_buffer)
-endfunction
-
-
-" Channel is in NL mode.
-function! gitgutter#async#handle_diff_job_vim(channel, line) abort
-  call gitgutter#debug#log('channel: '.a:channel.', line: '.a:line)
-
-  call s:accumulate_job_output(s:channel_id(a:channel), a:line)
-endfunction
-
-function! gitgutter#async#handle_diff_job_vim_close(channel) abort
-  call gitgutter#debug#log('channel: '.a:channel)
-
-  let channel_id = s:channel_id(a:channel)
-
-  let current_buffer = gitgutter#utility#bufnr()
-  call gitgutter#utility#set_buffer(s:job_buffer(channel_id))
-
-  call gitgutter#handle_diff(s:job_output(channel_id))
-  call s:job_finished(channel_id)
-
-  call gitgutter#utility#set_buffer(current_buffer)
-endfunction
-
-
-function! s:channel_id(channel) abort
-  " This seems to be the only way to get info about the channel once closed.
-  return matchstr(a:channel, '\d\+')
-endfunction
-
-
-"
-" Keep track of jobs.
-"
-" nvim: receives all the job's output at once so we don't need to accumulate
-" it ourselves.  We can pass the buffer number into the job so we don't need
-" to track that either.
-"
-"   s:jobs {} -> key: job's id, value: anything truthy
-"
-" vim: receives the job's output line by line so we need to accumulate it.
-" We also need to keep track of the buffer the job is running for.
-" Vim job's don't have an id.  Instead we could use the external process's id
-" or the channel's id (there seems to be 1 channel per job).  Arbitrarily
-" choose the channel's id.
-"
-"   s:jobs {} -> key: channel's id, value: {} key: output, value: [] job's output
-"                                             key: buffer: value: buffer number
-
-
-" nvim:
-"        id: job's id
-"
-" vim:
-"        id: channel's id
-"        arg: buffer number
-function! s:job_started(id, ...) abort
-  if a:0  " vim
-    let s:jobs[a:id] = {'output': [], 'buffer': a:1}
-  else    " nvim
-    let s:jobs[a:id] = 1
-  endif
-endfunction
-
-function! s:is_job_started(id) abort
-  return has_key(s:jobs, a:id)
-endfunction
-
-function! s:accumulate_job_output(id, line) abort
-  call add(s:jobs[a:id].output, a:line)
-endfunction
-
-" Returns a string
-function! s:job_output(id) abort
-  if has_key(s:jobs, a:id)
-    return gitgutter#utility#stringify(s:jobs[a:id].output)
-  else
-    return ""
-  endif
-endfunction
-
-function! s:job_buffer(id) abort
-  return s:jobs[a:id].buffer
-endfunction
-
-function! s:job_finished(id) abort
-  if has_key(s:jobs, a:id)
-    unlet s:jobs[a:id]
-  endif
-endfunction
-
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/debug.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/debug.vim
deleted file mode 100644
index 594f044..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/debug.vim
+++ /dev/null
@@ -1,119 +0,0 @@
-let s:plugin_dir  = expand('<sfile>:p:h:h:h').'/'
-let s:log_file    = s:plugin_dir.'gitgutter.log'
-let s:channel_log = s:plugin_dir.'channel.log'
-let s:new_log_session = 1
-
-
-function! gitgutter#debug#debug()
-  " Open a scratch buffer
-  vsplit __GitGutter_Debug__
-  normal! ggdG
-  setlocal buftype=nofile
-  setlocal bufhidden=delete
-  setlocal noswapfile
-
-  call gitgutter#debug#vim_version()
-  call gitgutter#debug#separator()
-
-  call gitgutter#debug#git_version()
-  call gitgutter#debug#separator()
-
-  call gitgutter#debug#grep_version()
-  call gitgutter#debug#separator()
-
-  call gitgutter#debug#option('updatetime')
-  call gitgutter#debug#option('shell')
-  call gitgutter#debug#option('shellcmdflag')
-  call gitgutter#debug#option('shellpipe')
-  call gitgutter#debug#option('shellquote')
-  call gitgutter#debug#option('shellredir')
-  call gitgutter#debug#option('shellslash')
-  call gitgutter#debug#option('shelltemp')
-  call gitgutter#debug#option('shelltype')
-  call gitgutter#debug#option('shellxescape')
-  call gitgutter#debug#option('shellxquote')
-endfunction
-
-
-function! gitgutter#debug#separator()
-  call gitgutter#debug#output('')
-endfunction
-
-function! gitgutter#debug#vim_version()
-  redir => version_info
-    silent execute 'version'
-  redir END
-  call gitgutter#debug#output(split(version_info, '\n')[0:2])
-endfunction
-
-function! gitgutter#debug#git_version()
-  let v = system(g:gitgutter_git_executable.' --version')
-  call gitgutter#debug#output( substitute(v, '\n$', '', '') )
-endfunction
-
-function! gitgutter#debug#grep_version()
-  let v = system('grep --version')
-  call gitgutter#debug#output( substitute(v, '\n$', '', '') )
-
-  let v = system('grep --help')
-  call gitgutter#debug#output( substitute(v, '\%x00', '', 'g') )
-endfunction
-
-function! gitgutter#debug#option(name)
-  if exists('+' . a:name)
-    let v = eval('&' . a:name)
-    call gitgutter#debug#output(a:name . '=' . v)
-    " redir => output
-    "   silent execute "verbose set " . a:name . "?"
-    " redir END
-    " call gitgutter#debug#output(a:name . '=' . output)
-  else
-    call gitgutter#debug#output(a:name . ' [n/a]')
-  end
-endfunction
-
-function! gitgutter#debug#output(text)
-  call append(line('$'), a:text)
-endfunction
-
-" assumes optional args are calling function's optional args
-function! gitgutter#debug#log(message, ...) abort
-  if g:gitgutter_log
-    if s:new_log_session && gitgutter#async#available()
-      if exists('*ch_logfile')
-        call ch_logfile(s:channel_log, 'w')
-      endif
-    endif
-
-    execute 'redir >> '.s:log_file
-      if s:new_log_session
-        let s:start = reltime()
-        silent echo "\n==== start log session ===="
-      endif
-
-      let elapsed = reltimestr(reltime(s:start)).' '
-      silent echo ''
-      " callers excluding this function
-      silent echo elapsed.expand('<sfile>')[:-22].':'
-      silent echo elapsed.s:format_for_log(a:message)
-      if a:0 && !empty(a:1)
-        for msg in a:000
-          silent echo elapsed.s:format_for_log(msg)
-        endfor
-      endif
-    redir END
-
-    let s:new_log_session = 0
-  endif
-endfunction
-
-function! s:format_for_log(data) abort
-  if type(a:data) == 1
-    return join(split(a:data,'\n'),"\n")
-  elseif type(a:data) == 3
-    return '['.join(a:data,"\n").']'
-  else
-    return a:data
-  endif
-endfunction
-
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/diff.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/diff.vim
deleted file mode 100644
index 170193b..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/diff.vim
+++ /dev/null
@@ -1,342 +0,0 @@
-if exists('g:gitgutter_grep_command')
-  let s:grep_available = 1
-  let s:grep_command = g:gitgutter_grep_command
-else
-  let s:grep_available = executable('grep')
-  if s:grep_available
-    let s:grep_command = 'grep --color=never -e'
-  endif
-endif
-let s:hunk_re = '^@@ -\(\d\+\),\?\(\d*\) +\(\d\+\),\?\(\d*\) @@'
-
-let s:c_flag = gitgutter#utility#git_supports_command_line_config_override()
-
-let s:temp_index = tempname()
-let s:temp_buffer = tempname()
-
-" Returns a diff of the buffer.
-"
-" The way to get the diff depends on whether the buffer is saved or unsaved.
-"
-" * Saved: the buffer contents is the same as the file on disk in the working
-"   tree so we simply do:
-"
-"       git diff myfile
-"
-" * Unsaved: the buffer contents is not the same as the file on disk so we
-"   need to pass two instances of the file to git-diff:
-"
-"       git diff myfileA myfileB
-"
-"   The first instance is the file in the index which we obtain with:
-"
-"       git show :myfile > myfileA
-"
-"   The second instance is the buffer contents.  Ideally we would pass this to
-"   git-diff on stdin via the second argument to vim's system() function.
-"   Unfortunately git-diff does not do CRLF conversion for input received on
-"   stdin, and git-show never performs CRLF conversion, so repos with CRLF
-"   conversion report that every line is modified due to mismatching EOLs.
-"
-"   Instead, we write the buffer contents to a temporary file - myfileB in this
-"   example.  Note the file extension must be preserved for the CRLF
-"   conversion to work.
-"
-" Before diffing a buffer for the first time, we check whether git knows about
-" the file:
-"
-"     git ls-files --error-unmatch myfile
-"
-" After running the diff we pass it through grep where available to reduce
-" subsequent processing by the plugin.  If grep is not available the plugin
-" does the filtering instead.
-function! gitgutter#diff#run_diff(realtime, preserve_full_diff) abort
-  " Wrap compound commands in parentheses to make Windows happy.
-  " bash doesn't mind the parentheses.
-  let cmd = '('
-
-  let bufnr = gitgutter#utility#bufnr()
-  let tracked = getbufvar(bufnr, 'gitgutter_tracked')  " i.e. tracked by git
-  if !tracked
-    " Don't bother trying to realtime-diff an untracked file.
-    " NOTE: perhaps we should pull this guard up to the caller?
-    if a:realtime
-      throw 'diff failed'
-    else
-      let cmd .= g:gitgutter_git_executable.' ls-files --error-unmatch '.gitgutter#utility#shellescape(gitgutter#utility#filename()).' && ('
-    endif
-  endif
-
-  if a:realtime
-    let blob_name = g:gitgutter_diff_base.':'.gitgutter#utility#shellescape(gitgutter#utility#file_relative_to_repo_root())
-    let blob_file = s:temp_index
-    let buff_file = s:temp_buffer
-    let extension = gitgutter#utility#extension()
-    if !empty(extension)
-      let blob_file .= '.'.extension
-      let buff_file .= '.'.extension
-    endif
-    let cmd .= g:gitgutter_git_executable.' show '.blob_name.' > '.blob_file.' && '
-
-    " Writing the whole buffer resets the '[ and '] marks and also the
-    " 'modified' flag (if &cpoptions includes '+').  These are unwanted
-    " side-effects so we save and restore the values ourselves.
-    let modified      = getbufvar(bufnr, "&mod")
-    let op_mark_start = getpos("'[")
-    let op_mark_end   = getpos("']")
-
-    execute 'keepalt noautocmd silent write!' buff_file
-
-    call setbufvar(bufnr, "&mod", modified)
-    call setpos("'[", op_mark_start)
-    call setpos("']", op_mark_end)
-  endif
-
-  let cmd .= g:gitgutter_git_executable
-  if s:c_flag
-    let cmd .= ' -c "diff.autorefreshindex=0"'
-  endif
-  let cmd .= ' diff --no-ext-diff --no-color -U0 '.g:gitgutter_diff_args.' '
-
-  if a:realtime
-    let cmd .= ' -- '.blob_file.' '.buff_file
-  else
-    let cmd .= g:gitgutter_diff_base.' -- '.gitgutter#utility#shellescape(gitgutter#utility#filename())
-  endif
-
-  if !a:preserve_full_diff && s:grep_available
-    let cmd .= ' | '.s:grep_command.' '.gitgutter#utility#shellescape('^@@ ')
-  endif
-
-  if (!a:preserve_full_diff && s:grep_available) || a:realtime
-    " grep exits with 1 when no matches are found; diff exits with 1 when
-    " differences are found.  However we want to treat non-matches and
-    " differences as non-erroneous behaviour; so we OR the command with one
-    " which always exits with success (0).
-    let cmd .= ' || exit 0'
-  endif
-
-  let cmd .= ')'
-
-  if !tracked
-    let cmd .= ')'
-  endif
-
-  let cmd = gitgutter#utility#command_in_directory_of_file(cmd)
-
-  if g:gitgutter_async && gitgutter#async#available() && !a:preserve_full_diff
-    call gitgutter#async#execute(cmd)
-    return 'async'
-
-  else
-    let diff = gitgutter#utility#system(cmd)
-
-    if gitgutter#utility#shell_error()
-      " A shell error indicates the file is not tracked by git (unless something bizarre is going on).
-      throw 'diff failed'
-    endif
-
-    return diff
-  endif
-endfunction
-
-function! gitgutter#diff#parse_diff(diff) abort
-  let hunks = []
-  for line in split(a:diff, '\n')
-    let hunk_info = gitgutter#diff#parse_hunk(line)
-    if len(hunk_info) == 4
-      call add(hunks, hunk_info)
-    endif
-  endfor
-  return hunks
-endfunction
-
-function! gitgutter#diff#parse_hunk(line) abort
-  let matches = matchlist(a:line, s:hunk_re)
-  if len(matches) > 0
-    let from_line  = str2nr(matches[1])
-    let from_count = (matches[2] == '') ? 1 : str2nr(matches[2])
-    let to_line    = str2nr(matches[3])
-    let to_count   = (matches[4] == '') ? 1 : str2nr(matches[4])
-    return [from_line, from_count, to_line, to_count]
-  else
-    return []
-  end
-endfunction
-
-function! gitgutter#diff#process_hunks(hunks) abort
-  call gitgutter#hunk#reset()
-  let modified_lines = []
-  for hunk in a:hunks
-    call extend(modified_lines, gitgutter#diff#process_hunk(hunk))
-  endfor
-  return modified_lines
-endfunction
-
-" Returns [ [<line_number (number)>, <name (string)>], ...]
-function! gitgutter#diff#process_hunk(hunk) abort
-  let modifications = []
-  let from_line  = a:hunk[0]
-  let from_count = a:hunk[1]
-  let to_line    = a:hunk[2]
-  let to_count   = a:hunk[3]
-
-  if gitgutter#diff#is_added(from_count, to_count)
-    call gitgutter#diff#process_added(modifications, from_count, to_count, to_line)
-    call gitgutter#hunk#increment_lines_added(to_count)
-
-  elseif gitgutter#diff#is_removed(from_count, to_count)
-    call gitgutter#diff#process_removed(modifications, from_count, to_count, to_line)
-    call gitgutter#hunk#increment_lines_removed(from_count)
-
-  elseif gitgutter#diff#is_modified(from_count, to_count)
-    call gitgutter#diff#process_modified(modifications, from_count, to_count, to_line)
-    call gitgutter#hunk#increment_lines_modified(to_count)
-
-  elseif gitgutter#diff#is_modified_and_added(from_count, to_count)
-    call gitgutter#diff#process_modified_and_added(modifications, from_count, to_count, to_line)
-    call gitgutter#hunk#increment_lines_added(to_count - from_count)
-    call gitgutter#hunk#increment_lines_modified(from_count)
-
-  elseif gitgutter#diff#is_modified_and_removed(from_count, to_count)
-    call gitgutter#diff#process_modified_and_removed(modifications, from_count, to_count, to_line)
-    call gitgutter#hunk#increment_lines_modified(to_count)
-    call gitgutter#hunk#increment_lines_removed(from_count - to_count)
-
-  endif
-  return modifications
-endfunction
-
-function! gitgutter#diff#is_added(from_count, to_count) abort
-  return a:from_count == 0 && a:to_count > 0
-endfunction
-
-function! gitgutter#diff#is_removed(from_count, to_count) abort
-  return a:from_count > 0 && a:to_count == 0
-endfunction
-
-function! gitgutter#diff#is_modified(from_count, to_count) abort
-  return a:from_count > 0 && a:to_count > 0 && a:from_count == a:to_count
-endfunction
-
-function! gitgutter#diff#is_modified_and_added(from_count, to_count) abort
-  return a:from_count > 0 && a:to_count > 0 && a:from_count < a:to_count
-endfunction
-
-function! gitgutter#diff#is_modified_and_removed(from_count, to_count) abort
-  return a:from_count > 0 && a:to_count > 0 && a:from_count > a:to_count
-endfunction
-
-function! gitgutter#diff#process_added(modifications, from_count, to_count, to_line) abort
-  let offset = 0
-  while offset < a:to_count
-    let line_number = a:to_line + offset
-    call add(a:modifications, [line_number, 'added'])
-    let offset += 1
-  endwhile
-endfunction
-
-function! gitgutter#diff#process_removed(modifications, from_count, to_count, to_line) abort
-  if a:to_line == 0
-    call add(a:modifications, [1, 'removed_first_line'])
-  else
-    call add(a:modifications, [a:to_line, 'removed'])
-  endif
-endfunction
-
-function! gitgutter#diff#process_modified(modifications, from_count, to_count, to_line) abort
-  let offset = 0
-  while offset < a:to_count
-    let line_number = a:to_line + offset
-    call add(a:modifications, [line_number, 'modified'])
-    let offset += 1
-  endwhile
-endfunction
-
-function! gitgutter#diff#process_modified_and_added(modifications, from_count, to_count, to_line) abort
-  let offset = 0
-  while offset < a:from_count
-    let line_number = a:to_line + offset
-    call add(a:modifications, [line_number, 'modified'])
-    let offset += 1
-  endwhile
-  while offset < a:to_count
-    let line_number = a:to_line + offset
-    call add(a:modifications, [line_number, 'added'])
-    let offset += 1
-  endwhile
-endfunction
-
-function! gitgutter#diff#process_modified_and_removed(modifications, from_count, to_count, to_line) abort
-  let offset = 0
-  while offset < a:to_count
-    let line_number = a:to_line + offset
-    call add(a:modifications, [line_number, 'modified'])
-    let offset += 1
-  endwhile
-  let a:modifications[-1] = [a:to_line + offset - 1, 'modified_removed']
-endfunction
-
-" Generates a zero-context diff for the current hunk.
-"
-" diff - the full diff for the buffer
-" type - stage | undo | preview
-function! gitgutter#diff#generate_diff_for_hunk(diff, type) abort
-  let diff_for_hunk = gitgutter#diff#discard_hunks(a:diff, a:type == 'stage' || a:type == 'undo')
-
-  if a:type == 'stage' || a:type == 'undo'
-    let diff_for_hunk = gitgutter#diff#adjust_hunk_summary(diff_for_hunk, a:type == 'stage')
-  endif
-
-  return diff_for_hunk
-endfunction
-
-" Returns the diff with all hunks discarded except the current.
-"
-" diff        - the diff to process
-" keep_header - truthy to keep the diff header and hunk summary, falsy to discard it
-function! gitgutter#diff#discard_hunks(diff, keep_header) abort
-  let modified_diff = []
-  let keep_line = a:keep_header
-  for line in split(a:diff, '\n')
-    let hunk_info = gitgutter#diff#parse_hunk(line)
-    if len(hunk_info) == 4  " start of new hunk
-      let keep_line = gitgutter#hunk#cursor_in_hunk(hunk_info)
-    endif
-    if keep_line
-      call add(modified_diff, line)
-    endif
-  endfor
-
-  if a:keep_header
-    return gitgutter#utility#stringify(modified_diff)
-  else
-    " Discard hunk summary too.
-    return gitgutter#utility#stringify(modified_diff[1:])
-  endif
-endfunction
-
-" Adjust hunk summary (from's / to's line number) to ignore changes above/before this one.
-"
-" diff_for_hunk - a diff containing only the hunk of interest
-" staging       - truthy if the hunk is to be staged, falsy if it is to be undone
-"
-" TODO: push this down to #discard_hunks?
-function! gitgutter#diff#adjust_hunk_summary(diff_for_hunk, staging) abort
-  let line_adjustment = gitgutter#hunk#line_adjustment_for_current_hunk()
-  let adj_diff = []
-  for line in split(a:diff_for_hunk, '\n')
-    if match(line, s:hunk_re) != -1
-      if a:staging
-        " increment 'to' line number
-        let line = substitute(line, '+\@<=\(\d\+\)', '\=submatch(1)+line_adjustment', '')
-      else
-        " decrement 'from' line number
-        let line = substitute(line, '-\@<=\(\d\+\)', '\=submatch(1)-line_adjustment', '')
-      endif
-    endif
-    call add(adj_diff, line)
-  endfor
-  return gitgutter#utility#stringify(adj_diff)
-endfunction
-
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/highlight.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/highlight.vim
deleted file mode 100644
index e3b774b..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/highlight.vim
+++ /dev/null
@@ -1,115 +0,0 @@
-function! gitgutter#highlight#define_sign_column_highlight() abort
-  if g:gitgutter_override_sign_column_highlight
-    highlight! link SignColumn LineNr
-  else
-    highlight default link SignColumn LineNr
-  endif
-endfunction
-
-function! gitgutter#highlight#define_highlights() abort
-  let [guibg, ctermbg] = gitgutter#highlight#get_background_colors('SignColumn')
-
-  " Highlights used by the signs.
-
-  execute "highlight GitGutterAddDefault    guifg=#009900 guibg=" . guibg . " ctermfg=2 ctermbg=" . ctermbg
-  execute "highlight GitGutterChangeDefault guifg=#bbbb00 guibg=" . guibg . " ctermfg=3 ctermbg=" . ctermbg
-  execute "highlight GitGutterDeleteDefault guifg=#ff2222 guibg=" . guibg . " ctermfg=1 ctermbg=" . ctermbg
-  highlight default link GitGutterChangeDeleteDefault GitGutterChangeDefault
-
-  execute "highlight GitGutterAddInvisible    guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
-  execute "highlight GitGutterChangeInvisible guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
-  execute "highlight GitGutterDeleteInvisible guifg=bg guibg=" . guibg . " ctermfg=" . ctermbg . " ctermbg=" . ctermbg
-  highlight default link GitGutterChangeDeleteInvisible GitGutterChangeInvisble
-
-  highlight default link GitGutterAdd          GitGutterAddDefault
-  highlight default link GitGutterChange       GitGutterChangeDefault
-  highlight default link GitGutterDelete       GitGutterDeleteDefault
-  highlight default link GitGutterChangeDelete GitGutterChangeDeleteDefault
-
-  " Highlights used for the whole line.
-
-  highlight default link GitGutterAddLine          DiffAdd
-  highlight default link GitGutterChangeLine       DiffChange
-  highlight default link GitGutterDeleteLine       DiffDelete
-  highlight default link GitGutterChangeDeleteLine GitGutterChangeLine
-endfunction
-
-function! gitgutter#highlight#define_signs() abort
-  sign define GitGutterLineAdded
-  sign define GitGutterLineModified
-  sign define GitGutterLineRemoved
-  sign define GitGutterLineRemovedFirstLine
-  sign define GitGutterLineModifiedRemoved
-  sign define GitGutterDummy
-
-  call gitgutter#highlight#define_sign_text()
-  call gitgutter#highlight#define_sign_text_highlights()
-  call gitgutter#highlight#define_sign_line_highlights()
-endfunction
-
-function! gitgutter#highlight#define_sign_text() abort
-  execute "sign define GitGutterLineAdded            text=" . g:gitgutter_sign_added
-  execute "sign define GitGutterLineModified         text=" . g:gitgutter_sign_modified
-  execute "sign define GitGutterLineRemoved          text=" . g:gitgutter_sign_removed
-  execute "sign define GitGutterLineRemovedFirstLine text=" . g:gitgutter_sign_removed_first_line
-  execute "sign define GitGutterLineModifiedRemoved  text=" . g:gitgutter_sign_modified_removed
-endfunction
-
-function! gitgutter#highlight#define_sign_text_highlights() abort
-  " Once a sign's text attribute has been defined, it cannot be undefined or
-  " set to an empty value.  So to make signs' text disappear (when toggling
-  " off or disabling) we make them invisible by setting their foreground colours
-  " to the background's.
-  if g:gitgutter_signs
-    sign define GitGutterLineAdded            texthl=GitGutterAdd
-    sign define GitGutterLineModified         texthl=GitGutterChange
-    sign define GitGutterLineRemoved          texthl=GitGutterDelete
-    sign define GitGutterLineRemovedFirstLine texthl=GitGutterDelete
-    sign define GitGutterLineModifiedRemoved  texthl=GitGutterChangeDelete
-  else
-    sign define GitGutterLineAdded            texthl=GitGutterAddInvisible
-    sign define GitGutterLineModified         texthl=GitGutterChangeInvisible
-    sign define GitGutterLineRemoved          texthl=GitGutterDeleteInvisible
-    sign define GitGutterLineRemovedFirstLine texthl=GitGutterDeleteInvisible
-    sign define GitGutterLineModifiedRemoved  texthl=GitGutterChangeDeleteInvisible
-  endif
-endfunction
-
-function! gitgutter#highlight#define_sign_line_highlights() abort
-  if g:gitgutter_highlight_lines
-    sign define GitGutterLineAdded            linehl=GitGutterAddLine
-    sign define GitGutterLineModified         linehl=GitGutterChangeLine
-    sign define GitGutterLineRemoved          linehl=GitGutterDeleteLine
-    sign define GitGutterLineRemovedFirstLine linehl=GitGutterDeleteLine
-    sign define GitGutterLineModifiedRemoved  linehl=GitGutterChangeDeleteLine
-  else
-    sign define GitGutterLineAdded            linehl=
-    sign define GitGutterLineModified         linehl=
-    sign define GitGutterLineRemoved          linehl=
-    sign define GitGutterLineRemovedFirstLine linehl=
-    sign define GitGutterLineModifiedRemoved  linehl=
-  endif
-endfunction
-
-function! gitgutter#highlight#get_background_colors(group) abort
-  redir => highlight
-  silent execute 'silent highlight ' . a:group
-  redir END
-
-  let link_matches = matchlist(highlight, 'links to \(\S\+\)')
-  if len(link_matches) > 0 " follow the link
-    return gitgutter#highlight#get_background_colors(link_matches[1])
-  endif
-
-  let ctermbg = gitgutter#highlight#match_highlight(highlight, 'ctermbg=\([0-9A-Za-z]\+\)')
-  let guibg   = gitgutter#highlight#match_highlight(highlight, 'guibg=\([#0-9A-Za-z]\+\)')
-  return [guibg, ctermbg]
-endfunction
-
-function! gitgutter#highlight#match_highlight(highlight, pattern) abort
-  let matches = matchlist(a:highlight, a:pattern)
-  if len(matches) == 0
-    return 'NONE'
-  endif
-  return matches[1]
-endfunction
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/hunk.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/hunk.vim
deleted file mode 100644
index 0fd0246..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/hunk.vim
+++ /dev/null
@@ -1,137 +0,0 @@
-let s:hunks = []
-
-function! gitgutter#hunk#set_hunks(hunks) abort
-  let s:hunks = a:hunks
-endfunction
-
-function! gitgutter#hunk#hunks() abort
-  return s:hunks
-endfunction
-
-function! gitgutter#hunk#summary(bufnr) abort
-  return get(getbufvar(a:bufnr,''), 'gitgutter_summary', [0,0,0])
-endfunction
-
-function! gitgutter#hunk#reset() abort
-  call setbufvar(gitgutter#utility#bufnr(), 'gitgutter_summary', [0,0,0])
-endfunction
-
-function! gitgutter#hunk#increment_lines_added(count) abort
-  let bufnr = gitgutter#utility#bufnr()
-  let summary = gitgutter#hunk#summary(bufnr)
-  let summary[0] += a:count
-  call setbufvar(bufnr, 'gitgutter_summary', summary)
-endfunction
-
-function! gitgutter#hunk#increment_lines_modified(count) abort
-  let bufnr = gitgutter#utility#bufnr()
-  let summary = gitgutter#hunk#summary(bufnr)
-  let summary[1] += a:count
-  call setbufvar(bufnr, 'gitgutter_summary', summary)
-endfunction
-
-function! gitgutter#hunk#increment_lines_removed(count) abort
-  let bufnr = gitgutter#utility#bufnr()
-  let summary = gitgutter#hunk#summary(bufnr)
-  let summary[2] += a:count
-  call setbufvar(bufnr, 'gitgutter_summary', summary)
-endfunction
-
-function! gitgutter#hunk#next_hunk(count) abort
-  if gitgutter#utility#is_active()
-    let current_line = line('.')
-    let hunk_count = 0
-    for hunk in s:hunks
-      if hunk[2] > current_line
-        let hunk_count += 1
-        if hunk_count == a:count
-          execute 'normal!' hunk[2] . 'G'
-          return
-        endif
-      endif
-    endfor
-    call gitgutter#utility#warn('No more hunks')
-  endif
-endfunction
-
-function! gitgutter#hunk#prev_hunk(count) abort
-  if gitgutter#utility#is_active()
-    let current_line = line('.')
-    let hunk_count = 0
-    for hunk in reverse(copy(s:hunks))
-      if hunk[2] < current_line
-        let hunk_count += 1
-        if hunk_count == a:count
-          let target = hunk[2] == 0 ? 1 : hunk[2]
-          execute 'normal!' target . 'G'
-          return
-        endif
-      endif
-    endfor
-    call gitgutter#utility#warn('No previous hunks')
-  endif
-endfunction
-
-" Returns the hunk the cursor is currently in or an empty list if the cursor
-" isn't in a hunk.
-function! gitgutter#hunk#current_hunk() abort
-  let current_hunk = []
-
-  for hunk in s:hunks
-    if gitgutter#hunk#cursor_in_hunk(hunk)
-      let current_hunk = hunk
-      break
-    endif
-  endfor
-
-  return current_hunk
-endfunction
-
-function! gitgutter#hunk#cursor_in_hunk(hunk) abort
-  let current_line = line('.')
-
-  if current_line == 1 && a:hunk[2] == 0
-    return 1
-  endif
-
-  if current_line >= a:hunk[2] && current_line < a:hunk[2] + (a:hunk[3] == 0 ? 1 : a:hunk[3])
-    return 1
-  endif
-
-  return 0
-endfunction
-
-" Returns the number of lines the current hunk is offset from where it would
-" be if any changes above it in the file didn't exist.
-function! gitgutter#hunk#line_adjustment_for_current_hunk() abort
-  let adj = 0
-  for hunk in s:hunks
-    if gitgutter#hunk#cursor_in_hunk(hunk)
-      break
-    else
-      let adj += hunk[1] - hunk[3]
-    endif
-  endfor
-  return adj
-endfunction
-
-function! gitgutter#hunk#text_object(inner) abort
-  let hunk = gitgutter#hunk#current_hunk()
-
-  if empty(hunk)
-    return
-  endif
-
-  let [first_line, last_line] = [hunk[2], hunk[2] + hunk[3] - 1]
-
-  if ! a:inner
-    let lnum = last_line
-    let eof = line('$')
-    while lnum < eof && empty(getline(lnum + 1))
-      let lnum +=1
-    endwhile
-    let last_line = lnum
-  endif
-
-  execute 'normal! 'first_line.'GV'.last_line.'G'
-endfunction
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/sign.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/sign.vim
deleted file mode 100644
index 6bd5efa..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/sign.vim
+++ /dev/null
@@ -1,173 +0,0 @@
-" Vim doesn't namespace sign ids so every plugin shares the same
-" namespace.  Sign ids are simply integers so to avoid clashes with other
-" signs we guess at a clear run.
-"
-" Note also we currently never reset s:next_sign_id.
-let s:first_sign_id = 3000
-let s:next_sign_id  = s:first_sign_id
-let s:dummy_sign_id = s:first_sign_id - 1
-" Remove-all-signs optimisation requires Vim 7.3.596+.
-let s:supports_star = v:version > 703 || (v:version == 703 && has("patch596"))
-
-
-" Removes gitgutter's signs (excluding dummy sign) from the buffer being processed.
-function! gitgutter#sign#clear_signs() abort
-  let bufnr = gitgutter#utility#bufnr()
-  call gitgutter#sign#find_current_signs()
-
-  let sign_ids = map(values(getbufvar(bufnr, 'gitgutter_gitgutter_signs')), 'v:val.id')
-  call gitgutter#sign#remove_signs(sign_ids, 1)
-  call setbufvar(bufnr, 'gitgutter_gitgutter_signs', {})
-endfunction
-
-
-" Updates gitgutter's signs in the buffer being processed.
-"
-" modified_lines: list of [<line_number (number)>, <name (string)>]
-" where name = 'added|removed|modified|modified_removed'
-function! gitgutter#sign#update_signs(modified_lines) abort
-  call gitgutter#sign#find_current_signs()
-
-  let new_gitgutter_signs_line_numbers = map(copy(a:modified_lines), 'v:val[0]')
-  let obsolete_signs = gitgutter#sign#obsolete_gitgutter_signs_to_remove(new_gitgutter_signs_line_numbers)
-
-  let flicker_possible = s:remove_all_old_signs && !empty(a:modified_lines)
-  if flicker_possible
-    call gitgutter#sign#add_dummy_sign()
-  endif
-
-  call gitgutter#sign#remove_signs(obsolete_signs, s:remove_all_old_signs)
-  call gitgutter#sign#upsert_new_gitgutter_signs(a:modified_lines)
-
-  if flicker_possible
-    call gitgutter#sign#remove_dummy_sign(0)
-  endif
-endfunction
-
-
-function! gitgutter#sign#add_dummy_sign() abort
-  let bufnr = gitgutter#utility#bufnr()
-  if !getbufvar(bufnr, 'gitgutter_dummy_sign')
-    execute "sign place" s:dummy_sign_id "line=" . 9999 "name=GitGutterDummy buffer=" . bufnr
-    call setbufvar(bufnr, 'gitgutter_dummy_sign', 1)
-  endif
-endfunction
-
-function! gitgutter#sign#remove_dummy_sign(force) abort
-  let bufnr = gitgutter#utility#bufnr()
-  if getbufvar(bufnr, 'gitgutter_dummy_sign') && (a:force || !g:gitgutter_sign_column_always)
-    execute "sign unplace" s:dummy_sign_id "buffer=" . bufnr
-    call setbufvar(bufnr, 'gitgutter_dummy_sign', 0)
-  endif
-endfunction
-
-
-"
-" Internal functions
-"
-
-
-function! gitgutter#sign#find_current_signs() abort
-  let bufnr = gitgutter#utility#bufnr()
-  let gitgutter_signs = {}  " <line_number (string)>: {'id': <id (number)>, 'name': <name (string)>}
-  let other_signs = []      " [<line_number (number),...]
-  let dummy_sign_placed = 0
-
-  redir => signs
-    silent execute "sign place buffer=" . bufnr
-  redir END
-
-  for sign_line in filter(split(signs, '\n')[2:], 'v:val =~# "="')
-    " Typical sign line:  line=88 id=1234 name=GitGutterLineAdded
-    " We assume splitting is faster than a regexp.
-    let components  = split(sign_line)
-    let name        = split(components[2], '=')[1]
-    if name =~# 'GitGutterDummy'
-      let dummy_sign_placed = 1
-    else
-      let line_number = str2nr(split(components[0], '=')[1])
-      if name =~# 'GitGutter'
-        let id = str2nr(split(components[1], '=')[1])
-        " Remove orphaned signs (signs placed on lines which have been deleted).
-        " (When a line is deleted its sign lingers.  Subsequent lines' signs'
-        " line numbers are decremented appropriately.)
-        if has_key(gitgutter_signs, line_number)
-          execute "sign unplace" gitgutter_signs[line_number].id
-        endif
-        let gitgutter_signs[line_number] = {'id': id, 'name': name}
-      else
-        call add(other_signs, line_number)
-      endif
-    end
-  endfor
-
-  call setbufvar(bufnr, 'gitgutter_dummy_sign', dummy_sign_placed)
-  call setbufvar(bufnr, 'gitgutter_gitgutter_signs', gitgutter_signs)
-  call setbufvar(bufnr, 'gitgutter_other_signs', other_signs)
-endfunction
-
-
-" Returns a list of [<id (number)>, ...]
-" Sets `s:remove_all_old_signs` as a side-effect.
-function! gitgutter#sign#obsolete_gitgutter_signs_to_remove(new_gitgutter_signs_line_numbers) abort
-  let bufnr = gitgutter#utility#bufnr()
-  let signs_to_remove = []  " list of [<id (number)>, ...]
-  let remove_all_signs = 1
-  let old_gitgutter_signs = getbufvar(bufnr, 'gitgutter_gitgutter_signs')
-  for line_number in keys(old_gitgutter_signs)
-    if index(a:new_gitgutter_signs_line_numbers, str2nr(line_number)) == -1
-      call add(signs_to_remove, old_gitgutter_signs[line_number].id)
-    else
-      let remove_all_signs = 0
-    endif
-  endfor
-  let s:remove_all_old_signs = remove_all_signs
-  return signs_to_remove
-endfunction
-
-
-function! gitgutter#sign#remove_signs(sign_ids, all_signs) abort
-  let bufnr = gitgutter#utility#bufnr()
-  if a:all_signs && s:supports_star && empty(getbufvar(bufnr, 'gitgutter_other_signs'))
-    let dummy_sign_present = getbufvar(bufnr, 'gitgutter_dummy_sign')
-    execute "sign unplace * buffer=" . bufnr
-    if dummy_sign_present
-      execute "sign place" s:dummy_sign_id "line=" . 9999 "name=GitGutterDummy buffer=" . bufnr
-    endif
-  else
-    for id in a:sign_ids
-      execute "sign unplace" id
-    endfor
-  endif
-endfunction
-
-
-function! gitgutter#sign#upsert_new_gitgutter_signs(modified_lines) abort
-  let bufnr = gitgutter#utility#bufnr()
-  let other_signs         = getbufvar(bufnr, 'gitgutter_other_signs')
-  let old_gitgutter_signs = getbufvar(bufnr, 'gitgutter_gitgutter_signs')
-
-  for line in a:modified_lines
-    let line_number = line[0]  " <number>
-    if index(other_signs, line_number) == -1  " don't clobber others' signs
-      let name = gitgutter#utility#highlight_name_for_change(line[1])
-      if !has_key(old_gitgutter_signs, line_number)  " insert
-        let id = gitgutter#sign#next_sign_id()
-        execute "sign place" id "line=" . line_number "name=" . name "buffer=" . bufnr
-      else  " update if sign has changed
-        let old_sign = old_gitgutter_signs[line_number]
-        if old_sign.name !=# name
-          execute "sign place" old_sign.id "name=" . name "buffer=" . bufnr
-        end
-      endif
-    endif
-  endfor
-  " At this point b:gitgutter_gitgutter_signs is out of date.
-endfunction
-
-
-function! gitgutter#sign#next_sign_id() abort
-  let next_id = s:next_sign_id
-  let s:next_sign_id += 1
-  return next_id
-endfunction
diff --git a/vim/bundle/vim-gitgutter/autoload/gitgutter/utility.vim b/vim/bundle/vim-gitgutter/autoload/gitgutter/utility.vim
deleted file mode 100644
index 3135453..0000000
--- a/vim/bundle/vim-gitgutter/autoload/gitgutter/utility.vim
+++ /dev/null
@@ -1,199 +0,0 @@
-let s:file = ''
-let s:using_xolox_shell = -1
-let s:exit_code = 0
-
-function! gitgutter#utility#warn(message) abort
-  echohl WarningMsg
-  echo 'vim-gitgutter: ' . a:message
-  echohl None
-  let v:warningmsg = a:message
-endfunction
-
-function! gitgutter#utility#warn_once(message, key) abort
-  if empty(getbufvar(s:bufnr, a:key))
-    call setbufvar(s:bufnr, a:key, '1')
-    echohl WarningMsg
-    redraw | echo 'vim-gitgutter: ' . a:message
-    echohl None
-    let v:warningmsg = a:message
-  endif
-endfunction
-
-" Returns truthy when the buffer's file should be processed; and falsey when it shouldn't.
-" This function does not and should not make any system calls.
-function! gitgutter#utility#is_active() abort
-  return g:gitgutter_enabled &&
-        \ !pumvisible() &&
-        \ gitgutter#utility#is_file_buffer() &&
-        \ gitgutter#utility#exists_file() &&
-        \ gitgutter#utility#not_git_dir()
-endfunction
-
-function! gitgutter#utility#not_git_dir() abort
-  return gitgutter#utility#full_path_to_directory_of_file() !~ '[/\\]\.git\($\|[/\\]\)'
-endfunction
-
-function! gitgutter#utility#is_file_buffer() abort
-  return empty(getbufvar(s:bufnr, '&buftype'))
-endfunction
-
-" A replacement for the built-in `shellescape(arg)`.
-"
-" Recent versions of Vim handle shell escaping pretty well.  However older
-" versions aren't as good.  This attempts to do the right thing.
-"
-" See:
-" https://github.com/tpope/vim-fugitive/blob/8f0b8edfbd246c0026b7a2388e1d883d579ac7f6/plugin/fugitive.vim#L29-L37
-function! gitgutter#utility#shellescape(arg) abort
-  if a:arg =~ '^[A-Za-z0-9_/.-]\+$'
-    return a:arg
-  elseif &shell =~# 'cmd' || gitgutter#utility#using_xolox_shell()
-    return '"' . substitute(substitute(a:arg, '"', '""', 'g'), '%', '"%"', 'g') . '"'
-  else
-    return shellescape(a:arg)
-  endif
-endfunction
-
-function! gitgutter#utility#set_buffer(bufnr) abort
-  let s:bufnr = a:bufnr
-  let s:file = resolve(bufname(a:bufnr))
-endfunction
-
-function! gitgutter#utility#bufnr()
-  return s:bufnr
-endfunction
-
-function! gitgutter#utility#file()
-  return s:file
-endfunction
-
-function! gitgutter#utility#filename() abort
-  return fnamemodify(s:file, ':t')
-endfunction
-
-function! gitgutter#utility#extension() abort
-  return fnamemodify(s:file, ':e')
-endfunction
-
-function! gitgutter#utility#full_path_to_directory_of_file() abort
-  return fnamemodify(s:file, ':p:h')
-endfunction
-
-function! gitgutter#utility#directory_of_file() abort
-  return fnamemodify(s:file, ':h')
-endfunction
-
-function! gitgutter#utility#exists_file() abort
-  return filereadable(s:file)
-endfunction
-
-function! gitgutter#utility#has_unsaved_changes() abort
-  return getbufvar(s:bufnr, "&mod")
-endfunction
-
-function! gitgutter#utility#has_fresh_changes() abort
-  return getbufvar(s:bufnr, 'changedtick') != getbufvar(s:bufnr, 'gitgutter_last_tick')
-endfunction
-
-function! gitgutter#utility#save_last_seen_change() abort
-  call setbufvar(s:bufnr, 'gitgutter_last_tick', getbufvar(s:bufnr, 'changedtick'))
-endfunction
-
-function! gitgutter#utility#shell_error() abort
-  return gitgutter#utility#using_xolox_shell() ? s:exit_code : v:shell_error
-endfunction
-
-function! gitgutter#utility#using_xolox_shell() abort
-  if s:using_xolox_shell == -1
-    if !g:gitgutter_avoid_cmd_prompt_on_windows
-      let s:using_xolox_shell = 0
-    " Although xolox/vim-shell works on both windows and unix we only want to use
-    " it on windows.
-    elseif has('win32') || has('win64') || has('win32unix')
-      let s:using_xolox_shell = exists('g:xolox#misc#version') && exists('g:xolox#shell#version')
-    else
-      let s:using_xolox_shell = 0
-    endif
-  endif
-  return s:using_xolox_shell
-endfunction
-
-function! gitgutter#utility#system(cmd, ...) abort
-  call gitgutter#debug#log(a:cmd, a:000)
-
-  if gitgutter#utility#using_xolox_shell()
-    let options = {'command': a:cmd, 'check': 0}
-    if a:0 > 0
-      let options['stdin'] = a:1
-    endif
-    let ret = xolox#misc#os#exec(options)
-    let output = join(ret.stdout, "\n")
-    let s:exit_code = ret.exit_code
-  else
-    silent let output = (a:0 == 0) ? system(a:cmd) : system(a:cmd, a:1)
-  endif
-  return output
-endfunction
-
-function! gitgutter#utility#file_relative_to_repo_root() abort
-  let file_path_relative_to_repo_root = getbufvar(s:bufnr, 'gitgutter_repo_relative_path')
-  if empty(file_path_relative_to_repo_root)
-    let dir_path_relative_to_repo_root = gitgutter#utility#system(gitgutter#utility#command_in_directory_of_file(g:gitgutter_git_executable.' rev-parse --show-prefix'))
-    let dir_path_relative_to_repo_root = gitgutter#utility#strip_trailing_new_line(dir_path_relative_to_repo_root)
-    let file_path_relative_to_repo_root = dir_path_relative_to_repo_root . gitgutter#utility#filename()
-    call setbufvar(s:bufnr, 'gitgutter_repo_relative_path', file_path_relative_to_repo_root)
-  endif
-  return file_path_relative_to_repo_root
-endfunction
-
-function! gitgutter#utility#command_in_directory_of_file(cmd) abort
-  return 'cd '.gitgutter#utility#shellescape(gitgutter#utility#directory_of_file()).' && '.a:cmd
-endfunction
-
-function! gitgutter#utility#highlight_name_for_change(text) abort
-  if a:text ==# 'added'
-    return 'GitGutterLineAdded'
-  elseif a:text ==# 'removed'
-    return 'GitGutterLineRemoved'
-  elseif a:text ==# 'removed_first_line'
-    return 'GitGutterLineRemovedFirstLine'
-  elseif a:text ==# 'modified'
-    return 'GitGutterLineModified'
-  elseif a:text ==# 'modified_removed'
-    return 'GitGutterLineModifiedRemoved'
-  endif
-endfunction
-
-function! gitgutter#utility#strip_trailing_new_line(line) abort
-  return substitute(a:line, '\n$', '', '')
-endfunction
-
-function! gitgutter#utility#git_version() abort
-  return matchstr(system(g:gitgutter_git_executable.' --version'), '[0-9.]\+')
-endfunction
-
-" True for git v1.7.2+.
-function! gitgutter#utility#git_supports_command_line_config_override() abort
-  let [major, minor, patch; _] = split(gitgutter#utility#git_version(), '\.')
-  return major > 1 || (major == 1 && minor > 7) || (minor == 7 && patch > 1)
-endfunction
-
-function! gitgutter#utility#stringify(list) abort
-  return join(a:list, "\n")."\n"
-endfunction
-
-function! gitgutter#utility#use_known_shell() abort
-  if has('unix')
-    let s:shell = &shell
-    let s:shellcmdflag = &shellcmdflag
-    set shell=/bin/sh
-    set shellcmdflag=-c
-  endif
-endfunction
-
-function! gitgutter#utility#restore_shell() abort
-  if has('unix')
-    let &shell = s:shell
-    let &shellcmdflag = s:shellcmdflag
-  endif
-endfunction
diff --git a/vim/bundle/vim-gitgutter/doc/gitgutter.txt b/vim/bundle/vim-gitgutter/doc/gitgutter.txt
deleted file mode 100644
index d4bb774..0000000
--- a/vim/bundle/vim-gitgutter/doc/gitgutter.txt
+++ /dev/null
@@ -1,340 +0,0 @@
-*gitgutter.txt*              A Vim plugin which shows a git diff in the gutter.
-
-
-                           Vim Git Gutter
-
-
-Author:            Andy Stewart <http://airbladesoftware.com/>
-Plugin Homepage:   <https://github.com/airblade/vim-gitgutter>
-
-===============================================================================
-CONTENTS                                                    *GitGutterContents*
-
-  1.  Introduction ................. |GitGutterIntroduction|
-  2.  Installation ................. |GitGutterInstallation|
-  3.  Usage ........................ |GitGutterUsage|
-  4.  Commands ..................... |GitGutterCommands|
-  5.  Autocommand .................. |GitGutterAutocmd|
-  6.  CUSTOMISATION................. |GitGutterCustomisation|
-  7.  FAQ .......................... |GitGutterFAQ|
-
-===============================================================================
-1. INTRODUCTION                                         *GitGutterIntroduction*
-                                                                    *GitGutter*
-
-Vim Git Gutter is a Vim plugin which shows a git diff in the 'gutter' (sign
-column). It shows whether each line has been added, modified, and where lines
-have been removed.
-
-This is a port of the Git Gutter plugin for Sublime Text 2.
-
-===============================================================================
-2. INSTALLATION                                         *GitGutterInstallation*
-
-* Pathogen:
->
-  cd ~/.vim/bundle
-  git clone git://github.com/airblade/vim-gitgutter.git
-<
-* Voom:
-
-Edit your plugin manifest (`voom edit`) and add:
->
-  airblade/vim-gitgutter
-<
-* VimPlug:
-
-Place this in your .vimrc:
->
-    Plug 'airblade/vim-gitgutter'
-<
-Then run the following in Vim:
->
-  :source %
-  :PlugInstall
-<
-* NeoBundle:
-
-Place this in your .vimrc:
->
-  NeoBundle 'airblade/vim-gitgutter'
-<
-Then run the following in Vim:
->
-  :source %
-  :NeoBundleInstall
-<
-* No plugin manager:
-
-Copy vim-gitgutter's subdirectories into your vim configuration directory:
->
-  cd tmp && git clone git://github.com/airblade/vim-gitgutter.git
-  cp vim-gitgutter/* ~/.vim/
-<
-See |add-global-plugin|.
-
-===============================================================================
-3. USAGE                                                       *GitGutterUsage*
-
-You don't have to do anything: it just works.
-
-===============================================================================
-4. COMMANDS                                                 *GitGutterCommands*
-
-Commands for turning Git Gutter on and off:
-
-  :GitGutterDisable                                         *:GitGutterDisable*
-      Explicitly turn Git Gutter off.
-
-  :GitGutterEnable                                           *:GitGutterEnable*
-      Explicitly turn Git Gutter on.
-
-  :GitGutterToggle                                           *:GitGutterToggle*
-      Explicitly turn Git Gutter on if it was off and vice versa.
-
-  :GitGutter                                                       *:GitGutter*
-      Update signs for the current buffer.
-
-  :GitGutterAll                                                 *:GitGutterAll*
-      Update signs across all buffers.
-
-Commands for turning signs on and off (defaults to on):
-
-  :GitGutterSignsEnable                                 *:GitGutterSignsEnable*
-      Explicitly turn line signs on.
-
-  :GitGutterSignsDisable                               *:GitGutterSignsDisable*
-      Explicitly turn line signs off.
-
-  :GitGutterSignsToggle                                 *:GitGutterSignsToggle*
-      Explicitly turn line signs on if it was off and vice versa.
-
-Commands for turning line highlighting on and off (defaults to off):
-
-  :GitGutterLineHighlightsEnable               *:GitGutterLineHighlightsEnable*
-      Explicitly turn line highlighting on.
-
-  :GitGutterLineHighlightsDisable             *:GitGutterLineHighlightsDisable*
-      Explicitly turn line highlighting off.
-
-  :GitGutterLineHighlightsToggle               *:GitGutterLineHighlightsToggle*
-      Explicitly turn line highlighting on if it was off and vice versa.
-
-Commands for jumping between marked hunks:
-
-  :GitGutterNextHunk                                       *:GitGutterNextHunk*
-      Jump to the next marked hunk.  Takes a count.
-
-  :GitGutterPrevHunk                                       *:GitGutterPrevHunk*
-      Jump to the previous marked hunk.  Takes a count.
-
-Commands for staging or undoing individual hunks:
-
-  :GitGutterStageHunk                                     *:GitGutterStageHunk*
-      Stage the hunk the cursor is in.
-
-  :GitGutterUndoHunk                                       *:GitGutterUndoHunk*
-      Undo the hunk the cursor is in.
-
-  :GitGutterPreviewHunk                                 *:GitGutterPreviewHunk*
-      Preview the hunk the cursor is in.
-
-===============================================================================
-5. AUTOCOMMAND                                               *GitGutterAutocmd*
-
-After updating a buffer's signs vim-gitgutter fires a |User| |autocmd| with the
-event GitGutter.  You can listen for this event, for example:
->
-  autocmd User GitGutter call updateMyStatusLine()
-<
-
-===============================================================================
-6. CUSTOMISATION                                       *GitGutterCustomisation*
-
-You can customise:
-
-- The sign column's colours
-- The signs' colours and symbols
-- Line highlights
-- The base of the diff
-- Extra arguments for git-diff
-- Key mappings
-- The grep executable used
-- Whether or not vim-gitgutter is on initially (defaults to on)
-- Whether or not signs are shown (defaults to yes)
-- Whether or not line highlighting is on initially (defaults to off)
-- Whether or not vim-gitgutter runs in realtime (defaults to yes)
-- Whether or not vim-gitgutter runs eagerly (defaults to yes)
-- Whether or not vim-gitgutter runs asynchronously (defaults to yes)
-
-Please note that vim-gitgutter won't override any colours or highlights you've
-set in your colorscheme.
-
-SIGN COLUMN
-
-By default vim-gitgutter will make the sign column look like the line number
-column (i.e. the |hl-LineNr| highlight group).
-
-To customise your sign column's background color, first tell vim-gitgutter to
-leave it alone:
->
-  let g:gitgutter_override_sign_column_highlight = 0
-<
-
-And then either update your colorscheme's |hlSignColumn| highlight group or set
-it in your |vimrc|:
-
-  Desired appearance                  Command ~
-  Same as line number column          highlight clear SignColumn
-  User-defined (terminal Vim)         highlight SignColumn ctermbg={whatever}
-  User-defined (graphical Vim)        highlight SignColumn guibg={whatever}
-
-SIGNS' COLOURS AND SYMBOLS
-
-To customise the colours, set up the following highlight groups in your
-colorscheme or |vimrc|:
-
->
-  GitGutterAdd          " an added line
-  GitGutterChange       " a changed line
-  GitGutterDelete       " at least one removed line
-  GitGutterChangeDelete " a changed line followed by at least one removed line
-<
-
-You can either set these with `highlight GitGutterAdd {key}={arg}...` or link
-them to existing highlight groups with, say:
->
-  highlight link GitGutterAdd DiffAdd
-<
-
-To customise the symbols, add the following to your |vimrc|:
->
-  let g:gitgutter_sign_added = 'xx'
-  let g:gitgutter_sign_modified = 'yy'
-  let g:gitgutter_sign_removed = 'zz'
-  let g:gitgutter_sign_modified_removed = 'ww'
-<
-
-LINE HIGHLIGHTS
-
-Similarly to the signs' colours, set up the following highlight groups in your
-colorscheme or |vimrc|:
->
-  GitGutterAddLine          " default: links to DiffAdd
-  GitGutterChangeLine       " default: links to DiffChange
-  GitGutterDeleteLine       " default: links to DiffDelete
-  GitGutterChangeDeleteLine " default: links to GitGutterChangeLineDefault
-<
-
-THE BASE OF THE DIFF
-
-By default buffers are diffed against the index.  To diff against a commit
-instead:
->
-  let g:gitgutter_diff_base = '<commit SHA>'
-<
-
-EXTRA ARGUMENTS FOR GIT-DIFF
-
-To pass extra arguments to git-diff, add this to your |vimrc|:
->
-  let g:gitgutter_diff_args = '-w'
-<
-
-KEY MAPPINGS
-
-To disable all key maps:
->
-  let g:gitgutter_map_keys = 0
-<
-
-To change the hunk-jumping maps (defaults shown):
->
-  nmap [c <Plug>GitGutterPrevHunk
-  nmap ]c <Plug>GitGutterNextHunk
-<
-
-To change the hunk-staging/undoing/previewing maps (defaults shown):
->
-  nmap <Leader>hs <Plug>GitGutterStageHunk
-  nmap <Leader>hu <Plug>GitGutterUndoHunk
-  nmap <Leader>hp <Plug>GitGutterPreviewHunk
-<
-
-To change the hunk text object maps (defaults shown):
->
-  omap ic <Plug>GitGutterTextObjectInnerPending
-  omap ac <Plug>GitGutterTextObjectOuterPending
-  xmap ic <Plug>GitGutterTextObjectInnerVisual
-  xmap ac <Plug>GitGutterTextObjectOuterVisual
-<
-
-TO USE A CUSTOM GREP COMMAND
-
-To use a custom invocation for grep, use this:
->
-  let g:gitgutter_grep_command = 'grep --color=never -e'
-<
-
-TO TURN OFF VIM-GITGUTTER BY DEFAULT
-
-Add to your |vimrc|
->
-  let g:gitgutter_enabled = 0
-<
-
-TO TURN OFF SIGNS BY DEFAULT
-
-Add to your |vimrc|
->
-  let g:gitgutter_signs = 0
-<
-
-Note that the sign column will still be present if you have line highlighting
-switched on.
-
-TO TURN ON LINE HIGHLIGHTING BY DEFAULT
-
-Add to your |vimrc|
->
-  let g:gitgutter_highlight_lines = 1
-<
-
-TO STOP VIM-GITGUTTER RUNNING IN REALTIME
-
-Add to your |vimrc|
->
-  let g:gitgutter_realtime = 0
-<
-
-TO STOP VIM-GITGUTTER RUNNING EAGERLY
-
-Add to your |vimrc|
->
-  let g:gitgutter_eager = 0
-<
-
-TO TURN OFF ASYNCHRONOUS UPDATES
-
-By default diffs are run asynchronously.  To run diffs synchronously
-instead:
-
-Add to your |vimrc|
->
-let g:gitgutter_async = 0
-<
-
-===============================================================================
-7. FAQ                                                           *GitGutterFAQ*
-
-a. Why are the colours in the sign column weird?
-
-  Your colorscheme is configuring the |hl-SignColumn| highlight group weirdly.
-  Please see |GitGutterCustomisation| on customising the sign column.
-
-b. What happens if I also use another plugin which uses signs (e.g. Syntastic)?
-
-  Vim only allows one sign per line. Before adding a sign to a line,
-  vim-gitgutter checks whether a sign has already been added by somebody else.
-  If so it doesn't do anything. In other words vim-gitgutter won't overwrite
-  another plugin's signs. It also won't remove another plugin's signs.
diff --git a/vim/bundle/vim-gitgutter/plugin/gitgutter.vim b/vim/bundle/vim-gitgutter/plugin/gitgutter.vim
deleted file mode 100644
index ff87a0a..0000000
--- a/vim/bundle/vim-gitgutter/plugin/gitgutter.vim
+++ /dev/null
@@ -1,224 +0,0 @@
-scriptencoding utf-8
-
-if exists('g:loaded_gitgutter') || !has('signs') || &cp
-  finish
-endif
-let g:loaded_gitgutter = 1
-
-" Initialisation {{{
-
-" Realtime sign updates require Vim 7.3.105+.
-if v:version < 703 || (v:version == 703 && !has("patch105"))
-  let g:gitgutter_realtime = 0
-endif
-
-" Eager updates require gettabvar()/settabvar().
-if !exists("*gettabvar")
-  let g:gitgutter_eager = 0
-endif
-
-function! s:set(var, default) abort
-  if !exists(a:var)
-    if type(a:default)
-      execute 'let' a:var '=' string(a:default)
-    else
-      execute 'let' a:var '=' a:default
-    endif
-  endif
-endfunction
-
-call s:set('g:gitgutter_enabled',                     1)
-call s:set('g:gitgutter_max_signs',                 500)
-call s:set('g:gitgutter_signs',                       1)
-call s:set('g:gitgutter_highlight_lines',             0)
-call s:set('g:gitgutter_sign_column_always',          0)
-call s:set('g:gitgutter_override_sign_column_highlight', 1)
-call s:set('g:gitgutter_realtime',                    1)
-call s:set('g:gitgutter_eager',                       1)
-call s:set('g:gitgutter_sign_added',                '+')
-call s:set('g:gitgutter_sign_modified',             '~')
-call s:set('g:gitgutter_sign_removed',              '_')
-try
-  call s:set('g:gitgutter_sign_removed_first_line', '‾')
-catch /E239/
-  let g:gitgutter_sign_removed_first_line = '_^'
-endtry
-
-call s:set('g:gitgutter_sign_modified_removed',    '~_')
-call s:set('g:gitgutter_diff_args',                  '')
-call s:set('g:gitgutter_diff_base',                  '')
-call s:set('g:gitgutter_map_keys',                    1)
-call s:set('g:gitgutter_avoid_cmd_prompt_on_windows', 1)
-call s:set('g:gitgutter_async',                       1)
-call s:set('g:gitgutter_log',                         0)
-call s:set('g:gitgutter_git_executable',          'git')
-
-if !executable(g:gitgutter_git_executable)
-  call gitgutter#utility#warn('cannot find git. Please set g:gitgutter_git_executable.')
-endif
-
-call gitgutter#highlight#define_sign_column_highlight()
-call gitgutter#highlight#define_highlights()
-call gitgutter#highlight#define_signs()
-
-" }}}
-
-" Primary functions {{{
-
-command -bar GitGutterAll call gitgutter#all()
-command -bar GitGutter    call gitgutter#process_buffer(bufnr(''), 0)
-
-command -bar GitGutterDisable call gitgutter#disable()
-command -bar GitGutterEnable  call gitgutter#enable()
-command -bar GitGutterToggle  call gitgutter#toggle()
-
-" }}}
-
-" Line highlights {{{
-
-command -bar GitGutterLineHighlightsDisable call gitgutter#line_highlights_disable()
-command -bar GitGutterLineHighlightsEnable  call gitgutter#line_highlights_enable()
-command -bar GitGutterLineHighlightsToggle  call gitgutter#line_highlights_toggle()
-
-" }}}
-
-" Signs {{{
-
-command -bar GitGutterSignsEnable  call gitgutter#signs_enable()
-command -bar GitGutterSignsDisable call gitgutter#signs_disable()
-command -bar GitGutterSignsToggle  call gitgutter#signs_toggle()
-
-" }}}
-
-" Hunks {{{
-
-command -bar -count=1 GitGutterNextHunk call gitgutter#hunk#next_hunk(<count>)
-command -bar -count=1 GitGutterPrevHunk call gitgutter#hunk#prev_hunk(<count>)
-
-command -bar GitGutterStageHunk   call gitgutter#stage_hunk()
-command -bar GitGutterUndoHunk    call gitgutter#undo_hunk()
-command -bar GitGutterRevertHunk  echomsg 'GitGutterRevertHunk is deprecated. Use GitGutterUndoHunk'<Bar>call gitgutter#undo_hunk()
-command -bar GitGutterPreviewHunk call gitgutter#preview_hunk()
-
-" Hunk text object
-onoremap <silent> <Plug>GitGutterTextObjectInnerPending :<C-U>call gitgutter#hunk#text_object(1)<CR>
-onoremap <silent> <Plug>GitGutterTextObjectOuterPending :<C-U>call gitgutter#hunk#text_object(0)<CR>
-xnoremap <silent> <Plug>GitGutterTextObjectInnerVisual  :<C-U>call gitgutter#hunk#text_object(1)<CR>
-xnoremap <silent> <Plug>GitGutterTextObjectOuterVisual  :<C-U>call gitgutter#hunk#text_object(0)<CR>
-
-
-" Returns the git-diff hunks for the file or an empty list if there
-" aren't any hunks.
-"
-" The return value is a list of lists.  There is one inner list per hunk.
-"
-"   [
-"     [from_line, from_count, to_line, to_count],
-"     [from_line, from_count, to_line, to_count],
-"     ...
-"   ]
-"
-" where:
-"
-" `from`  - refers to the staged file
-" `to`    - refers to the working tree's file
-" `line`  - refers to the line number where the change starts
-" `count` - refers to the number of lines the change covers
-function! GitGutterGetHunks()
-  return gitgutter#utility#is_active() ? gitgutter#hunk#hunks() : []
-endfunction
-
-" Returns an array that contains a summary of the hunk status for the current
-" window.  The format is [ added, modified, removed ], where each value
-" represents the number of lines added/modified/removed respectively.
-function! GitGutterGetHunkSummary()
-  return gitgutter#hunk#summary(winbufnr(0))
-endfunction
-
-" }}}
-
-command -bar GitGutterDebug call gitgutter#debug#debug()
-
-" Maps {{{
-
-nnoremap <silent> <expr> <Plug>GitGutterNextHunk &diff ? ']c' : ":\<C-U>execute v:count1 . 'GitGutterNextHunk'\<CR>"
-nnoremap <silent> <expr> <Plug>GitGutterPrevHunk &diff ? '[c' : ":\<C-U>execute v:count1 . 'GitGutterPrevHunk'\<CR>"
-
-if g:gitgutter_map_keys
-  if !hasmapto('<Plug>GitGutterPrevHunk') && maparg('[c', 'n') ==# ''
-    nmap [c <Plug>GitGutterPrevHunk
-  endif
-  if !hasmapto('<Plug>GitGutterNextHunk') && maparg(']c', 'n') ==# ''
-    nmap ]c <Plug>GitGutterNextHunk
-  endif
-endif
-
-
-nnoremap <silent> <Plug>GitGutterStageHunk   :GitGutterStageHunk<CR>
-nnoremap <silent> <Plug>GitGutterUndoHunk    :GitGutterUndoHunk<CR>
-nnoremap <silent> <Plug>GitGutterPreviewHunk :GitGutterPreviewHunk<CR>
-
-if g:gitgutter_map_keys
-  if !hasmapto('<Plug>GitGutterStageHunk') && maparg('<Leader>hs', 'n') ==# ''
-    nmap <Leader>hs <Plug>GitGutterStageHunk
-  endif
-  if !hasmapto('<Plug>GitGutterUndoHunk') && maparg('<Leader>hu', 'n') ==# ''
-    nmap <Leader>hu <Plug>GitGutterUndoHunk
-    nmap <Leader>hr <Plug>GitGutterUndoHunk:echomsg '<Leader>hr is deprecated. Use <Leader>hu'<CR>
-  endif
-  if !hasmapto('<Plug>GitGutterPreviewHunk') && maparg('<Leader>hp', 'n') ==# ''
-    nmap <Leader>hp <Plug>GitGutterPreviewHunk
-  endif
-
-  if !hasmapto('<Plug>GitGutterTextObjectInnerPending') && maparg('ic', 'o') ==# ''
-    omap ic <Plug>GitGutterTextObjectInnerPending
-  endif
-  if !hasmapto('<Plug>GitGutterTextObjectOuterPending') && maparg('ac', 'o') ==# ''
-    omap ac <Plug>GitGutterTextObjectOuterPending
-  endif
-  if !hasmapto('<Plug>GitGutterTextObjectInnerVisual') && maparg('ic', 'x') ==# ''
-    xmap ic <Plug>GitGutterTextObjectInnerVisual
-  endif
-  if !hasmapto('<Plug>GitGutterTextObjectOuterVisual') && maparg('ac', 'x') ==# ''
-    xmap ac <Plug>GitGutterTextObjectOuterVisual
-  endif
-endif
-
-" }}}
-
-" Autocommands {{{
-
-augroup gitgutter
-  autocmd!
-
-  if g:gitgutter_realtime
-    autocmd CursorHold,CursorHoldI * call gitgutter#process_buffer(bufnr(''), 1)
-  endif
-
-  if g:gitgutter_eager
-    autocmd BufEnter,BufWritePost,FileChangedShellPost *
-          \  if gettabvar(tabpagenr(), 'gitgutter_didtabenter') |
-          \   call settabvar(tabpagenr(), 'gitgutter_didtabenter', 0) |
-          \ else |
-          \   call gitgutter#process_buffer(bufnr(''), 0) |
-          \ endif
-    autocmd TabEnter *
-          \  call settabvar(tabpagenr(), 'gitgutter_didtabenter', 1) |
-          \ call gitgutter#all()
-    if !has('gui_win32')
-      autocmd FocusGained * call gitgutter#all()
-    endif
-  else
-    autocmd BufRead,BufWritePost,FileChangedShellPost * call gitgutter#process_buffer(bufnr(''), 0)
-  endif
-
-  autocmd ColorScheme * call gitgutter#highlight#define_sign_column_highlight() | call gitgutter#highlight#define_highlights()
-
-  " Disable during :vimgrep
-  autocmd QuickFixCmdPre  *vimgrep* let g:gitgutter_enabled = 0
-  autocmd QuickFixCmdPost *vimgrep* let g:gitgutter_enabled = 1
-augroup END
-
-" }}}
-
-" vim:set et sw=2 fdm=marker:
diff --git a/vim/bundle/vim-gitgutter/screenshot.png b/vim/bundle/vim-gitgutter/screenshot.png
deleted file mode 100644
index 6b50f83..0000000
--- a/vim/bundle/vim-gitgutter/screenshot.png
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/=fixture=.txt b/vim/bundle/vim-gitgutter/test/=fixture=.txt
deleted file mode 100644
index e69de29..0000000
--- a/vim/bundle/vim-gitgutter/test/=fixture=.txt
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/README.markdown b/vim/bundle/vim-gitgutter/test/README.markdown
deleted file mode 100644
index 2be0c37..0000000
--- a/vim/bundle/vim-gitgutter/test/README.markdown
+++ /dev/null
@@ -1,30 +0,0 @@
-## Testing vim-gitgutter
-
-### Run the tests
-
-```sh
-$ cd test
-$ ./test
-```
-
-### Add a new test
-
-- Add a test file named like `testFoo.vim`.  It should have this structure:
-
-```viml
-source helper.vim
-call Setup()
-
-" test code here
-```
-
-- Run the tests.
-- Inspect output (in `foo.actual`) from the new test.  If good, copy it to `foo.expected`.
-- Run the tests to ensure new test's output is verified.
-- Commit changes.
-
-### Limitations
-
-- Currently tests are done by writing out a file and comparing it to a known good one.
-- There's no support for assertions within the testcase code.
-
diff --git a/vim/bundle/vim-gitgutter/test/addLines.expected b/vim/bundle/vim-gitgutter/test/addLines.expected
deleted file mode 100644
index 8e2c2ec..0000000
--- a/vim/bundle/vim-gitgutter/test/addLines.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=2  id=3000  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/addLinesFish.expected b/vim/bundle/vim-gitgutter/test/addLinesFish.expected
deleted file mode 100644
index 8e2c2ec..0000000
--- a/vim/bundle/vim-gitgutter/test/addLinesFish.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=2  id=3000  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/ambiguousFile.expected b/vim/bundle/vim-gitgutter/test/ambiguousFile.expected
deleted file mode 100644
index 1cd4e89..0000000
--- a/vim/bundle/vim-gitgutter/test/ambiguousFile.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=5  id=3000  name=GitGutterLineModified
diff --git a/vim/bundle/vim-gitgutter/test/fileAddedToGit.expected b/vim/bundle/vim-gitgutter/test/fileAddedToGit.expected
deleted file mode 100644
index bfd8eeb..0000000
--- a/vim/bundle/vim-gitgutter/test/fileAddedToGit.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fileAddedToGit.tmp:
-    line=1  id=3000  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/filenameWithEquals.expected b/vim/bundle/vim-gitgutter/test/filenameWithEquals.expected
deleted file mode 100644
index a78b977..0000000
--- a/vim/bundle/vim-gitgutter/test/filenameWithEquals.expected
+++ /dev/null
@@ -1,5 +0,0 @@
-
---- Signs ---
-Signs for =fixture=.txt:
-    line=1  id=3000  name=GitGutterLineAdded
-    line=2  id=3001  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/filenameWithSquareBrackets.expected b/vim/bundle/vim-gitgutter/test/filenameWithSquareBrackets.expected
deleted file mode 100644
index 18f3022..0000000
--- a/vim/bundle/vim-gitgutter/test/filenameWithSquareBrackets.expected
+++ /dev/null
@@ -1,5 +0,0 @@
-
---- Signs ---
-Signs for fix[tu]re.txt:
-    line=1  id=3000  name=GitGutterLineAdded
-    line=2  id=3001  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/fix[tu]re.txt b/vim/bundle/vim-gitgutter/test/fix[tu]re.txt
deleted file mode 100644
index e69de29..0000000
--- a/vim/bundle/vim-gitgutter/test/fix[tu]re.txt
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/fixture.txt b/vim/bundle/vim-gitgutter/test/fixture.txt
deleted file mode 100644
index f5c6aff..0000000
--- a/vim/bundle/vim-gitgutter/test/fixture.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-a
-b
-c
-d
-e
-f
-g
-h
-i
-j
-
diff --git a/vim/bundle/vim-gitgutter/test/followSymlink.expected b/vim/bundle/vim-gitgutter/test/followSymlink.expected
deleted file mode 100644
index 8f8fb4a..0000000
--- a/vim/bundle/vim-gitgutter/test/followSymlink.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for symlink:
-    line=5  id=3000  name=GitGutterLineRemoved
diff --git a/vim/bundle/vim-gitgutter/test/helper.vim b/vim/bundle/vim-gitgutter/test/helper.vim
deleted file mode 100644
index aaccf39..0000000
--- a/vim/bundle/vim-gitgutter/test/helper.vim
+++ /dev/null
@@ -1,27 +0,0 @@
-set runtimepath+=../
-source ../plugin/gitgutter.vim
-
-function! Setup()
-  edit! fixture.txt
-  sign unplace *
-endfunction
-
-function! DumpSigns(filename)
-  execute 'redir! > ' a:filename.'.actual'
-    silent execute 'sign place'
-  redir END
-endfunction
-
-function! DumpGitDiff(filename)
-  call system('git diff fixture.txt > '.a:filename.'.actual')
-endfunction
-
-function! DumpGitDiffStaged(filename)
-  call system('git diff --staged fixture.txt > '.a:filename.'.actual')
-endfunction
-
-function! Dump(text, filename)
-  let msg = type(a:text) == 1 ? split(a:text, '\n') : a:text
-  call writefile(msg, a:filename.'.actual', 'a')
-endfunction
-
diff --git a/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopStageGitDiffStaged.expected b/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopStageGitDiffStaged.expected
deleted file mode 100644
index e69de29..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopStageGitDiffStaged.expected
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopUndoGitDiffStaged.expected b/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopUndoGitDiffStaged.expected
deleted file mode 100644
index e69de29..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkHunkOutsideNoopUndoGitDiffStaged.expected
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/hunkOutsideNoopStageSigns.expected b/vim/bundle/vim-gitgutter/test/hunkOutsideNoopStageSigns.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkOutsideNoopStageSigns.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/hunkOutsideNoopUndoSigns.expected b/vim/bundle/vim-gitgutter/test/hunkOutsideNoopUndoSigns.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkOutsideNoopUndoSigns.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/hunkStageGitDiff.expected b/vim/bundle/vim-gitgutter/test/hunkStageGitDiff.expected
deleted file mode 100644
index 6f6a7fa..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkStageGitDiff.expected
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/test/fixture.txt b/test/fixture.txt
-index f5c6aff..ae8e546 100644
---- a/test/fixture.txt
-+++ b/test/fixture.txt
-@@ -2,7 +2,7 @@ a
- b
- c
- d
--e
-+*e
- f
- g
- h
diff --git a/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiff.expected b/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiff.expected
deleted file mode 100644
index 6a0b7f0..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiff.expected
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/test/fixture.txt b/test/fixture.txt
-index 53b13df..8fdfda7 100644
---- a/test/fixture.txt
-+++ b/test/fixture.txt
-@@ -1,5 +1,8 @@
- a
- b
-+x
-+y
-+z
- c
- e
- f
diff --git a/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiffStaged.expected b/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiffStaged.expected
deleted file mode 100644
index 8806576..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkStageNearbyGitDiffStaged.expected
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/test/fixture.txt b/test/fixture.txt
-index f5c6aff..53b13df 100644
---- a/test/fixture.txt
-+++ b/test/fixture.txt
-@@ -1,7 +1,6 @@
- a
- b
- c
--d
- e
- f
- g
diff --git a/vim/bundle/vim-gitgutter/test/hunkStageNearbySigns.expected b/vim/bundle/vim-gitgutter/test/hunkStageNearbySigns.expected
deleted file mode 100644
index edfebd2..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkStageNearbySigns.expected
+++ /dev/null
@@ -1,6 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=3  id=3000  name=GitGutterLineAdded
-    line=4  id=3001  name=GitGutterLineAdded
-    line=5  id=3002  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/hunkStageSigns.expected b/vim/bundle/vim-gitgutter/test/hunkStageSigns.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkStageSigns.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/hunkUndoGitDiff.expected b/vim/bundle/vim-gitgutter/test/hunkUndoGitDiff.expected
deleted file mode 100644
index e69de29..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkUndoGitDiff.expected
+++ /dev/null
diff --git a/vim/bundle/vim-gitgutter/test/hunkUndoNearbyGitDiff.expected b/vim/bundle/vim-gitgutter/test/hunkUndoNearbyGitDiff.expected
deleted file mode 100644
index d480c7b..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkUndoNearbyGitDiff.expected
+++ /dev/null
@@ -1,13 +0,0 @@
-diff --git a/test/fixture.txt b/test/fixture.txt
-index f5c6aff..3fbde56 100644
---- a/test/fixture.txt
-+++ b/test/fixture.txt
-@@ -1,5 +1,8 @@
- a
- b
-+x
-+y
-+z
- c
- d
- e
diff --git a/vim/bundle/vim-gitgutter/test/hunkUndoNearbySigns.expected b/vim/bundle/vim-gitgutter/test/hunkUndoNearbySigns.expected
deleted file mode 100644
index edfebd2..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkUndoNearbySigns.expected
+++ /dev/null
@@ -1,6 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=3  id=3000  name=GitGutterLineAdded
-    line=4  id=3001  name=GitGutterLineAdded
-    line=5  id=3002  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/hunkUndoSigns.expected b/vim/bundle/vim-gitgutter/test/hunkUndoSigns.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/hunkUndoSigns.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/keepAlt.expected b/vim/bundle/vim-gitgutter/test/keepAlt.expected
deleted file mode 100644
index feee7b5..0000000
--- a/vim/bundle/vim-gitgutter/test/keepAlt.expected
+++ /dev/null
@@ -1,3 +0,0 @@
-buffer: fixture.txt
-altbuffer: 
-altbuffer: 
diff --git a/vim/bundle/vim-gitgutter/test/keepModified.expected b/vim/bundle/vim-gitgutter/test/keepModified.expected
deleted file mode 100644
index 57a1bbf..0000000
--- a/vim/bundle/vim-gitgutter/test/keepModified.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-modified: 1
-modified: 1
diff --git a/vim/bundle/vim-gitgutter/test/keepOpMarks.expected b/vim/bundle/vim-gitgutter/test/keepOpMarks.expected
deleted file mode 100644
index ed6b8c3..0000000
--- a/vim/bundle/vim-gitgutter/test/keepOpMarks.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-'[ mark: 0,6,1,0
-'] mark: 0,6,2,0
-'[ mark: 0,6,1,0
-'] mark: 0,6,2,0
diff --git a/vim/bundle/vim-gitgutter/test/modifyLines.expected b/vim/bundle/vim-gitgutter/test/modifyLines.expected
deleted file mode 100644
index 91ad42c..0000000
--- a/vim/bundle/vim-gitgutter/test/modifyLines.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=1  id=3000  name=GitGutterLineModified
diff --git a/vim/bundle/vim-gitgutter/test/noModifications.expected b/vim/bundle/vim-gitgutter/test/noModifications.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/noModifications.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/orphanedSigns.expected b/vim/bundle/vim-gitgutter/test/orphanedSigns.expected
deleted file mode 100644
index 1beeb65..0000000
--- a/vim/bundle/vim-gitgutter/test/orphanedSigns.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=6  id=3001  name=GitGutterLineAdded
diff --git a/vim/bundle/vim-gitgutter/test/removeFirstLines.expected b/vim/bundle/vim-gitgutter/test/removeFirstLines.expected
deleted file mode 100644
index 1cbfd76..0000000
--- a/vim/bundle/vim-gitgutter/test/removeFirstLines.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=1  id=3000  name=GitGutterLineRemovedFirstLine
diff --git a/vim/bundle/vim-gitgutter/test/removeLines.expected b/vim/bundle/vim-gitgutter/test/removeLines.expected
deleted file mode 100644
index 94d8ee4..0000000
--- a/vim/bundle/vim-gitgutter/test/removeLines.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=4  id=3000  name=GitGutterLineRemoved
diff --git a/vim/bundle/vim-gitgutter/test/signColumnAlways.expected b/vim/bundle/vim-gitgutter/test/signColumnAlways.expected
deleted file mode 100644
index aeda456..0000000
--- a/vim/bundle/vim-gitgutter/test/signColumnAlways.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-
---- Signs ---
-Signs for fixture.txt:
-    line=9999  id=2999  name=GitGutterDummy
diff --git a/vim/bundle/vim-gitgutter/test/test b/vim/bundle/vim-gitgutter/test/test
deleted file mode 100755
index 5c2d877..0000000
--- a/vim/bundle/vim-gitgutter/test/test
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-
-VIM="/Applications/MacVim.app/Contents/MacOS/Vim -v"
-
-status=0
-
-# Execute the tests.
-for editor in "$VIM" nvim; do
-
-  for testcase in test*.vim; do
-    $editor -N -u NONE --cmd 'let g:gitgutter_async=0' -S $testcase -c 'quit!'
-
-    git reset HEAD fixture.txt > /dev/null
-    git checkout fixture.txt
-  done
-
-  # Verify the results.
-  echo "$editor:"
-  echo
-
-  count_ok=0
-  count_fail=0
-
-  for expected in *.expected; do
-    name=${expected%.*}
-    actual=$name.actual
-
-    if diff $expected $actual; then
-      count_ok=$((count_ok + 1))
-      echo "$name ok"
-      rm $actual
-    else
-      count_fail=$((count_fail + 1))
-      echo "$name failed"
-    fi
-  done
-
-  # Print results.
-  echo
-  echo "$((count_ok + count_fail)) tests"
-  echo "$count_ok ok"
-  echo "$count_fail failed"
-  echo
-
-  status=$(($status + $count_fail))
-
-done
-
-exit $status
-
diff --git a/vim/bundle/vim-gitgutter/test/testAddLines.vim b/vim/bundle/vim-gitgutter/test/testAddLines.vim
deleted file mode 100644
index 6b0ec4a..0000000
--- a/vim/bundle/vim-gitgutter/test/testAddLines.vim
+++ /dev/null
@@ -1,6 +0,0 @@
-source helper.vim
-call Setup()
-
-normal ggo*
-write
-call DumpSigns('addLines')
diff --git a/vim/bundle/vim-gitgutter/test/testAddLinesFish.vim b/vim/bundle/vim-gitgutter/test/testAddLinesFish.vim
deleted file mode 100644
index f1c6bab..0000000
--- a/vim/bundle/vim-gitgutter/test/testAddLinesFish.vim
+++ /dev/null
@@ -1,7 +0,0 @@
-set shell=/usr/local/bin/fish
-source helper.vim
-call Setup()
-
-normal ggo*
-write
-call DumpSigns('addLinesFish')
diff --git a/vim/bundle/vim-gitgutter/test/testEditAmbiguousFile.vim b/vim/bundle/vim-gitgutter/test/testEditAmbiguousFile.vim
deleted file mode 100644
index 693ecf7..0000000
--- a/vim/bundle/vim-gitgutter/test/testEditAmbiguousFile.vim
+++ /dev/null
@@ -1,9 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5Gi*
-call system('git checkout -b fixture.txt')
-write
-call DumpSigns('ambiguousFile')
-
-call system('git checkout - && git branch -d fixture.txt')
diff --git a/vim/bundle/vim-gitgutter/test/testFileAddedToGit.vim b/vim/bundle/vim-gitgutter/test/testFileAddedToGit.vim
deleted file mode 100644
index 91a2c14..0000000
--- a/vim/bundle/vim-gitgutter/test/testFileAddedToGit.vim
+++ /dev/null
@@ -1,12 +0,0 @@
-source helper.vim
-
-let tmpfile = 'fileAddedToGit.tmp'
-call system('touch '.tmpfile)
-call system('git add '.tmpfile)
-execute 'edit '.tmpfile
-normal ihello
-write
-call DumpSigns('fileAddedToGit')
-
-call system('git reset HEAD '.tmpfile)
-call system('rm '.tmpfile)
diff --git a/vim/bundle/vim-gitgutter/test/testFilenameWithEquals.vim b/vim/bundle/vim-gitgutter/test/testFilenameWithEquals.vim
deleted file mode 100644
index 082ff02..0000000
--- a/vim/bundle/vim-gitgutter/test/testFilenameWithEquals.vim
+++ /dev/null
@@ -1,12 +0,0 @@
-source helper.vim
-
-edit =fixture=.txt
-normal ggo*
-try
-  write
-  write
-  call DumpSigns('filenameWithEquals')
-finally
-  call system('git reset HEAD =fixture=.txt')
-  call system('git checkout =fixture=.txt')
-endtry
diff --git a/vim/bundle/vim-gitgutter/test/testFilenameWithSquareBrackets.vim b/vim/bundle/vim-gitgutter/test/testFilenameWithSquareBrackets.vim
deleted file mode 100644
index 85ae889..0000000
--- a/vim/bundle/vim-gitgutter/test/testFilenameWithSquareBrackets.vim
+++ /dev/null
@@ -1,9 +0,0 @@
-source helper.vim
-
-edit fix[tu]re.txt
-normal ggo*
-write
-call DumpSigns('filenameWithSquareBrackets')
-
-call system('git reset HEAD fix[tu]re.txt')
-call system('git checkout fix[tu]re.txt')
diff --git a/vim/bundle/vim-gitgutter/test/testFollowSymlink.vim b/vim/bundle/vim-gitgutter/test/testFollowSymlink.vim
deleted file mode 100644
index fda33ec..0000000
--- a/vim/bundle/vim-gitgutter/test/testFollowSymlink.vim
+++ /dev/null
@@ -1,10 +0,0 @@
-source helper.vim
-
-let tmpfile = 'symlink'
-call system('ln -nfs fixture.txt '.tmpfile)
-execute 'edit '.tmpfile
-execute '6d'
-write
-call DumpSigns('followSymlink')
-
-call system('rm '.tmpfile)
diff --git a/vim/bundle/vim-gitgutter/test/testHunkOutsideNoop.vim b/vim/bundle/vim-gitgutter/test/testHunkOutsideNoop.vim
deleted file mode 100644
index 6601e6d..0000000
--- a/vim/bundle/vim-gitgutter/test/testHunkOutsideNoop.vim
+++ /dev/null
@@ -1,13 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5G
-
-execute 'GitGutterStageHunk'
-call DumpSigns('hunkOutsideNoopStageSigns')
-call DumpGitDiffStaged('hunkHunkOutsideNoopStageGitDiffStaged')
-
-execute 'GitGutterUndoHunk'
-call DumpSigns('hunkOutsideNoopUndoSigns')
-call DumpGitDiffStaged('hunkHunkOutsideNoopUndoGitDiffStaged')
-
diff --git a/vim/bundle/vim-gitgutter/test/testHunkStage.vim b/vim/bundle/vim-gitgutter/test/testHunkStage.vim
deleted file mode 100644
index 6f818fb..0000000
--- a/vim/bundle/vim-gitgutter/test/testHunkStage.vim
+++ /dev/null
@@ -1,7 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5Gi*
-execute 'GitGutterStageHunk'
-call DumpSigns('hunkStageSigns')
-call DumpGitDiffStaged('hunkStageGitDiff')
diff --git a/vim/bundle/vim-gitgutter/test/testHunkStageNearbyHunk.vim b/vim/bundle/vim-gitgutter/test/testHunkStageNearbyHunk.vim
deleted file mode 100644
index 9939103..0000000
--- a/vim/bundle/vim-gitgutter/test/testHunkStageNearbyHunk.vim
+++ /dev/null
@@ -1,10 +0,0 @@
-source helper.vim
-call Setup()
-
-execute "normal! 2Gox\<CR>y\<CR>z"
-normal 2jdd
-normal k
-execute 'GitGutterStageHunk'
-call DumpSigns('hunkStageNearbySigns')
-call DumpGitDiff('hunkStageNearbyGitDiff')
-call DumpGitDiffStaged('hunkStageNearbyGitDiffStaged')
diff --git a/vim/bundle/vim-gitgutter/test/testHunkUndo.vim b/vim/bundle/vim-gitgutter/test/testHunkUndo.vim
deleted file mode 100644
index 9d187a7..0000000
--- a/vim/bundle/vim-gitgutter/test/testHunkUndo.vim
+++ /dev/null
@@ -1,7 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5Gi*
-execute 'GitGutterUndoHunk'
-call DumpSigns('hunkUndoSigns')
-call DumpGitDiffStaged('hunkUndoGitDiff')
diff --git a/vim/bundle/vim-gitgutter/test/testHunkUndoNearbyHunk.vim b/vim/bundle/vim-gitgutter/test/testHunkUndoNearbyHunk.vim
deleted file mode 100644
index 5721f2d..0000000
--- a/vim/bundle/vim-gitgutter/test/testHunkUndoNearbyHunk.vim
+++ /dev/null
@@ -1,9 +0,0 @@
-source helper.vim
-call Setup()
-
-execute "normal! 2Gox\<CR>y\<CR>z"
-normal 2jdd
-normal k
-execute 'GitGutterUndoHunk'
-call DumpSigns('hunkUndoNearbySigns')
-call DumpGitDiff('hunkUndoNearbyGitDiff')
diff --git a/vim/bundle/vim-gitgutter/test/testKeepAlt.vim b/vim/bundle/vim-gitgutter/test/testKeepAlt.vim
deleted file mode 100644
index 303ff0f..0000000
--- a/vim/bundle/vim-gitgutter/test/testKeepAlt.vim
+++ /dev/null
@@ -1,12 +0,0 @@
-source helper.vim
-call Setup()
-
-enew
-execute "normal! \<C-^>"
-call Dump('buffer: '.bufname(''), 'keepAlt')
-call Dump('altbuffer: '.bufname('#'), 'keepAlt')
-
-normal ggx
-doautocmd CursorHold
-call Dump('altbuffer: '.bufname('#'), 'keepAlt')
-
diff --git a/vim/bundle/vim-gitgutter/test/testKeepModified.vim b/vim/bundle/vim-gitgutter/test/testKeepModified.vim
deleted file mode 100644
index acb687f..0000000
--- a/vim/bundle/vim-gitgutter/test/testKeepModified.vim
+++ /dev/null
@@ -1,8 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5Go*
-call Dump("modified: ".getbufvar('', '&modified'), 'keepModified')
-doautocmd CursorHold
-call Dump("modified: ".getbufvar('', '&modified'), 'keepModified')
-
diff --git a/vim/bundle/vim-gitgutter/test/testKeepOpMarks.vim b/vim/bundle/vim-gitgutter/test/testKeepOpMarks.vim
deleted file mode 100644
index 1175c80..0000000
--- a/vim/bundle/vim-gitgutter/test/testKeepOpMarks.vim
+++ /dev/null
@@ -1,10 +0,0 @@
-source helper.vim
-call Setup()
-
-normal 5Go*
-call Dump("'[ mark: ".join(getpos("'["), ','), 'keepOpMarks')
-call Dump("'] mark: ".join(getpos("']"), ','), 'keepOpMarks')
-doautocmd CursorHold
-call Dump("'[ mark: ".join(getpos("'["), ','), 'keepOpMarks')
-call Dump("'] mark: ".join(getpos("']"), ','), 'keepOpMarks')
-
diff --git a/vim/bundle/vim-gitgutter/test/testModifyLines.vim b/vim/bundle/vim-gitgutter/test/testModifyLines.vim
deleted file mode 100644
index d4a3d01..0000000
--- a/vim/bundle/vim-gitgutter/test/testModifyLines.vim
+++ /dev/null
@@ -1,6 +0,0 @@
-source helper.vim
-call Setup()
-
-normal ggi*
-write
-call DumpSigns('modifyLines')
diff --git a/vim/bundle/vim-gitgutter/test/testNoModifications.vim b/vim/bundle/vim-gitgutter/test/testNoModifications.vim
deleted file mode 100644
index 909639f..0000000
--- a/vim/bundle/vim-gitgutter/test/testNoModifications.vim
+++ /dev/null
@@ -1,4 +0,0 @@
-source helper.vim
-call Setup()
-
-call DumpSigns('noModifications')
diff --git a/vim/bundle/vim-gitgutter/test/testOrphanedSigns.vim b/vim/bundle/vim-gitgutter/test/testOrphanedSigns.vim
deleted file mode 100644
index 35992d2..0000000
--- a/vim/bundle/vim-gitgutter/test/testOrphanedSigns.vim
+++ /dev/null
@@ -1,8 +0,0 @@
-source helper.vim
-call Setup()
-
-execute "normal 5GoX\<CR>Y"
-write
-execute '6d'
-write
-call DumpSigns('orphanedSigns')
diff --git a/vim/bundle/vim-gitgutter/test/testRemoveFirstLines.vim b/vim/bundle/vim-gitgutter/test/testRemoveFirstLines.vim
deleted file mode 100644
index 4a29a73..0000000
--- a/vim/bundle/vim-gitgutter/test/testRemoveFirstLines.vim
+++ /dev/null
@@ -1,6 +0,0 @@
-source helper.vim
-call Setup()
-
-execute '1d'
-write
-call DumpSigns('removeFirstLines')
diff --git a/vim/bundle/vim-gitgutter/test/testRemoveLines.vim b/vim/bundle/vim-gitgutter/test/testRemoveLines.vim
deleted file mode 100644
index 23d672b..0000000
--- a/vim/bundle/vim-gitgutter/test/testRemoveLines.vim
+++ /dev/null
@@ -1,6 +0,0 @@
-source helper.vim
-call Setup()
-
-execute '5d'
-write
-call DumpSigns('removeLines')
diff --git a/vim/bundle/vim-gitgutter/test/testSignColumnAlways.vim b/vim/bundle/vim-gitgutter/test/testSignColumnAlways.vim
deleted file mode 100644
index ff3eb94..0000000
--- a/vim/bundle/vim-gitgutter/test/testSignColumnAlways.vim
+++ /dev/null
@@ -1,7 +0,0 @@
-source helper.vim
-call Setup()
-
-let g:gitgutter_sign_column_always=1
-write
-
-call DumpSigns('signColumnAlways')
diff --git a/vim/bundle/vim-gitgutter/test/testUntrackedFileOutsideRepo.vim b/vim/bundle/vim-gitgutter/test/testUntrackedFileOutsideRepo.vim
deleted file mode 100644
index f473d35..0000000
--- a/vim/bundle/vim-gitgutter/test/testUntrackedFileOutsideRepo.vim
+++ /dev/null
@@ -1,6 +0,0 @@
-source helper.vim
-
-let tmpfile = tempname()
-call system('touch '.tmpfile)
-execute 'edit '.tmpfile
-call DumpSigns('untrackedFileOutsideRepo')
diff --git a/vim/bundle/vim-gitgutter/test/testUntrackedFileSquareBracketsWithinRepo.vim b/vim/bundle/vim-gitgutter/test/testUntrackedFileSquareBracketsWithinRepo.vim
deleted file mode 100644
index b1fd48a..0000000
--- a/vim/bundle/vim-gitgutter/test/testUntrackedFileSquareBracketsWithinRepo.vim
+++ /dev/null
@@ -1,10 +0,0 @@
-source helper.vim
-
-let tmpfile = '[un]trackedFileWithinRepo.tmp'
-call system('touch '.tmpfile)
-execute 'edit '.tmpfile
-normal ggo*
-doautocmd CursorHold
-call DumpSigns('untrackedFileSquareBracketsWithinRepo')
-
-call system('rm '.tmpfile)
diff --git a/vim/bundle/vim-gitgutter/test/testUntrackedFileWithinRepo.vim b/vim/bundle/vim-gitgutter/test/testUntrackedFileWithinRepo.vim
deleted file mode 100644
index 4fdd48e..0000000
--- a/vim/bundle/vim-gitgutter/test/testUntrackedFileWithinRepo.vim
+++ /dev/null
@@ -1,10 +0,0 @@
-source helper.vim
-
-let tmpfile = 'untrackedFileWithinRepo.tmp'
-call system('touch '.tmpfile)
-execute 'edit '.tmpfile
-normal ggo*
-doautocmd CursorHold
-call DumpSigns('untrackedFileWithinRepo')
-
-call system('rm '.tmpfile)
diff --git a/vim/bundle/vim-gitgutter/test/untrackedFileOutsideRepo.expected b/vim/bundle/vim-gitgutter/test/untrackedFileOutsideRepo.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/untrackedFileOutsideRepo.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/untrackedFileSquareBracketsWithinRepo.expected b/vim/bundle/vim-gitgutter/test/untrackedFileSquareBracketsWithinRepo.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/untrackedFileSquareBracketsWithinRepo.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---
diff --git a/vim/bundle/vim-gitgutter/test/untrackedFileWithinRepo.expected b/vim/bundle/vim-gitgutter/test/untrackedFileWithinRepo.expected
deleted file mode 100644
index aa8cd86..0000000
--- a/vim/bundle/vim-gitgutter/test/untrackedFileWithinRepo.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-
---- Signs ---