Add packed-ref handling

.gitattributes

@@ -1,2 +0,0 @@
-.git* export-ignore
-*.markdown export-ignore

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: tpope
-custom: ["https://www.paypal.me/vimpope"]

CONTRIBUTING.markdown

@@ -8,14 +8,8 @@ platform issues, and interactions with other plugins.  I end up bisecting a
 lot more than other projects, and thus I'm especially meticulous here about
 maintaining a clean, readable, history.  Squash and force push any requested
 changes to a pull request.  And if your [commit message
-sucks](https://commit.style), I'm not going to accept it.  Period.
+sucks](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html),
-
+I'm not going to accept it.  Period.
-If your contribution involves adding a configuration option, you are going to
-need a very compelling justification for it.  Options add a maintenance
-burden, support burden, and documentation bloat, and oftentimes can be
-achieved much more simply with a custom map or autocommand.  If your option
-controls an underlying Git command, ask yourself why Git itself does not offer
-such configuration.
 
 Beyond that, don't be shy about asking before patching.  What takes you hours
 might take me minutes simply because I have both domain knowledge and a

README.markdown

@@ -1,80 +1,49 @@
 # fugitive.vim
 
-Fugitive is the premier Vim plugin for Git.  Or maybe it's the premier Git
+I'm not going to lie to you; fugitive.vim may very well be the best
-plugin for Vim?  Either way, it's "so awesome, it should be illegal".  That's
+Git wrapper of all time.  Check out these features:
-why it's called Fugitive.
 
-The crown jewel of Fugitive is `:Git` (or just `:G`), which calls any
+View any blob, tree, commit, or tag in the repository with `:Gedit` (and
-arbitrary Git command.  If you know how to use Git at the command line, you
+`:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
-know how to use `:Git`.  It's vaguely akin to `:!git` but with numerous
+write to it to stage the changes.  Use `:Gdiff` to bring up the staged
-improvements:
+version of the file side by side with the working tree version and use
+Vim's diff handling capabilities to stage a subset of the file's
+changes.
 
-* The default behavior is to directly echo the command's output.  Quiet
+Bring up the output of `git status` with `:Gstatus`.  Press `-` to
-  commands like `:Git add` avoid the dreaded "Press ENTER or type command to
+`add`/`reset` a file's changes, or `p` to `add`/`reset` `--patch`.  And guess
-  continue" prompt.
+what `:Gcommit` does!
-* `:Git commit`, `:Git rebase -i`, and other commands that invoke an editor do
-  their editing in the current Vim instance.
-* `:Git diff`, `:Git log`, and other verbose, paginated commands have their
-  output loaded into a temporary buffer.  Force this behavior for any command
-  with `:Git --paginate` or `:Git -p`.
-* `:Git blame` uses a temporary buffer with maps for additional triage.  Press
-  enter on a line to view the commit where the line changed, or `g?` to see
-  other available maps.  Omit the filename argument and the currently edited
-  file will be blamed in a vertical, scroll-bound split.
-* `:Git mergetool` and `:Git difftool` load their changesets into the quickfix
-  list.
-* Called with no arguments, `:Git` opens a summary window with dirty files and
-  unpushed and unpulled commits.  Press `g?` to bring up a list of maps for
-  numerous operations including diffing, staging, committing, rebasing, and
-  stashing.  (This is the successor to the old `:Gstatus`.)
-* This command (along with all other commands) always uses the current
-  buffer's repository, so you don't need to worry about the current working
-  directory.
 
-Additional commands are provided for higher level operations:
+`:Gblame` brings up an interactive vertical split with `git blame`
+output.  Press enter on a line to edit the commit where the line
+changed, or `o` to open it in a split.  When you're done, use `:Gedit`
+in the historic buffer to go back to the work tree version.
 
-* View any blob, tree, commit, or tag in the repository with `:Gedit` (and
+`:Gmove` does a `git mv` on a file and simultaneously renames the
-  `:Gsplit`, etc.).  For example, `:Gedit HEAD~3:%` loads the current file as
+buffer.  `:Gremove` does a `git rm` on a file and simultaneously deletes
-  it existed 3 commits ago.
+the buffer.
-* `:Gdiffsplit` (or `:Gvdiffsplit`) brings up the staged version of the file
+
-  side by side with the working tree version.  Use Vim's diff handling
+Use `:Ggrep` to search the work tree (or any arbitrary commit) with
-  capabilities to apply changes to the staged version, and write that buffer
+`git grep`, skipping over that which is not tracked in the repository.
-  to stage the changes.  You can also give an arbitrary `:Gedit` argument to
+`:Glog` loads all previous revisions of a file into the quickfix list so
-  diff against older versions of the file.
+you can iterate over them and watch the file evolve!
-* `:Gread` is a variant of `git checkout -- filename` that operates on the
+
-  buffer rather than the file itself.  This means you can use `u` to undo it
+`:Gread` is a variant of `git checkout -- filename` that operates on the
+buffer rather than the filename.  This means you can use `u` to undo it
 and you never get any warnings about the file changing outside Vim.
-* `:Gwrite` writes to both the work tree and index versions of a file, making
+`:Gwrite` writes to both the work tree and index versions of a file,
-  it like `git add` when called from a work tree file and like `git checkout`
+making it like `git add` when called from a work tree file and like
-  when called from the index or a blob in history.
+`git checkout` when called from the index or a blob in history.
-* `:Ggrep` is `:grep` for `git grep`.  `:Glgrep` is `:lgrep` for the same.
-* `:GMove` does a `git mv` on the current file and changes the buffer name to
-  match.  `:GRename` does the same with a destination filename relative to the
-  current file's directory.
-* `:GDelete` does a `git rm` on the current file and simultaneously deletes
-  the buffer.  `:GRemove` does the same but leaves the (now empty) buffer
-  open.
-* `:GBrowse` to open the current file on the web front-end of your favorite
-  hosting provider, with optional line range (try it in visual mode).  Plugins
-  are available for popular providers such as [GitHub][rhubarb.vim],
-  [GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim],
-  [Gitee][fugitive-gitee.vim], [Pagure][pagure],
-  [Phabricator][vim-phabricator], [Azure DevOps][fugitive-azure-devops.vim],
-  and [sourcehut][srht.vim].
 
-[rhubarb.vim]: https://github.com/tpope/vim-rhubarb
+Use `:Gbrowse` to open the current file on GitHub, with optional line
-[fugitive-gitlab.vim]: https://github.com/shumphrey/fugitive-gitlab.vim
+range (try it in visual mode!).  If your current repository isn't on
-[fubitive.vim]: https://github.com/tommcdo/vim-fubitive
+GitHub, `git instaweb` will be spun up instead.
-[fugitive-gitee.vim]: https://github.com/linuxsuren/fugitive-gitee.vim
-[pagure]: https://github.com/FrostyX/vim-fugitive-pagure
-[vim-phabricator]: https://github.com/jparise/vim-phabricator
-[fugitive-azure-devops.vim]: https://github.com/cedarbaum/fugitive-azure-devops.vim
-[srht.vim]: https://git.sr.ht/~willdurand/srht.vim
 
-Add `%{FugitiveStatusline()}` to `'statusline'` to get an indicator
+Add `%{fugitive#statusline()}` to `'statusline'` to get an indicator
-with the current branch in your statusline.
+with the current branch in (surprise!) your statusline.
 
-For more information, see `:help fugitive`.
+Last but not least, there's `:Git` for running any arbitrary command,
+and `Git!` to open the output of a command in a temp file.
 
 ## Screencasts
 
@@ -86,29 +55,53 @@ For more information, see `:help fugitive`.
 
 ## Installation
 
-Install using your favorite package manager, or use Vim's built-in package support:
+If you don't have a preferred installation method, one option is to install
+[pathogen.vim](https://github.com/tpope/vim-pathogen), and then copy
+and paste:
 
-    mkdir -p ~/.vim/pack/tpope/start
+    cd ~/.vim/bundle
-    cd ~/.vim/pack/tpope/start
+    git clone git://github.com/tpope/vim-fugitive.git
-    git clone https://tpope.io/vim/fugitive.git
+    vim -u NONE -c "helptags vim-fugitive/doc" -c q
-    vim -u NONE -c "helptags fugitive/doc" -c q
+
+If your Vim version is below 7.2, I recommend also installing
+[vim-git](https://github.com/tpope/vim-git) for syntax highlighting and
+other Git niceties.
 
 ## FAQ
 
-> What happened to the dispatch.vim backed asynchronous `:Gpush` and
+> I installed the plugin and started Vim.  Why don't any of the commands
-> `:Gfetch`?
+> exist?
 
-This behavior was divisive, confusing, and complicated inputting passwords, so
+Fugitive cares about the current file, not the current working
-it was removed.  Use `:Git! push` to use Fugitive's own asynchronous
+directory.  Edit a file from the repository.
-execution, or retroactively make `:Git push` asynchronous by pressing
-`CTRL-D`.
 
-> So I have a symlink and...
+> I opened a new tab.  Why don't any of the commands exist?
 
-Stop.  Just stop.  If Git won't deal with your symlink, then Fugitive won't
+Fugitive cares about the current file, not the current working
-either.  Consider using a [plugin that resolves
+directory.  Edit a file from the repository.
-symlinks](https://github.com/aymericbeaumet/symlink.vim), or even better,
+
-using fewer symlinks.
+> Why is `:Gbrowse` not using the right browser?
+
+`:Gbrowse` delegates to `git web--browse`, which is less than perfect
+when it comes to finding the right browser.  You can tell it the correct
+browser to use with `git config --global web.browser ...`.  On OS X, for
+example, you might want to set this to `open`.  See `git web--browse --help`
+for details.
+
+> Here's a patch that automatically opens the quickfix window after
+> `:Ggrep`.
+
+This is a great example of why I recommend asking before patching.
+There are valid arguments to be made both for and against automatically
+opening the quickfix window.  Whenever I have to make an arbitrary
+decision like this, I ask what Vim would do.  And Vim does not open a
+quickfix window after `:grep`.
+
+Luckily, it's easy to implement the desired behavior without changing
+fugitive.vim.  The following autocommand will cause the quickfix window
+to open after any grep invocation:
+
+    autocmd QuickFixCmdPost *grep* cwindow
 
 ## Self-Promotion
 

doc/fugitive.txt

@@ -15,156 +15,140 @@ COMMANDS                                        *fugitive-commands*
 These commands are local to the buffers in which they work (generally, buffers
 that are part of Git repositories).
 
-                                                *fugitive-:G*
+                                                *fugitive-:Git*
-:G [args]               Same as :Git, but two characters shorter.
+:Git [args]             Run an arbitrary git command. Similar to :!git [args]
+                        but chdir to the repository tree first.
 
-                                                *:Git*
+                                                *fugitive-:Git!*
-:Git {args}             Run an arbitrary git command and display any output.
+:Git! [args]            Like |:Git|, but capture the output into a temp file,
-                        On UNIX this uses a pty and on other platforms it uses
+                        and edit that temp file.
-                        a pipe, which will cause some behavior differences
-                        such as the absence of progress bars.  Any file the
-                        command edits (for example, a commit message) will be
-                        loaded into a split window.  Closing that window will
-                        resume running the command.  A few Git subcommands
-                        have different behavior; these are documented below.
 
-                                                *:Git!*
+                                                *fugitive-:Gcd*
-:Git! {args}            Run an arbitrary git command in the background and
-                        stream the output to the preview window.  Requires a
-                        Vim with |setbufline()|.  Press CTRL-D during an
-                        interactive :Git invocation to switch to this mode
-                        retroactively.
-
-                                                *:Git_--paginate* *:Git_-p*
-:Git --paginate {args}  Run an arbitrary git command, capture output to a temp
-:Git -p {args}          file, and |:split| that temp file.  Pass ++curwin as
-                        the first argument to |:edit| the temp file instead.
-                        A temp file is always used for commands like diff and
-                        log that typically uses a pager, and for any command
-                        that has the pager.<cmd> Git configuration option set.
-
-:{range}Git! --paginate {args}
-:{range}Git! -p {args}  Run an arbitrary git command, and insert the output
-                        after {range} in the current buffer.
-
-                                                *fugitive-summary*
-:Git                    With no arguments, bring up a summary window vaguely
-                        akin to git-status.  Press g? or see |fugitive-maps|
-                        for usage.
-
-                                                *:Git_blame*
-:Git blame [flags]      Run git-blame [flags] on the current file and open the
-                        results in a scroll-bound vertical split.  The
-                        following maps, which work on the cursor line commit
-                        where sensible, are provided:
-
-                        g?    show this help
-                        A     resize to end of author column
-                        C     resize to end of commit column
-                        D     resize to end of date/time column
-                        gq    close blame, then |:Gedit| to return to work
-                              tree version
-                        <CR>  close blame, and jump to patch that added line
-                              (or directly to blob for boundary commit)
-                        o     jump to patch or blob in horizontal split
-                        O     jump to patch or blob in new tab
-                        p     jump to patch or blob in preview window
-                        -     reblame at commit
-                        ~     reblame at [count]th first grandparent
-                        P     reblame at [count]th parent (like HEAD^[count])
-
-                                                *g:fugitive_dynamic_colors*
-                        In the GUI or a 256 color terminal, commit hashes will
-                        highlighted in different colors. To disable this:
->
-                        let g:fugitive_dynamic_colors = 0
-<
-:[range]Git blame [...] If a range is given, just that part of the file will
-:Git blame [...] {file} be blamed, and a horizontal split without
-                        scrollbinding is used.  You can also give an arbitrary
-                        filename.
-
-                                                *:Git_difftool*
-:Git[!] difftool [args] Invoke `git diff [args]` and load the changes into the
-                        quickfix list.  Each changed hunk gets a separate
-                        quickfix entry unless you pass an option like
-                        --name-only or --name-status.  Jumps to the first
-                        change unless [!] is given.
-
-:Git difftool -y [args] Invoke `git diff [args]`, open each changed file in a
-                        new tab, and invoke |:Gdiffsplit!| against the
-                        appropriate commit.
-
-                                                *:Git_mergetool*
-:Git mergetool [args]   Like |:Git_difftool|, but target merge conflicts.
-
-                                                *:Ggrep* *:Git_grep*
-:Ggrep[!] [args]        An approximation of |:grep|[!] with git-grep as
-:Git[!] grep -O [args]  'grepprg'.
-
-:Ggrep[!] --quiet [args]
-:Ggrep[!] -q [args]     Like |:Ggrep|, but instead of displaying output, open
-                        the quickfix list.
-
-                                                *:Glgrep*
-:Glgrep[!] [args]       :Ggrep but for |:lgrep|.
-:0Git[!] grep -O [args]
-
-                                                 *:Gclog*
-:Gclog[!] [args]        Use git-log [args] to load the commit history into the
-                        |quickfix| list.  Jumps to the first commit unless [!]
-                        is given.
-
-                        The quickfix list can be awkward for many use cases
-                        and exhibits extremely poor performance with larger
-                        data sets.  Consider using |:Git| log instead.
-
-:{range}Gclog[!] [args] Use git-log -L to load previous revisions of the given
-                        range of the current file into the |quickfix| list.
-                        The cursor is positioned on the first line of the
-                        first diff hunk for each commit.  Use :0Gclog to
-                        target the entire file.
-
-                                                *:Gllog*
-:Gllog [args]           Like |:Gclog|, but use the location list instead of the
-                        |quickfix| list.
-
-                                                *:Gcd*
 :Gcd [directory]        |:cd| relative to the repository.
 
-                                                *:Glcd*
+                                                *fugitive-:Glcd*
 :Glcd [directory]       |:lcd| relative to the repository.
 
-                                                *:Gedit* *fugitive-:Ge*
+                                                *fugitive-:Gstatus*
-:Gedit [object]         |:edit| a |fugitive-object|.
+:Gstatus                Bring up the output of git-status in the preview
+                        window.  The following maps, which work on the cursor
+                        line file where sensible, are provided:
 
-                                                *:Gsplit*
+                        g?    show this help
-:Gsplit [object]        |:split| a |fugitive-object|.
+                        <C-N> next file
+                        <C-P> previous file
+                        <CR>  |:Gedit|
+                        -     |:Git| add
+                        -     |:Git| reset (staged files)
+                        cA    |:Gcommit| --amend --reuse-message=HEAD
+                        ca    |:Gcommit| --amend
+                        cc    |:Gcommit|
+                        cva   |:Gcommit| --amend --verbose
+                        cvc   |:Gcommit| --verbose
+                        D     |:Gdiff|
+                        ds    |:Gsdiff|
+                        dp    |:Git!| diff (p for patch; use :Gw to apply)
+                        dp    |:Git| add --intent-to-add (untracked files)
+                        dv    |:Gvdiff|
+                        O     |:Gtabedit|
+                        o     |:Gsplit|
+                        p     |:Git| add --patch
+                        p     |:Git| reset --patch (staged files)
+                        q     close status
+                        r     reload status
+                        S     |:Gvsplit|
 
-                                                *:Gvsplit*
+                                                *fugitive-:Gcommit*
-:Gvsplit [object]       |:vsplit| a |fugitive-object|.
+:Gcommit [args]         A wrapper around git-commit.  If there is nothing
+                        to commit, |:Gstatus| is called instead.  Unless the
+                        arguments given would skip the invocation of an editor
+                        (e.g., -m), a split window will be used to obtain a
+                        commit message, or a new tab if -v is given.  Write
+                        and close that window (:wq or |:Gwrite|) to finish the
+                        commit.  Unlike when running the actual git-commit
+                        command, it is possible (but unadvisable) to alter the
+                        index with commands like git-add and git-reset while a
+                        commit message is pending.
 
-                                                *:Gtabedit*
+                                                *fugitive-:Gmerge*
-:Gtabedit [object]      |:tabedit| a |fugitive-object|.
+:Gmerge [args]          Calls git-merge and loads errors and conflicted files
+                        into the quickfix list.  Opens a |:Gcommit| style
+                        split window for the commit message if the merge
+                        succeeds.  If called during a merge conflict, the
+                        conflicted files from the current index are loaded
+                        into the quickfix list.
 
-                                                *:Gpedit*
+                                                *fugitive-:Gpull*
-:Gpedit [object]        |:pedit| a |fugitive-object|.
+:Gpull [args]           Like |:Gmerge|, but for git-pull.
 
-                                                *:Gread* *fugitive-:Gr*
+                                                *fugitive-:Gpush*
-:Gread [object]         Empty the buffer and |:read| a |fugitive-object|.
+:Gpush [args]           Invoke git-push, load the results into the quickfix
+                        list, and invoke |:cwindow| to reveal any errors.
+                        |:Dispatch| is used if available for asynchronous
+                        invocation.
+
+                                                *fugitive-:Gfetch*
+:Gfetch [args]          Like |:Gpush|, but for git-fetch.
+
+                                                *fugitive-:Ggrep*
+:Ggrep [args]           |:grep| with git-grep as 'grepprg'.
+
+                                                *fugitive-:Glgrep*
+:Glgrep [args]          |:lgrep| with git-grep as 'grepprg'.
+
+                                                *fugitive-:Glog*
+:Glog [args]            Load all previous revisions of the current file into
+                        the quickfix list.  Additional git-log arguments can
+                        be given (for example, --reverse).  If "--" appears as
+                        an argument, no file specific filtering is done, and
+                        previous commits rather than previous file revisions
+                        are loaded.
+
+:{range}Glog [args]     Use git-log -L to load previous revisions of the given
+                        range of the current file into the quickfix list.  The
+                        cursor is positioned on the first line of the first
+                        diff hunk for each commit.
+
+                                                *fugitive-:Gllog*
+:Gllog [args]           Like |:Glog|, but use the location list instead of the
+                        quickfix list.
+
+                                        *fugitive-:Gedit* *fugitive-:Ge*
+:Gedit [revision]       |:edit| a |fugitive-revision|.
+
+                                                *fugitive-:Gsplit*
+:Gsplit [revision]      |:split| a |fugitive-revision|.
+
+                                                *fugitive-:Gvsplit*
+:Gvsplit [revision]     |:vsplit| a |fugitive-revision|.
+
+                                                *fugitive-:Gtabedit*
+:Gtabedit [revision]    |:tabedit| a |fugitive-revision|.
+
+                                                *fugitive-:Gpedit*
+:Gpedit [revision]      |:pedit| a |fugitive-revision|.
+
+:Gsplit! [args]                 *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
+:Gvsplit! [args]                *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
+:Gtabedit! [args]       Like |:Git!|, but open the resulting temp file in a
+:Gpedit! [args]         split, tab, or preview window.
+
+                                                *fugitive-:Gread*
+:Gread [revision]       Empty the buffer and |:read| a |fugitive-revision|.
                         When the argument is omitted, this is similar to
                         git-checkout on a work tree file or git-add on a stage
                         file, but without writing anything to disk.
 
-:{range}Gread [object]  |:read| in a |fugitive-object| after {range}.
+:{range}Gread [revision]
+                        |:read| in a |fugitive-revision| after {range}.
 
-                                                *:Gread!* *fugitive-:Gr!*
+                                                *fugitive-:Gread!*
 :Gread! [args]          Empty the buffer and |:read| the output of a Git
                         command.  For example, :Gread! show HEAD:%.
 
 :{range}Gread! [args]  |:read| the output of a Git command after {range}.
 
-                                                *:Gwrite* *fugitive-:Gw*
+                                        *fugitive-:Gw* *fugitive-:Gwrite*
 :Gwrite                 Write to the current file's path and stage the results.
                         When run in a work tree file, it is effectively git
                         add.  Elsewhere, it is effectively git-checkout.  A
@@ -174,545 +158,194 @@ that are part of Git repositories).
 
 :Gwrite {path}          You can give |:Gwrite| an explicit path of where in
                         the work tree to write.  You can also give a path like
-                        :0:foo.txt or :0:% to write to just that stage in
+                        :0:foo.txt or even :0 to write to just that stage in
                         the index.
 
-                                                *:Gwq*
+                                                *fugitive-:Gwq*
 :Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
                         succeeded.
 
 :Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
                         succeeded.
 
-                                                *:Gdiffsplit*
+                                                *fugitive-:Gdiff*
-:Gdiffsplit [object]    Perform a |vimdiff| against the given file, or if a
+:Gdiff [revision]       Perform a |vimdiff| against the current file in the
-                        commit is given, the current file in that commit.
+                        given revision.  With no argument, the version in the
-                        With no argument, the version in the index or work
+                        index is used (which means a three-way diff during a
-                        tree is used, and the work tree version is always
+                        merge conflict, making it a git-mergetool
-                        placed to the right or bottom, depending on available
+                        alternative).  The newer of the two files is placed
-                        width.  Use Vim's |do| and |dp| to stage and unstage
+                        to the right or bottom, depending on 'diffopt' and
-                        changes.
+                        the width of the window relative to 'textwidth'.  Use
+                        |do| and |dp| and write to the index file to simulate
+                        "git add --patch".
 
-                                                *:Gdiffsplit!*
+                                                *fugitive-:Gsdiff*
-:Gdiffsplit!            Diff against any and all direct ancestors, retaining
+:Gsdiff [revision]      Like |:Gdiff|, but always split horizontally.
-                        focus on the current window.  During a merge conflict,
-                        this is a three-way diff against the "ours" and
-                        "theirs" ancestors.  Additional d2o and d3o maps are
-                        provided to obtain the hunk from the "ours" or
-                        "theirs" ancestor, respectively.
 
-:Gdiffsplit! {object}   Like |:Gdiffsplit|, but retain focus on the current
+                                                *fugitive-:Gvdiff*
-                        window.
+:Gvdiff [revision]      Like |:Gdiff|, but always split vertically.
 
-                                                *:Gvdiffsplit*
+                                                *fugitive-:Gmove*
-:Gvdiffsplit [object]   Like |:Gdiffsplit|, but always split vertically.
+:Gmove {destination}    Wrapper around git-mv that renames the buffer
+                        afterward.  The destination is relative to the current
+                        directory except when started with a /, in which case
+                        it is relative to the work tree.  Add a ! to pass -f.
 
-                                                *:Ghdiffsplit*
+                                                *fugitive-:Gremove*
-:Gdiffsplit ++novertical [object]
+:Gremove                Wrapper around git-rm that deletes the buffer
-:Ghdiffsplit [object]   Like |:Gdiffsplit|, but with "vertical" removed from
-                        'diffopt'.  The split will still be vertical if
-                        combined with |:vertical|.
-
-                                                *:GMove*
-:GMove {destination}    Wrapper around git-mv that renames the buffer
-                        afterward.  Add a ! to pass -f.
-
-                                                *:GRename*
-:GRename {destination}  Like |:GMove| but operates relative to the parent
-                        directory of the current file.
-
-                                                *:GDelete*
-:GDelete                Wrapper around git-rm that deletes the buffer
                         afterward.  When invoked in an index file, --cached is
                         passed.  Add a ! to pass -f and forcefully discard the
                         buffer.
 
-                                                *:GRemove*
+                                                *fugitive-:Gblame*
-:GRemove                Like |:GDelete|, but keep the (now empty) buffer around.
+:Gblame [flags]         Run git-blame on the file and open the results in a
+                        scroll bound vertical split.  You can give any of
+                        ltfnsewMC as flags and they will be passed along to
+                        git-blame.  The following maps, which work on the
+                        cursor line commit where sensible, are provided:
+
+                        g?    show this help
+                        A     resize to end of author column
+                        C     resize to end of commit column
+                        D     resize to end of date/time column
+                        q     close blame and return to blamed window
+                        gq    q, then |:Gedit| to return to work tree version
+                        <CR>  q, then open commit
+                        o     open commit in horizontal split
+                        O     open commit in new tab
+                        -     reblame at commit
+                        ~     reblame at [count]th first grandparent
+                        P     reblame at [count]th parent (like HEAD^[count])
+
+:[range]Gblame [flags]  Run git-blame on the given range.
+
+                                                *fugitive-:Gbrowse*
+:Gbrowse                Open the current file, blob, tree, commit, or tag
+                        in your browser at the upstream hosting provider
+                        indicated by the "origin" remote.  If a range is
+                        given, it is appropriately appended to the URL as an
+                        anchor.
 
-                                                *:GBrowse*
-:GBrowse                Open the current file, blob, tree, commit, or tag
-                        in your browser at the upstream hosting provider.
                         Upstream providers can be added by installing an
                         appropriate Vim plugin.  For example, GitHub can be
                         supported by installing rhubarb.vim, available at
-                        <https://github.com/tpope/vim-rhubarb>.
+                        <https://github.com/tpope/vim-rhubarb>.  (Native
+                        support for GitHub is currently included, but that is
+                        slated to be removed.)
 
-:GBrowse {object}       Like :GBrowse, but for a given |fugitive-object|.
+                        If no upstream support is available, a local instance
+                        of git-instaweb will be started and used instead.
 
-:{range}GBrowse [args]  Appends an anchor to the URL that emphasizes the
+:Gbrowse {revision}     Like :Gbrowse, but for a given |fugitive-revision|.  A
-                        selected lines. This also forces the URL to include a
+                        useful value here is -, which ties the URL to the
-                        commit rather than a branch name so it remains valid
+                        latest commit rather than a volatile branch.
-                        if the file changes.  You can give a range of "0" to
-                        force this behavior without including an anchor.
 
-:GBrowse [...]@{remote} Force using the given remote rather than the remote
+:Gbrowse [...]@{remote} Force using the given remote rather than the remote
                         for the current branch.  The remote is used to
-                        determine which upstream repository to link to.
+                        determine which GitHub repository to link to.
 
-:GBrowse {url}          Open an arbitrary URL in your browser.
+:{range}Gbrowse [args]  Appends an anchor to the URL that emphasizes the
+                        selected lines.  You almost certainly want to give a
+                        "-" argument in this case to force the URL to include
+                        an exact revision.
 
-:[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
+:[range]Gbrowse! [args] Like :Gbrowse, but put the URL on the clipboard rather
                         than opening it.
 
-MAPS                                            *fugitive-maps*
+MAPPINGS                                        *fugitive-mappings*
 
-These maps are available in both the |fugitive-summary| buffer and Fugitive
+These maps are available everywhere.
-object buffers, although not all maps make sense in all buffers.  Mappings
-that operate on the file or hunk under the cursor are generally available in
-visual mode to operate on multiple files or partial hunks.
 
-                                                *fugitive-staging-maps*
+                                                *fugitive-c_CTRL-R_CTRL-G*
-Staging/unstaging maps ~
-
-                                                *fugitive_s*
-s                       Stage (add) the file or hunk under the cursor.
-
-                                                *fugitive_u*
-u                       Unstage (reset) the file or hunk under the cursor.
-
-                                                *fugitive_-*
--                       Stage or unstage the file or hunk under the cursor.
-
-                                                *fugitive_U*
-U                       Unstage everything.
-
-                                                *fugitive_X*
-X                       Discard the change under the cursor.  This uses
-                        `checkout` or `clean` under the hood.  A command is
-                        echoed that shows how to undo the change.  Consult
-                        `:messages` to see it again.  During a merge conflict,
-                        use 2X to call `checkout --ours` or 3X to call
-                        `checkout --theirs` .
-
-                                                *fugitive_=*
-=                       Toggle an inline diff of the file under the cursor.
-
-                                                *fugitive_>*
->                       Insert an inline diff of the file under the cursor.
-
-                                                *fugitive_<*
-<                       Remove the inline diff of the file under the cursor.
-
-                                                *fugitive_gI*
-gI                      Open .git/info/exclude in a split and add the file
-                        under the cursor.  Use a count to open .gitignore.
-
-                                                *fugitive_I*
-I                       Invoke |:Git| add --patch or reset --patch on the file
-P                       under the cursor. On untracked files, this instead
-                        calls |:Git| add --intent-to-add.
-
-                                                *fugitive_d*
-Diff maps ~
-                                                *fugitive_dp*
-dp                      Invoke |:Git| diff on the file under the cursor.
-                        Deprecated in favor of inline diffs.
-
-                                                *fugitive_dd*
-dd                      Perform a |:Gdiffsplit| on the file under the cursor.
-
-                                                *fugitive_dv*
-dv                      Perform a |:Gvdiffsplit| on the file under the cursor.
-
-                                                *fugitive_ds* *fugitive_dh*
-ds                      Perform a |:Ghdiffsplit| on the file under the cursor.
-dh
-
-                                                *fugitive_dq*
-dq                      Close all but one diff buffer, and |:diffoff|! the
-                        last one.
-
-                                                *fugitive_d?*
-d?                      Show this help.
-
-                                                *fugitive-navigation-maps*
-Navigation maps ~
-
-                                                *fugitive_<CR>*
-<CR>                    Open the file or |fugitive-object| under the cursor.
-                        In a blob, this and similar maps jump to the patch
-                        from the diff where this was added, or where it was
-                        removed if a count was given.  If the line is still in
-                        the work tree version, passing a count takes you to
-                        it.
-
-                                                *fugitive_o*
-o                       Open the file or |fugitive-object| under the cursor in
-                        a new split.
-
-                                                *fugitive_gO*
-gO                      Open the file or |fugitive-object| under the cursor in
-                        a new vertical split.
-
-                                                *fugitive_O*
-O                       Open the file or |fugitive-object| under the cursor in
-                        a new tab.
-
-                                                *fugitive_p*
-p                       Open the file or |fugitive-object| under the cursor in
-                        a preview window.  In the status buffer, 1p is
-                        required to bypass the legacy usage instructions.
-
-                                                *fugitive_~*
-~                       Open the current file in the [count]th first ancestor.
-
-                                                *fugitive_P*
-P                       Open the current file in the [count]th parent.
-
-                                                *fugitive_C*
-C                       Open the commit containing the current file.
-
-                                                *fugitive_CTRL-P* *fugitive_(*
-(                       Jump to the previous file, hunk, or revision.
-
-                                                *fugitive_CTRL-N* *fugitive_)*
-)                       Jump to the next file, hunk, or revision.
-
-                                                *fugitive_[c*
-[c                      Jump to previous hunk, expanding inline diffs
-                        automatically.  (This shadows the Vim built-in |[c|
-                        that provides a similar operation in |diff| mode.)
-
-                                                *fugitive_]c*
-]c                      Jump to next hunk, expanding inline diffs
-                        automatically.  (This shadows the Vim built-in |]c|
-                        that provides a similar operation in |diff| mode.)
-
-                                                *fugitive_[/* *fugitive_[m*
-[/                      Jump to previous file, collapsing inline diffs
-[m                      automatically.  (Mnemonic: "/" appears in filenames,
-                        "m" appears in "filenames".)
-
-                                                *fugitive_]/* *fugitive_]m*
-]/                      Jump to next file, collapsing inline diffs
-]m                      automatically.  (Mnemonic: "/" appears in filenames,
-                        "m" appears in "filenames".)
-
-                                                *fugitive_i*
-i                       Jump to the next file or hunk, expanding inline diffs
-                        automatically.
-
-                                                *fugitive_[[*
-[[                      Jump [count] sections backward.
-
-                                                *fugitive_]]*
-]]                      Jump [count] sections forward.
-
-                                                *fugitive_[]*
-[]                      Jump [count] section ends backward.
-
-                                                *fugitive_][*
-][                      Jump [count] section ends forward.
-
-                                                *fugitive_star*
-*                       On the first column of a + or - diff line, search for
-                        the corresponding - or + line.  Otherwise, defer to
-                        built-in |star|.
-
-                                                *fugitive_#*
-#                       Same as "*", but search backward.
-
-                                                *fugitive_gu*
-gu                      Jump to file [count] in the "Untracked" or "Unstaged"
-                        section.
-
-                                                *fugitive_gU*
-gU                      Jump to file [count] in the "Unstaged" section.
-
-                                                *fugitive_gs*
-gs                      Jump to file [count] in the "Staged" section.
-
-                                                *fugitive_gp*
-gp                      Jump to file [count] in the "Unpushed" section.
-
-                                                *fugitive_gP*
-gP                      Jump to file [count] in the "Unpulled" section.
-
-                                                *fugitive_gr*
-gr                      Jump to file [count] in the "Rebasing" section.
-
-                                                *fugitive_gi*
-gi                      Open .git/info/exclude in a split.  Use a count to
-                        open .gitignore.
-
-                                                *fugitive_c*
-Commit maps ~
-
-cc                      Create a commit.
-
-ca                      Amend the last commit and edit the message.
-
-ce                      Amend the last commit without editing the message.
-
-cw                      Reword the last commit.
-
-cvc                     Create a commit with -v.
-
-cva                     Amend the last commit with -v
-
-cf                      Create a `fixup!` commit for the commit under the
-                        cursor.
-
-cF                      Create a `fixup!` commit for the commit under the
-                        cursor and immediately rebase it.
-
-cs                      Create a `squash!` commit for the commit under the
-                        cursor.
-
-cS                      Create a `squash!` commit for the commit under the
-                        cursor and immediately rebase it.
-
-cA                      Create a `squash!` commit for the commit under the
-                        cursor and edit the message.
-
-c<Space>                Populate command line with ":Git commit ".
-
-                                                *fugitive_cr*
-crc                     Revert the commit under the cursor.
-
-crn                     Revert the commit under the cursor in the index and
-                        work tree, but do not actually commit the changes.
-
-cr<Space>               Populate command line with ":Git revert ".
-
-                                                *fugitive_cm*
-cm<Space>               Populate command line with ":Git merge ".
-
-c?                      Show this help.
-
-                                                *fugitive_cb*
-                                                *fugitive_co*
-Checkout/branch maps ~
-
-coo                     Check out the commit under the cursor.
-
-cb<Space>               Populate command line with ":Git branch ".
-
-co<Space>               Populate command line with ":Git checkout ".
-
-cb?                     Show this help.
-co?
-
-                                                *fugitive_cz*
-Stash maps ~
-
-czz                     Push stash.  Pass a [count] of 1 to add
-                        `--include-untracked` or 2 to add `--all`.
-
-czw                     Push stash of worktree.  Like `czz` with
-                        `--keep-index`.
-
-czA                     Apply topmost stash, or stash@{count}.
-
-cza                     Apply topmost stash, or stash@{count}, preserving the
-                        index.
-
-czP                     Pop topmost stash, or stash@{count}.
-
-czp                     Pop topmost stash, or stash@{count}, preserving the
-                        index.
-
-cz<Space>               Populate command line with ":Git stash ".
-
-cz?                     Show this help.
-
-                                                *fugitive_r*
-Rebase maps ~
-
-ri                      Perform an interactive rebase.  Uses ancestor of
-u                       commit under cursor as upstream if available.
-
-rf                      Perform an autosquash rebase without editing the todo
-                        list.  Uses ancestor of commit under cursor as
-                        upstream if available.
-
-ru                      Perform an interactive rebase against @{upstream}.
-
-rp                      Perform an interactive rebase against @{push}.
-
-rr                      Continue the current rebase.
-
-rs                      Skip the current commit and continue the current
-                        rebase.
-
-ra                      Abort the current rebase.
-
-re                      Edit the current rebase todo list.
-
-rw                      Perform an interactive rebase with the commit under
-                        the cursor set to `reword`.
-
-rm                      Perform an interactive rebase with the commit under
-                        the cursor set to `edit`.
-
-rd                      Perform an interactive rebase with the commit under
-                        the cursor set to `drop`.
-
-r<Space>                Populate command line with ":Git rebase ".
-
-r?                      Show this help.
-
-                                                *fugitive-misc-maps*
-Miscellaneous maps ~
-
-                                                *fugitive_gq* *fugitive_q*
-gq                      Close the status buffer.
-
-                                                *fugitive_.*
-.                       Start a |:| command line with the file under the
-                        cursor prepopulated.
-
-                                                *fugitive_g?*
-g?                      Show help for |fugitive-maps|.
-
-                                                *fugitive-global-maps*
-Global maps ~
-
-                                                *fugitive_c_CTRL-R_CTRL-G*
 <C-R><C-G>              On the command line, recall the path to the current
-                        |fugitive-object| (that is, a representation of the
+                        object (that is, a representation of the object
-                        object recognized by |:Gedit|).
+                        recognized by |:Gedit|).
 
-                                                *fugitive_y_CTRL-G*
+                                                *fugitive-y_CTRL-G*
-["x]y<C-G>              Yank the path to the current |fugitive-object|.
+["x]y<C-G>              Yank the commit SHA and path to the current object.
 
-                                                *g:fugitive_no_maps*
+These maps are available in Git objects.
-Global maps can be disabled with the g:fugitive_no_maps option.
->
-        let g:fugitive_no_maps = 1
-<
-SPECIFYING OBJECTS                      *fugitive-object* *fugitive-revision*
 
-Fugitive objects are either work tree files or Git revisions as defined in the
+                                                *fugitive-<CR>*
-"SPECIFYING REVISIONS" section in the git-rev-parse man page, with expansions
+<CR>                    Jump to the revision under the cursor.
-inspired by |cmdline-special| layered on top.  For commands that accept an
-optional object, the default is the file in the index for work tree files and
-the work tree file for everything else.  Example objects follow.
 
-Object          Meaning ~
+                                                *fugitive-o*
-@               The commit referenced by @ aka HEAD
+o                       Jump to the revision under the cursor in a new split.
-master          The commit referenced by master
+
-master^         The parent of the commit referenced by master
+                                                *fugitive-S*
-master...other  The merge base of master and other
+S                       Jump to the revision under the cursor in a new
-master:         The tree referenced by master
+                        vertical split.
-./master        The file named master in the working directory
+
-:(top)master    The file named master in the work tree
+                                                *fugitive-O*
+O                       Jump to the revision under the cursor in a new tab.
+
+                                                *fugitive--*
+-                       Go to the tree containing the current tree or blob.
+
+                                                *fugitive-~*
+~                       Go to the current file in the [count]th first
+                        ancestor.
+
+                                                *fugitive-P*
+P                       Go to the current file in the [count]th parent.
+
+                                                *fugitive-C*
+C                       Go to the commit containing the current file.
+
+                                                *fugitive-.*
+.                       Start a |:| command line with the current revision
+                        prepopulated at the end of the line.
+
+                                                *fugitive-a*
+a                       Show the current tag, commit, or tree in an alternate
+                        format.
+
+SPECIFYING REVISIONS                            *fugitive-revision*
+
+Fugitive revisions are similar to Git revisions as defined in the "SPECIFYING
+REVISIONS" section in the git-rev-parse man page.  For commands that accept an
+optional revision, the default is the file in the index for work tree files
+and the work tree file for everything else.  Example revisions follow.
+
+Revision        Meaning ~
+HEAD            .git/HEAD
+master          .git/refs/heads/master
+HEAD^{}         The commit referenced by HEAD
+HEAD^           The parent of the commit referenced by HEAD
+HEAD:           The tree referenced by HEAD
+/HEAD           The file named HEAD in the work tree
 Makefile        The file named Makefile in the work tree
-@^:Makefile     The file named Makefile in the parent of HEAD
+HEAD^:Makefile  The file named Makefile in the parent of HEAD
 :Makefile       The file named Makefile in the index (writable)
-@~2:%           The current file in the grandparent of HEAD
+-               The current file in HEAD
-:%              The current file in the index
+^               The current file in the previous commit
-:1:%            The current file's common ancestor during a conflict
+~3              The current file 3 commits ago
-:2:#            The alternate file in the target branch during a conflict
+:               .git/index (Same as |:Gstatus|)
-:3:#5           The file from buffer #5 in the merged branch during a conflict
+:0              The current file in the index
-!               The commit owning the current file
+:1              The current file's common ancestor during a conflict
-!:Makefile      The file named Makefile in the commit owning the current file
+:2              The current file in the target branch during a conflict
-!3^2            The second parent of the commit owning buffer #3
+:3              The current file in the merged branch during a conflict
-.git/config     The repo config file
+:/foo           The most recent commit with "foo" in the message
-:               The |fugitive-summary| buffer
--               A temp file containing the last |:Git| invocation's output
-<cfile>         The file or commit under the cursor
 
 STATUSLINE                                      *fugitive-statusline*
 
-                                *FugitiveStatusline()* *fugitive#statusline()*
+                                                *fugitive#statusline()*
-Add %{FugitiveStatusline()} to your statusline to get an indicator including
+Add %{fugitive#statusline()} to your statusline to get an indicator including
 the current branch and the currently edited file's commit.  If you don't have
 a statusline, this one matches the default when 'ruler' is set:
 >
-        set statusline=%<%f\ %h%m%r%{FugitiveStatusline()}%=%-14.(%l,%c%V%)\ %P
+    set statusline=%<%f\ %h%m%r%{fugitive#statusline()}%=%-14.(%l,%c%V%)\ %P
 <
-AUTOCOMMANDS                                    *fugitive-autocommands*
+                                                *fugitive#head(...)*
-
+Use fugitive#head() to return the name of the current branch. If the current
-A handful of |User| |autocommands| are provided to allow extending and
+HEAD is detached, fugitive#head() will return the empty string, unless the
-overriding Fugitive behaviors.  Example usage:
+optional argument is given, in which case the hash of the current commit will
->
+be truncated to the given number of characters.
-        autocmd User FugitiveBlob,FugitiveStageBlob call s:BlobOverrides()
-<
-                                                *User_FugitiveTag*
-FugitiveTag             After loading a tag object.
-
-                                                *User_FugitiveCommit*
-FugitiveCommit          After loading a commit object.
-
-                                                *User_FugitiveTree*
-FugitiveTree            After loading a tree (directory) object.
-
-                                                *User_FugitiveBlob*
-FugitiveBlob            After loading a committed blob (file) object.
-
-                                                *User_FugitiveObject*
-FugitiveObject          After loading any of the 4 above buffer types.
-
-                                                *User_FugitiveStageBlob*
-FugitiveStageBlob       After loading a staged blob (file) object.  These
-                        buffers are 'modifiable' and oftentimes don't want the
-                        same behavior as the other buffer types.
-
-                                                *User_FugitiveIndex*
-FugitiveIndex           After loading the |fugitive-summary| buffer.
-
-                                                *User_FugitivePager*
-FugitivePager           After loading a temp file created by a command like
-                        :Git --paginate or :Git blame.
-
-                                                *User_FugitiveEditor*
-FugitiveEditor          After a :Git command (e.g., :Git commit) edits a file
-                        (e.g., the commit message).
-
-                                                *User_FugitiveChanged*
-FugitiveChanged         After any event which can potentially change the
-                        repository, for example, any invocation of |:Git|.
-                        Originally intended for expiring caches, but can have
-                        other uses.
-
-API                                             *fugitive-api*
-
-Officially supported functions are documented inline in plugin/fugitive.vim.
-
-DEPRECATIONS                                    *fugitive-deprecated*
-
-The following commands are deprecated in favor of replacements that adhere to
-a new naming scheme.  Remember that |:Git| can be shortened to |:G|, so
-replacements using it are just one space character longer than the legacy
-version.
-
-*:Gremove*      Superseded by |:GRemove|.
-*:Gdelete*      Superseded by |:GDelete|.
-*:Gmove*        Superseded by |:GMove|.
-*:Grename*      Superseded by |:GRename|.
-*:Gbrowse*      Superseded by |:GBrowse|.
-*:Gdiff*        Superseded by |:Gdiffsplit|
-*:Gsdiff*       Superseded by |:Ghdiffsplit|
-*:Gvdiff*       Superseded by |:Gvdiffsplit| or |:vert| |:Gdiffsplit|.
-*:Gblame*       Superseded by |:Git_blame|.
-*:Gcommit*      Superseded by |:Git| commit.
-*:Gmerge*       Superseded by |:Git| merge and |:Git_mergetool|.
-*:Gpull*        Superseded by |:Git| pull.
-*:Grebase*      Superseded by |:Git| rebase.
-*:Grevert*      Superseded by |:Git| revert.
-*:Gpush*        Superseded by |:Git| push.
-*:Gfetch*       Superseded by |:Git| fetch.
-*:Glog*         Superseded by |:Gclog|.
-*:Gstatus*      Superseded by |:Git| (with no arguments).
-*:Gsplit!*      Superseded by |:Git_--paginate|.
-*:Gvsplit!*     Superseded by :vert Git --paginate.
-*:Gtabsplit!*   Superseded by :tab Git --paginate.
-*:Gpedit!*      Superseded by :Git! --paginate.
-
-                                                *User_Fugitive*
-Fugitive used to support `:autocmd User Fugitive` to run an autocommand after
-loading any buffer belonging to a Git repository, but this is being phased
-out.  Instead, one can leverage regular autocommand events like |BufNewFile|
-and |BufReadPost|, and check !empty(FugitiveGitDir()) to confirm Fugitive has
-found a repository.  See also |fugitive-autocommands| for other, more
-selective events.
 
 ABOUT                                           *fugitive-about*
 
 Grab the latest version or report a bug on GitHub:
 
-https://github.com/tpope/vim-fugitive
+http://github.com/tpope/vim-fugitive
 
  vim:tw=78:et:ft=help:norl:

ftdetect/fugitive.vim

@@ -1 +0,0 @@
-autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame

ftplugin/fugitiveblame.vim

@@ -1,6 +0,0 @@
-if exists("b:did_ftplugin") || !exists("*FugitiveGitDir")
-  finish
-endif
-let b:did_ftplugin = 1
-
-call fugitive#BlameFileType()

syntax/fugitive.vim

@@ -1,57 +0,0 @@
-if exists("b:current_syntax")
-  finish
-endif
-
-syn sync fromstart
-syn spell notoplevel
-
-syn include @fugitiveDiff syntax/diff.vim
-
-syn match fugitiveHeader /^[A-Z][a-z][^:]*:/
-syn match fugitiveHeader /^Head:/ nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
-syn match fugitiveHeader /^Pull:\|^Rebase:\|^Merge:\|^Push:/ nextgroup=fugitiveSymbolicRef skipwhite
-syn match fugitiveHelpHeader /^Help:/ nextgroup=fugitiveHelpTag skipwhite
-syn match fugitiveHelpTag    /\S\+/ contained
-
-syn region fugitiveSection start=/^\%(.*(\d\++\=)$\)\@=/ contains=fugitiveHeading end=/^$/
-syn cluster fugitiveSection contains=fugitiveSection
-syn match fugitiveHeading /^[A-Z][a-z][^:]*\ze (\d\++\=)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite
-syn match fugitiveCount /(\d\++\=)/hs=s+1,he=e-1 contained
-syn match fugitivePreposition /\<\%([io]nto\|from\|to\|Rebasing\%( detached\)\=\)\>/ transparent contained nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
-
-syn match fugitiveInstruction /^\l\l\+\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
-syn match fugitiveDone /^done\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
-syn match fugitiveStop /^stop\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
-syn match fugitiveModifier /^[MADRCU?]\{1,2} / contained containedin=@fugitiveSection
-syn match fugitiveSymbolicRef /\.\@!\%(\.\.\@!\|[^[:space:][:cntrl:]\:.]\)\+\.\@<!/ contained
-syn match fugitiveHash /^\x\{4,\}\S\@!/ contained containedin=@fugitiveSection
-syn match fugitiveHash /\S\@<!\x\{4,\}\S\@!/ contained
-
-syn region fugitiveHunk start=/^\%(@@\+ -\)\@=/ end=/^\%([A-Za-z?@]\|$\)\@=/ contains=diffLine,diffRemoved,diffAdded,diffNoEOL containedin=@fugitiveSection fold
-
-for s:section in ['Untracked', 'Unstaged', 'Staged']
-  exe 'syn region fugitive' . s:section . 'Section start=/^\%(' . s:section . ' .*(\d\++\=)$\)\@=/ contains=fugitive' . s:section . 'Heading end=/^$/'
-  exe 'syn match fugitive' . s:section . 'Modifier /^[MADRCU?] / contained containedin=fugitive' . s:section . 'Section'
-  exe 'syn cluster fugitiveSection add=fugitive' . s:section . 'Section'
-  exe 'syn match fugitive' . s:section . 'Heading /^[A-Z][a-z][^:]*\ze (\d\++\=)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite'
-endfor
-unlet s:section
-
-hi def link fugitiveHelpHeader fugitiveHeader
-hi def link fugitiveHeader Label
-hi def link fugitiveHelpTag Tag
-hi def link fugitiveHeading PreProc
-hi def link fugitiveUntrackedHeading PreCondit
-hi def link fugitiveUnstagedHeading Macro
-hi def link fugitiveStagedHeading Include
-hi def link fugitiveModifier Type
-hi def link fugitiveUntrackedModifier StorageClass
-hi def link fugitiveUnstagedModifier Structure
-hi def link fugitiveStagedModifier Typedef
-hi def link fugitiveInstruction Type
-hi def link fugitiveStop Function
-hi def link fugitiveHash Identifier
-hi def link fugitiveSymbolicRef Function
-hi def link fugitiveCount Number
-
-let b:current_syntax = "fugitive"

syntax/fugitiveblame.vim

@@ -1,7 +0,0 @@
-if exists("b:current_syntax") || !exists("*FugitiveGitDir")
-  finish
-endif
-
-call fugitive#BlameSyntax()
-
-let b:current_syntax = "fugitiveblame"