fugitive.vim 3.3

* Replace :! :Git backend with smart job runner.
* Replace special cased commit/revert/rebase/merge/etc. with regular :Git.
* Support :Git -c config.name=value and other common flags.
* Improve completion of :Git subcommands, including hiding plumbing commands.
* Improve completion of arguments to :Git subcommands.
* Show unpulled and unpushed sections for both upstream and push remote.
* Introduce capitalized naming scheme for :GMove/:GRename/:GRemove/:GDelete/:GBrowse.
* Expand SSH host aliases in remote URLs for :GBrowse.
* Enable opening arbitrary URLs with :GBrowse.
* Add warnings to deprecated commands.
* Remove all other temp buffer commands in favor of :Git --paginate.
* Don't automatically invoke :setlocal foldmethod=syntax in Fugitive buffers.
* Support colored :Git blame commits in 256 color terminals.
* Bug fixes.

.github/FUNDING.yml

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

README.markdown

@@ -1,61 +1,79 @@
 # fugitive.vim
 
-I'm not going to lie to you; fugitive.vim may very well be the best
+Fugitive is the premier Vim plugin for Git.  Or maybe it's the premier Git
-Git wrapper of all time.  Check out these features:
+plugin for Vim?  Either way, it's "so awesome, it should be illegal".  That's
+why it's called Fugitive.
 
-Bring up an enhanced version of `git status` with `:G` (also known as
+The crown jewel of Fugitive is `:Git` (or just `:G`), which calls any
-`:Gstatus`).  Press `g?` to bring up a list of mappings for numerous
+arbitrary Git command.  If you know how to use Git at the command line, you
-operations including diffing, staging, committing, rebasing, and stashing.
+know how to use `:Git`.  It's vaguely akin to `:!git` but with numerous
+improvements:
 
-View any blob, tree, commit, or tag in the repository with `:Gedit` (and
+* The default behavior is to directly echo the command's output.  Quiet
-`:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
+  commands like `:Git add` avoid the dreaded "Press ENTER or type command to
-write to it to stage the changes.  Use `:Gdiffsplit` to bring up the staged
+  continue" prompt.
-version of the file side by side with the working tree version and use
+* `:Git commit`, `:Git rebase -i`, and other commands that invoke an editor do
-Vim's diff handling capabilities to stage a subset of the file's
+  their editing in the current Vim instance.
-changes.
+* `: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.
 
-Commit, merge, and rebase with `:Gcommit`, `:Gmerge`, and `:Grebase`, using
+Additional commands are provided for higher level operations:
-the current Vim instance to edit commit messages and the rebase todo list.
-Use `:Gpush`, `:Gfetch`, and `:Gpull` to send and retrieve upstream changes.
 
-`:Gblame` brings up an interactive vertical split with `git blame`
+* View any blob, tree, commit, or tag in the repository with `:Gedit` (and
-output.  Press enter on a line to edit the commit where the line
+  `:Gsplit`, etc.).  For example, `:Gedit HEAD~3:%` loads the current file as
-changed, or `o` to open it in a split.  When you're done, use `:Gedit`
+  it existed 3 commits ago.
-in the historic buffer to go back to the work tree version.
+* `:Gdiffsplit` brings up the staged version of the file side by side with the
-
+  working tree version.  Use Vim's diff handling capabilities to apply changes
-`:Gmove` does a `git mv` on a file and simultaneously renames the
+  to the staged version, and write that buffer to stage the changes.  You can
-buffer.  `:Gdelete` does a `git rm` on a file and simultaneously deletes
+  also give an arbitrary `:Gedit` argument to diff against older versions of
-the buffer.
+  the file.
-
+* `:Gread` is a variant of `git checkout -- filename` that operates on the
-Use `:Ggrep` to search the work tree (or any arbitrary commit) with
+  buffer rather than the file itself.  This means you can use `u` to undo it
-`git grep`, skipping over that which is not tracked in the repository.
+  and you never get any warnings about the file changing outside Vim.
-`:Gclog` and `:Gllog` load all previous commits into the quickfix or location
+* `:Gwrite` writes to both the work tree and index versions of a file, making
-list.  Give them a range (e.g., using visual mode and `:'<,'>Gclog`) to
+  it like `git add` when called from a work tree file and like `git checkout`
-iterate over every change to that portion of the current file.
+  when called from the index or a blob in history.
-
+* `:Ggrep` is `:grep` for `git grep`.  `:Glgrep` is `:lgrep` for the same.
-`:Gread` is a variant of `git checkout -- filename` that operates on the
+* `:GMove` does a `git mv` on the current file and changes the buffer name to
-buffer rather than the filename.  This means you can use `u` to undo it
+  match.  `:GRename` does the same with a destination filename relative to the
-and you never get any warnings about the file changing outside Vim.
+  current file's directory.
-`:Gwrite` writes to both the work tree and index versions of a file,
+* `:GDelete` does a `git rm` on the current file and simultaneously deletes
-making it like `git add` when called from a work tree file and like
+  the buffer.  `:GRemove` does the same but leaves the (now empty) buffer
-`git checkout` when called from the index or a blob in history.
+  open.
-
+* `:GBrowse` to open the current file on the web front-end of your favorite
-Use `: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
-hosting provider, with optional line range (try it in visual mode).  Plugins
+  are available for popular providers such as [GitHub][rhubarb.vim],
-are available for popular providers such as [GitHub][rhubarb.vim],
+  [GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim],
-[GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim], and
+  [Gitee][fugitive-gitee.vim], [Pagure][pagure],
-[Gitee][fugitive-gitee.vim].
+  [Phabricator][vim-phabricator], [Azure DevOps][fugitive-azure-devops.vim],
+  and [sourcehut][srht.vim].
 
 [rhubarb.vim]: https://github.com/tpope/vim-rhubarb
 [fugitive-gitlab.vim]: https://github.com/shumphrey/fugitive-gitlab.vim
 [fubitive.vim]: https://github.com/tommcdo/vim-fubitive
 [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
 with the current branch in your statusline.
 
-Last but not least, there's `:Git` for running any arbitrary command.
-
 For more information, see `:help fugitive`.
 
 ## Screencasts
@@ -68,36 +86,34 @@ For more information, see `:help fugitive`.
 
 ## Installation
 
-If you don't have a preferred installation method, one option is to install
+Install using your favorite package manager, or use Vim's built-in package support:
-[pathogen.vim](https://github.com/tpope/vim-pathogen), and then copy
-and paste:
 
-    cd ~/.vim/bundle
+    mkdir -p ~/.vim/pack/tpope/start
-    git clone https://github.com/tpope/vim-fugitive.git
+    cd ~/.vim/pack/tpope/start
-    vim -u NONE -c "helptags vim-fugitive/doc" -c q
+    git clone https://tpope.io/vim/fugitive.git
+    vim -u NONE -c "helptags fugitive/doc" -c q
 
 ## FAQ
 
-> Why don't any of the commands exist?
+> What happened to the dispatch.vim backed asynchronous `:Gpush` and
+> `:Gfetch`?
 
-Fugitive cares about the current file, not the current working directory.
+This behavior was divisive, confusing, and complicated inputting passwords, so
-Edit a file from the repository.  To avoid the blank window problem, favor
+it was removed.  Use `:Dispatch git push` for effectively the same behavior,
-commands like `:split` and `:tabedit` over commands like `:new` and `:tabnew`.
+or provide your own asynchronous `:Gpush` and `:Gfetch` by adding the
+following to your vimrc:
 
-> Why can't I enter my password when I `:Gpush`?
+    command! -bang -bar -nargs=* Gpush execute 'Dispatch<bang> -dir=' .
+          \ fnameescape(FugitiveGitDir()) 'git push' <q-args>
+    command! -bang -bar -nargs=* Gfetch execute 'Dispatch<bang> -dir=' .
+          \ fnameescape(FugitiveGitDir()) 'git fetch' <q-args>
 
-It is highly recommended to use SSH keys or [credentials caching][] to avoid
+> So I have a symlink and...
-entering your password on every upstream interaction.  If this isn't an
-option, the official solution is to use the `core.askPass` Git option to
-request the password via a GUI.  Fugitive will configure this for you
-automatically if you have `ssh-askpass` or `git-gui` installed; otherwise it's
-your responsibility to set this up.
 
-As an absolute last resort, you can invoke `:Git --paginate push`.  Fugitive
+Stop.  Just stop.  If Git won't deal with your symlink, then Fugitive won't
-recognizes the pagination request and fires up a `:terminal`, which allows for
+either.  Consider using a [plugin that resolves
-interactive password entry.
+symlinks](https://github.com/aymericbeaumet/symlink.vim), or even better,
-
+using fewer symlinks.
-[credentials caching]: https://help.github.com/en/articles/caching-your-github-password-in-git
 
 ## Self-Promotion
 

doc/fugitive.txt

@@ -15,185 +15,31 @@ 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-:Gstatus*
+                                                *:Git* *fugitive-:G*
-:G                      Bring up a summary window vaguely akin to git-status.
+:Git {args}             Run an arbitrary git command and display any output.
-:Gstatus                Press g? or see |fugitive-mappings| for usage.
+:G {args}               On UNIX this uses a pty and on other platforms it uses
+                        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.
 
-                                                *fugitive-:Git*
+                                                *:Git_--paginate* *:Git_-p*
-:Git {args}             Run an arbitrary git command. Similar to :!git [args]
+:Git --paginate {args}  Run an arbitrary git command, capture output to a temp
-:G {args}               but chdir to the repository tree first.  For some
+:Git -p {args}          file, and |:split| that temp file.  Use :0Git to
-                        subcommands, a Fugitive command is called instead.
+:G --paginate {args}    |:edit| the temp file instead.  A temp file is always
-                        Invoking :Git push will call :Gpush for example.
+:G -p {args}            used for commands like diff and log that typically
+                        user a pager, and for any command that has the
+                        pager.<cmd> Git configuration option set.
 
-                                                *fugitive-:Git!*
+                                                *fugitive-summary*
-:Git! {args}            Like |:Git|, but capture the output into a temp file,
+:Git                    With no arguments, bring up a summary window vaguely
-:Git --no-pager {args}  and |:split| that temp file.  Use :0Git to
+:G                      akin to git-status.  Press g? or see |fugitive-maps|
-:Git -P {args}          |:edit| the temp file instead.  A temp file is always
+                        for usage.
-                        used for diff and log commands.
 
-                                                *fugitive-:Gcd*
+                                                *:Git_blame*
-:Gcd [directory]        |:cd| relative to the repository.
+:Git blame [flags]      Run git-blame [flags] on the current file and open the
-
-                                                *fugitive-:Glcd*
-:Glcd [directory]       |:lcd| relative to the repository.
-
-                                                *fugitive-:Gcommit*
-:Gcommit [args]         A wrapper around git-commit.  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
-                        the window (:wq) to finish the commit. To cancel, use
-                        an empty message.
-
-                                                *fugitive-:Grevert*
-:Grevert [args]         A wrapper around git-revert.  Similar to |:Gcommit|.
-
-                                                *fugitive-:Gmerge*
-: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.
-
-                                                *fugitive-:Gpull*
-:Gpull [args]           Like |:Gmerge|, but for git-pull.
-
-                                                *fugitive-:Grebase*
-:Grebase [args]         Like |:Gmerge|, but for git-rebase.  Interactive
-                        rebase is experimentally supported.
-
-                                                *fugitive-:Gpush*
-: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* *fugitive-:Gcgrep*
-:Ggrep[!] [args]        |:grep|[!] with git-grep as 'grepprg'.
-
-                                                *fugitive-:Glgrep*
-:Glgrep[!] [args]       |:lgrep|[!] with git-grep as 'grepprg'.
-
-                                        *fugitive-:Gclog* *fugitive-:Glog*
-:Gclog[!] [args]        Use git-log [args] to load the commit history into the
-:Glog[!] [args]         |quickfix| list.  Jump to the first commit unless [!]
-                        is given.
-
-:{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.
-
-                                                *fugitive-:Gllog*
-:Gllog [args]           Like |:Gclog|, but use the location list instead of the
-                        |quickfix| list.
-
-                                        *fugitive-:Gedit* *fugitive-:Ge*
-:Gedit [object]         |:edit| a |fugitive-object|.
-
-                                                *fugitive-:Gsplit*
-:Gsplit [object]        |:split| a |fugitive-object|.
-
-                                                *fugitive-:Gvsplit*
-:Gvsplit [object]       |:vsplit| a |fugitive-object|.
-
-                                                *fugitive-:Gtabedit*
-:Gtabedit [object]      |:tabedit| a |fugitive-object|.
-
-                                                *fugitive-:Gpedit*
-:Gpedit [object]        |:pedit| a |fugitive-object|.
-
-:Gsplit! [args]                 *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
-:Gvsplit! [args]                *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
-:Gtabedit! [args]       Capture the output of `git [args]` to a temp file and
-:Gpedit! [args]         open it in a split, tab, or preview window.  Use
-                        :0Gsplit! to suppress the split and open it in the
-                        current window.
-
-                                                *fugitive-:Gread*
-:Gread [object]         Empty the buffer and |:read| a |fugitive-object|.
-                        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}.
-
-                                                *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}.
-
-                                        *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
-                        great deal of effort is expended to behave sensibly
-                        when the work tree or index version of the file is
-                        open in another buffer.
-
-: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
-                        the index.
-
-                                                *fugitive-:Gwq*
-:Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
-                        succeeded.
-
-:Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
-                        succeeded.
-
-                                                *fugitive-:Gdiffsplit*
-:Gdiffsplit [object]    Perform a |vimdiff| against the given file, or if a
-                        commit is given, the current file in that commit.
-                        With no argument, the version in the index or work
-                        tree is used.  The newer of the two files is placed to
-                        the right or bottom, depending on 'diffopt' and the
-                        width of the window relative to 'textwidth'.  Use
-                        Vim's |do| and |dp| to stage and unstage changes.
-
-                                                *fugitive-:Gdiffsplit!*
-:Gdiffsplit!            Diff against any and all direct ancestors, retaining
-                        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 to obtain the hunk from the "ours" or
-                        "theirs" ancestor, respectively.
-
-:Gdiffsplit! {object}   Like |:Gdiffsplit|, but retain focus on the current
-                        window.
-
-                                                *fugitive-:Gvdiffsplit*
-:Gvdiffsplit [object]   Like |:Gdiffsplit|, but always split vertically.
-
-                                *fugitive-:Ghdiffsplit* *fugitive-:Gsdiff*
-:Ghdiffsplit [object]   Like |:Gdiffsplit|, but always split horizontally.
-
-                                                *fugitive-:Gmove*
-:Gmove {destination}    Wrapper around git-mv that renames the buffer
-                        afterward.  Add a ! to pass -f.
-
-                                                *fugitive-:Grename*
-:Grename {destination}  Like |:Gmove| but operates relative to the parent
-                        directory of the current file.
-
-                                                *fugitive-: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.
-
-                                                *fugitive-:Gremove*
-:Gremove                Like :Gdelete, but keep the (now empty) buffer around.
-
-                                                *fugitive-:Gblame*
-:Gblame [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:
@@ -213,46 +59,190 @@ that are part of Git repositories).
                         ~     reblame at [count]th first grandparent
                         P     reblame at [count]th parent (like HEAD^[count])
 
-:[range]Gblame [flags]  If a range is given, just that part of the file will
+                                                *g:fugitive_dynamic_colors*
-:Gblame [flags] {file}  be blamed, and a horizontal split without
+                        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.
 
-                                                *fugitive-:Gbrowse*
+                                                *:Git_difftool*
-:Gbrowse                Open the current file, blob, tree, commit, or tag
+:Git[!] difftool [args] Invoke `git diff [args]` and load the changes into the
-                        in your browser at the upstream hosting provider.
+                        quickfix list.  Each changed hunk gets a separate
-                        If a range is given, it is appropriately appended to
+                        quickfix entry unless you pass an option like
-                        the URL as an anchor.
+                        --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* *:Gcgrep* *:Git_grep*
+:Ggrep[!] [args]        |:grep|[!] with git-grep as 'grepprg'.
+:Git[!] grep [args]
+
+                                                *:Glgrep*
+:Glgrep[!] [args]       |:lgrep|[!] with git-grep as 'grepprg'.
+:0Git[!] grep [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*
+:Glcd [directory]       |:lcd| relative to the repository.
+
+                                                *:Gedit* *fugitive-:Ge*
+:Gedit [object]         |:edit| a |fugitive-object|.
+
+                                                *:Gsplit*
+:Gsplit [object]        |:split| a |fugitive-object|.
+
+                                                *:Gvsplit*
+:Gvsplit [object]       |:vsplit| a |fugitive-object|.
+
+                                                *:Gtabedit*
+:Gtabedit [object]      |:tabedit| a |fugitive-object|.
+
+                                                *:Gpedit*
+:Gpedit [object]        |:pedit| a |fugitive-object|.
+
+                                                *:Gread* *fugitive-:Gr*
+:Gread [object]         Empty the buffer and |:read| a |fugitive-object|.
+                        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}.
+
+                                                *:Gread!* *fugitive-:Gr!*
+: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*
+: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
+                        great deal of effort is expended to behave sensibly
+                        when the work tree or index version of the file is
+                        open in another buffer.
+
+: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
+                        the index.
+
+                                                *:Gwq*
+:Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
+                        succeeded.
+
+:Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
+                        succeeded.
+
+                                                *:Gdiffsplit*
+:Gdiffsplit [object]    Perform a |vimdiff| against the given file, or if a
+                        commit is given, the current file in that commit.
+                        With no argument, the version in the index or work
+                        tree is used.  The newer of the two files is placed to
+                        the right or bottom, depending on 'diffopt' and the
+                        width of the window relative to 'textwidth'.  Use
+                        Vim's |do| and |dp| to stage and unstage changes.
+
+                                                *:Gdiffsplit!*
+:Gdiffsplit!            Diff against any and all direct ancestors, retaining
+                        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
+                        window.
+
+                                                *:Gvdiffsplit*
+:Gvdiffsplit [object]   Like |:Gdiffsplit|, but always split vertically.
+
+                                                *:Ghdiffsplit*
+:Ghdiffsplit [object]   Like |:Gdiffsplit|, but always split horizontally.
+
+                                                *: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*
+:GRemove                Like |:GDelete|, but keep the (now empty) buffer around.
+
+                                                *: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>.
 
-:Gbrowse {object}       Like :Gbrowse, but for a given |fugitive-object|.
+:GBrowse {object}       Like :GBrowse, but for a given |fugitive-object|.
 
-:Gbrowse [...]@{remote} Force using the given remote rather than the remote
+:{range}GBrowse [args]  Appends an anchor to the URL that emphasizes the
-                        for the current branch.  The remote is used to
-                        determine which upstream repository to link to.
-
-:{range}Gbrowse [args]  Appends an anchor to the URL that emphasizes the
                         selected lines. This also forces the URL to include a
                         commit rather than a branch name so it remains valid
                         if the file changes.  You can give a range of "0" to
                         force this behavior without including an anchor.
 
-:[range]Gbrowse! [args] Like :Gbrowse, but put the URL on the clipboard rather
+: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.
+
+:GBrowse {url}          Open an arbitrary URL in your browser.
+
+:[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
                         than opening it.
 
-MAPPINGS                                        *fugitive-mappings*
+MAPS                                            *fugitive-maps*
 
-These mappings are available in both the |:Gstatus| buffer and Fugitive object
+These maps are available in both the |fugitive-summary| buffer and Fugitive
-buffers, although not all mappings make sense in all buffers.  Mappings that
+object buffers, although not all maps make sense in all buffers.  Mappings
-operate on the file or hunk under the cursor are generally available in visual
+that operate on the file or hunk under the cursor are generally available in
-mode to operate on multiple files or partial hunks.
+visual mode to operate on multiple files or partial hunks.
 
-                                                *fugitive-staging-mappings*
+                                                *fugitive-staging-maps*
-Staging/unstaging mappings ~
+Staging/unstaging maps ~
 
                                                 *fugitive_s*
 s                       Stage (add) the file or hunk under the cursor.
@@ -270,10 +260,9 @@ U                       Unstage everything.
 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.  You can use this during
+                        `:messages` to see it again.  During a merge conflict,
-                        a merge conflict do discard "our" changes (--theirs)
+                        use 2X to call `checkout --ours` or 3X to call
-                        in the "Unstaged" section or discard "their" changes
+                        `checkout --theirs` .
-                        (--ours) in the "Staged" section.
 
                                                 *fugitive_=*
 =                       Toggle an inline diff of the file under the cursor.
@@ -294,9 +283,9 @@ P                       under the cursor. On untracked files, this instead
                         calls |:Git| add --intent-to-add.
 
                                                 *fugitive_d*
-Diff mappings ~
+Diff maps ~
                                                 *fugitive_dp*
-dp                      Invoke |:Git!| diff on the file under the cursor.
+dp                      Invoke |:Git| diff on the file under the cursor.
                         Deprecated in favor of inline diffs.
 
                                                 *fugitive_dd*
@@ -315,8 +304,8 @@ dq                      Close all but one diff buffer, and |:diffoff|! the
                                                 *fugitive_d?*
 d?                      Show this help.
 
-                                                *fugitive-navigation-mappings*
+                                                *fugitive-navigation-maps*
-Navigation mappings ~
+Navigation maps ~
 
                                                 *fugitive_<CR>*
 <CR>                    Open the file or |fugitive-object| under the cursor.
@@ -395,7 +384,7 @@ i                       Jump to the next file or hunk, expanding inline diffs
 ][                      Jump [count] section ends forward.
 
                                                 *fugitive_star*
-*                       One the first column of a + or - diff line, search for
+*                       On the first column of a + or - diff line, search for
                         the corresponding - or + line.  Otherwise, defer to
                         built-in |star|.
 
@@ -426,7 +415,7 @@ gi                      Open .git/info/exclude in a split.  Use a count to
                         open .gitignore.
 
                                                 *fugitive_c*
-Commit mappings ~
+Commit maps ~
 
 cc                      Create a commit.
 
@@ -455,7 +444,7 @@ cS                      Create a `squash!` commit for the commit under the
 cA                      Create a `squash!` commit for the commit under the
                         cursor and edit the message.
 
-c<Space>                Populate command line with ":Gcommit ".
+c<Space>                Populate command line with ":Git commit ".
 
                                                 *fugitive_cr*
 crc                     Revert the commit under the cursor.
@@ -463,34 +452,34 @@ 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 ":Grevert ".
+cr<Space>               Populate command line with ":Git revert ".
 
                                                 *fugitive_cm*
-cm<Space>               Populate command line with ":Gmerge ".
+cm<Space>               Populate command line with ":Git merge ".
 
 c?                      Show this help.
 
                                                 *fugitive_cb*
                                                 *fugitive_co*
-Checkout/branch mappings ~
+Checkout/branch maps ~
 
 coo                     Check out the commit under the cursor.
 
-cb<Space>               Populate command line with ":G branch ".
+cb<Space>               Populate command line with ":Git branch ".
 
-co<Space>               Populate command line with ":G checkout ".
+co<Space>               Populate command line with ":Git checkout ".
 
 cb?                     Show this help.
 co?
 
                                                 *fugitive_cz*
-Stash mappings ~
+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
-                        `--include-index`.
+                        `--keep-index`.
 
 czA                     Apply topmost stash, or stash@{count}.
 
@@ -502,12 +491,12 @@ czP                     Pop topmost stash, or stash@{count}.
 czp                     Pop topmost stash, or stash@{count}, preserving the
                         index.
 
-cz<Space>               Populate command line with ":G stash ".
+cz<Space>               Populate command line with ":Git stash ".
 
 cz?                     Show this help.
 
                                                 *fugitive_r*
-Rebase mappings ~
+Rebase maps ~
 
 ri                      Perform an interactive rebase.  Uses ancestor of
 u                       commit under cursor as upstream if available.
@@ -538,12 +527,12 @@ rm                      Perform an interactive rebase with the commit under
 rd                      Perform an interactive rebase with the commit under
                         the cursor set to `drop`.
 
-r<Space>                Populate command line with ":Grebase ".
+r<Space>                Populate command line with ":Git rebase ".
 
 r?                      Show this help.
 
-                                                *fugitive-misc-mappings*
+                                                *fugitive-misc-maps*
-Miscellaneous mappings ~
+Miscellaneous maps ~
 
                                                 *fugitive_gq* *fugitive_q*
 gq                      Close the status buffer.
@@ -553,10 +542,10 @@ gq                      Close the status buffer.
                         cursor prepopulated.
 
                                                 *fugitive_g?*
-g?                      Show help for |fugitive-mappings|.
+g?                      Show help for |fugitive-maps|.
 
-                                                *fugitive-global-mappings*
+                                                *fugitive-global-maps*
-Global mappings ~
+Global maps ~
 
                                                 *fugitive_c_CTRL-R_CTRL-G*
 <C-R><C-G>              On the command line, recall the path to the current
@@ -566,6 +555,11 @@ Global mappings ~
                                                 *fugitive_y_CTRL-G*
 ["x]y<C-G>              Yank the path to the current |fugitive-object|.
 
+                                                *g:fugitive_no_maps*
+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
@@ -581,7 +575,7 @@ master^         The parent of the commit referenced by master
 master...other  The merge base of master and other
 master:         The tree referenced by master
 ./master        The file named master in the working directory
-:(top)master    The file named master in the the work tree
+:(top)master    The file named master in the work tree
 Makefile        The file named Makefile in the work tree
 @^:Makefile     The file named Makefile in the parent of HEAD
 :Makefile       The file named Makefile in the index (writable)
@@ -594,7 +588,9 @@ Makefile        The file named Makefile in the work tree
 !:Makefile      The file named Makefile in the commit owning the current file
 !3^2            The second parent of the commit owning buffer #3
 .git/config     The repo config file
-:               Same as |:Gstatus|
+:               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*
 
@@ -611,6 +607,39 @@ HEAD is detached, FugitiveHead() will return the empty string, unless the
 optional argument is given, in which case the hash of the current commit will
 be truncated to the given number of characters.
 
+DEPRECATIONS                                    *fugitive-deprecated*
+
+The following commands are softly deprecated in favor of replacements that
+adhere to a new naming scheme.  They will eventually be removed, but probably
+not in the near future.
+
+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).
+*:Git!*         Superseded by |:Git_--paginate|.
+*:Gsplit!*      Superseded by |:Git_--paginate|.
+*:Gvsplit!*     Superseded by :vert Git --paginate.
+*:Gtabsplit!*   Superseded by :tab Git --paginate.
+*:Gpedit!*      Superseded by :Git! --paginate.
+
 ABOUT                                           *fugitive-about*
 
 Grab the latest version or report a bug on GitHub:

ftplugin/fugitiveblame.vim

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

plugin/fugitive.vim

@@ -1,6 +1,6 @@
 " fugitive.vim - A Git wrapper so awesome, it should be illegal
 " Maintainer:   Tim Pope <http://tpo.pe/>
-" Version:      3.0
+" Version:      3.3
 " GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
 
 if exists('g:loaded_fugitive')
@@ -8,13 +8,31 @@ if exists('g:loaded_fugitive')
 endif
 let g:loaded_fugitive = 1
 
+let s:bad_git_dir = '/$\|^fugitive:'
+
 function! FugitiveGitDir(...) abort
-  if !a:0 || a:1 ==# -1
+  if !a:0 || type(a:1) == type(0) && a:1 < 0
-    return get(b:, 'git_dir', '')
+    if exists('g:fugitive_event')
+      return g:fugitive_event
+    endif
+    let dir = get(b:, 'git_dir', '')
+    if empty(dir) && (empty(bufname('')) || &buftype =~# '^\%(nofile\|acwrite\|quickfix\|prompt\)$')
+      return FugitiveExtractGitDir(getcwd())
+    elseif (!exists('b:git_dir') || b:git_dir =~# s:bad_git_dir) && empty(&buftype)
+      let b:git_dir = FugitiveExtractGitDir(expand('%:p'))
+      return b:git_dir
+    endif
+    return dir =~# s:bad_git_dir ? '' : dir
   elseif type(a:1) == type(0)
-    return getbufvar(a:1, 'git_dir')
+    if a:1 == bufnr('') && (!exists('b:git_dir') || b:git_dir =~# s:bad_git_dir) && empty(&buftype)
+      let b:git_dir = FugitiveExtractGitDir(expand('%:p'))
+    endif
+    let dir = getbufvar(a:1, 'git_dir')
+    return dir =~# s:bad_git_dir ? '' : dir
   elseif type(a:1) == type('')
     return substitute(s:Slash(a:1), '/$', '', '')
+  elseif type(a:1) == type({})
+    return get(a:1, 'git_dir', '')
   else
     return ''
   endif
@@ -59,8 +77,8 @@ function! FugitivePath(...) abort
 endfunction
 
 " FugitiveParse() takes a fugitive:// URL and returns a 2 element list
-" containing the Git dir and an object name ("commit:file").  It's effectively
+" containing an object name ("commit:file") and the Git dir.  It's effectively
-" then inverse of FugitiveFind().
+" the inverse of FugitiveFind().
 function! FugitiveParse(...) abort
   let path = s:Slash(a:0 ? a:1 : @%)
   if path !~# '^fugitive:'
@@ -74,6 +92,22 @@ function! FugitiveParse(...) abort
   throw v:errmsg
 endfunction
 
+" FugitiveResult() returns an object encapsulating the result of the most
+" recend :Git command.  Will be empty if no result is available.  Pass in the
+" name of a temp buffer to get the result object for that command instead.
+" Contains the following keys:
+"
+" * "args": List of command arguments, starting with the subcommand.  Will be
+"   empty for usages like :Git --help.
+" * "dir": Git dir of the relevant repository.
+" * "exit_status": The integer exit code of the process.
+" * "flags": Flags passed directly to Git, like -c and --help.
+" * "file": Path to file containing command output.  Not guaranteed to exist,
+"   so verify with filereadable() before trying to access it.
+function! FugitiveResult(...) abort
+  return call('fugitive#Result', a:000)
+endfunction
+
 " FugitivePrepare() constructs a Git command string which can be executed with
 " functions like system() and commands like :!.  Integer arguments will be
 " treated as buffer numbers, and the appropriate relative path inserted in
@@ -86,18 +120,66 @@ function! FugitivePrepare(...) abort
   return call('fugitive#Prepare', a:000)
 endfunction
 
+" FugitiveConfig() get returns an opaque structure that can be passed to other
+" FugitiveConfig functions in lieu of a Git directory.  This can be faster
+" when performing multiple config queries.  Do not rely on the internal
+" structure of the return value as it is not guaranteed.  If you want a full
+" dictionary of every config value, use FugitiveConfigGetRegexp('.*').
 function! FugitiveConfig(...) abort
-  if a:0 == 2 && type(a:2) != type({})
+  if a:0 == 2 && (type(a:2) != type({}) || has_key(a:2, 'git_dir'))
     return fugitive#Config(a:1, FugitiveGitDir(a:2))
-  elseif a:0 == 1 && a:1 !~# '^[[:alnum:]-]\+\.'
+  elseif a:0 == 1 && (type(a:1) !=# type('') || a:1 !~# '^[[:alnum:]-]\+\.')
     return fugitive#Config(FugitiveGitDir(a:1))
   else
     return call('fugitive#Config', a:000)
   endif
 endfunction
 
+" FugitiveConfigGet() retrieves a Git configuration value.  An optional second
+" argument provides the Git dir as with FugitiveFind().  Pass a blank string
+" to limit to the global config.
+function! FugitiveConfigGet(name, ...) abort
+  return call('FugitiveConfig', [a:name] + a:000)
+endfunction
+
+" FugitiveConfigGetAll() is like FugitiveConfigGet() but returns a list of
+" all values.
+function! FugitiveConfigGetAll(name, ...) abort
+  if a:0 && type(a:1) ==# type({}) && !has_key(a:1, 'git_dir')
+    let config = a:1
+  else
+    let config = fugitive#Config(FugitiveGitDir(a:0 ? a:1 : -1))
+  endif
+  let name = substitute(a:name, '^[^.]\+\|[^.]\+$', '\L&', 'g')
+  return copy(get(config, name, []))
+endfunction
+
+" FugitiveConfigGetRegexp() retrieves a dictionary of all configuration values
+" with a key matching the given pattern.  Like git config --get-regexp, but
+" using a Vim regexp.  Second argument has same semantics as
+" FugitiveConfigGet().
+function! FugitiveConfigGetRegexp(pattern, ...) abort
+  if a:0 && type(a:1) ==# type({}) && !has_key(a:2, 'git_dir')
+    let config = a:1
+  else
+    let config = fugitive#Config(FugitiveGitDir(a:0 ? a:1 : -1))
+  endif
+  let filtered = map(filter(copy(config), 'v:key =~# "\\." && v:key =~# a:pattern'), 'copy(v:val)')
+  if a:pattern !~# '\\\@<!\%(\\\\\)*\\z[se]'
+    return filtered
+  endif
+  let transformed = {}
+  for [k, v] in items(filtered)
+    let k = matchstr(k, a:pattern)
+    if len(k)
+      let transformed[k] = v
+    endif
+  endfor
+  return transformed
+endfunction
+
 function! FugitiveRemoteUrl(...) abort
-  return fugitive#RemoteUrl(a:0 ? a:1 : '', FugitiveGitDir(a:0 > 1 ? a:2 : -1))
+  return fugitive#RemoteUrl(a:0 ? a:1 : '', FugitiveGitDir(a:0 > 1 ? a:2 : -1), a:0 > 2 ? a:3 : 0)
 endfunction
 
 function! FugitiveHead(...) abort
@@ -109,7 +191,7 @@ function! FugitiveHead(...) abort
 endfunction
 
 function! FugitiveStatusline(...) abort
-  if !exists('b:git_dir')
+  if empty(get(b:, 'git_dir', ''))
     return ''
   endif
   return fugitive#Statusline()
@@ -150,16 +232,16 @@ function! s:Tree(path) abort
       let config = readfile(config_file,'',10)
       call filter(config,'v:val =~# "^\\s*worktree *="')
       if len(config) == 1
-        let worktree = s:Slash(FugitiveVimPath(matchstr(config[0], '= *\zs.*')))
+        let worktree = FugitiveVimPath(matchstr(config[0], '= *\zs.*'))
       endif
     elseif filereadable(dir . '/gitdir')
-      let worktree = s:Slash(fnamemodify(FugitiveVimPath(readfile(dir . '/gitdir')[0]), ':h'))
+      let worktree = fnamemodify(FugitiveVimPath(readfile(dir . '/gitdir')[0]), ':h')
       if worktree ==# '.'
         unlet! worktree
       endif
     endif
     if exists('worktree')
-      let s:worktree_for_dir[dir] = worktree
+      let s:worktree_for_dir[dir] = s:Slash(resolve(worktree))
       let s:dir_for_worktree[s:worktree_for_dir[dir]] = dir
     endif
   endif
@@ -170,10 +252,29 @@ function! s:Tree(path) abort
   endif
 endfunction
 
+function! s:CeilingDirectories() abort
+  if !exists('s:ceiling_directories')
+    let s:ceiling_directories = []
+    let resolve = 1
+    for dir in split($GIT_CEILING_DIRECTORIES, has('win32') ? ';' : ':', 1)
+      if empty(dir)
+        let resolve = 0
+      elseif resolve
+        call add(s:ceiling_directories, resolve(dir))
+      else
+        call add(s:ceiling_directories, dir)
+      endif
+    endfor
+  endif
+  return s:ceiling_directories + get(g:, 'ceiling_directories', [])
+endfunction
+
 function! FugitiveExtractGitDir(path) abort
   let path = s:Slash(a:path)
   if path =~# '^fugitive:'
     return matchstr(path, '\C^fugitive:\%(//\)\=\zs.\{-\}\ze\%(//\|::\|$\)')
+  elseif empty(path)
+    return ''
   elseif isdirectory(path)
     let path = fnamemodify(path, ':p:s?/$??')
   else
@@ -194,7 +295,7 @@ function! FugitiveExtractGitDir(path) abort
     if root =~# '\v^//%([^/]+/?)?$'
       break
     endif
-    if index(split($GIT_CEILING_DIRECTORIES, ':'), root) >= 0
+    if index(s:CeilingDirectories(), root) >= 0
       break
     endif
     if root ==# $GIT_WORK_TREE && FugitiveIsGitDir(env_git_dir)
@@ -226,18 +327,29 @@ function! FugitiveExtractGitDir(path) abort
 endfunction
 
 function! FugitiveDetect(path) abort
-  if exists('b:git_dir') && b:git_dir =~# '^$\|/$\|^fugitive:'
+  if exists('b:git_dir') && b:git_dir =~# '^$\|' . s:bad_git_dir
     unlet b:git_dir
   endif
   if !exists('b:git_dir')
-    let dir = FugitiveExtractGitDir(a:path)
+    let b:git_dir = FugitiveExtractGitDir(a:path)
-    if dir !=# ''
-      let b:git_dir = dir
-    endif
   endif
-  if exists('b:git_dir')
+  if empty(b:git_dir) || !exists('#User#Fugitive')
-    return fugitive#Init()
+    return ''
   endif
+  if v:version >= 704 || (v:version == 703 && has('patch442'))
+    doautocmd <nomodeline> User Fugitive
+  elseif &modelines > 0
+    let modelines = &modelines
+    try
+      set modelines=0
+      doautocmd User Fugitive
+    finally
+      let &modelines = modelines
+    endtry
+  else
+    doautocmd User Fugitive
+  endif
+  return ''
 endfunction
 
 function! FugitiveVimPath(path) abort
@@ -252,13 +364,15 @@ function! FugitiveGitPath(path) abort
   return s:Slash(a:path)
 endfunction
 
-function! s:Slash(path) abort
+if exists('+shellslash')
-  if exists('+shellslash')
+  function! s:Slash(path) abort
     return tr(a:path, '\', '/')
-  else
+  endfunction
+else
+  function! s:Slash(path) abort
     return a:path
-  endif
+  endfunction
-endfunction
+endif
 
 function! s:ProjectionistDetect() abort
   let file = s:Slash(get(g:, 'projectionist_file', ''))
@@ -278,65 +392,9 @@ function! s:ProjectionistDetect() abort
   endif
 endfunction
 
-augroup fugitive
+if v:version + has('patch061') < 703
-  autocmd!
+  runtime! autoload/fugitive.vim
-
+endif
-  autocmd BufNewFile,BufReadPost * call FugitiveDetect(expand('<amatch>:p'))
-  autocmd FileType           netrw call FugitiveDetect(fnamemodify(get(b:, 'netrw_curdir', expand('<amatch>')), ':p'))
-  autocmd User NERDTreeInit,NERDTreeNewRoot
-        \ if exists('b:NERDTree.root.path.str') |
-        \   call FugitiveDetect(b:NERDTree.root.path.str()) |
-        \ endif
-  autocmd VimEnter * if empty(expand('<amatch>'))|call FugitiveDetect(getcwd())|endif
-  autocmd CmdWinEnter * call FugitiveDetect(expand('#:p'))
-
-  autocmd FileType git
-        \ if len(FugitiveGitDir()) |
-        \   call fugitive#MapJumps() |
-        \   call fugitive#MapCfile() |
-        \ endif
-  autocmd FileType gitcommit
-        \ if len(FugitiveGitDir()) |
-        \   call fugitive#MapCfile('fugitive#MessageCfile()') |
-        \ endif
-  autocmd FileType fugitive
-        \ if len(FugitiveGitDir()) |
-        \   call fugitive#MapCfile('fugitive#StatusCfile()') |
-        \ endif
-  autocmd FileType gitrebase
-        \ let &l:include = '^\%(pick\|squash\|edit\|reword\|fixup\|drop\|[pserfd]\)\>' |
-        \ if len(FugitiveGitDir()) |
-        \   let &l:includeexpr = 'v:fname =~# ''^\x\{4,\}$'' ? FugitiveFind(v:fname) : ' .
-        \   (len(&l:includeexpr) ? &l:includeexpr : 'v:fname') |
-        \ endif |
-        \ let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') . '|setl inex= inc='
-
-  autocmd BufReadCmd index{,.lock}
-        \ if FugitiveIsGitDir(expand('<amatch>:p:h')) |
-        \   let b:git_dir = s:Slash(expand('<amatch>:p:h')) |
-        \   exe fugitive#BufReadStatus() |
-        \ elseif filereadable(expand('<amatch>')) |
-        \   silent doautocmd BufReadPre |
-        \   keepalt read <amatch> |
-        \   1delete_ |
-        \   silent doautocmd BufReadPost |
-        \ else |
-        \   silent doautocmd BufNewFile |
-        \ endif
-
-  autocmd BufReadCmd    fugitive://*//*             exe fugitive#BufReadCmd()
-  autocmd BufWriteCmd   fugitive://*//[0-3]/*       exe fugitive#BufWriteCmd()
-  autocmd FileReadCmd   fugitive://*//*             exe fugitive#FileReadCmd()
-  autocmd FileWriteCmd  fugitive://*//[0-3]/*       exe fugitive#FileWriteCmd()
-  if exists('##SourceCmd')
-    autocmd SourceCmd     fugitive://*//*    nested exe fugitive#SourceCmd()
-  endif
-
-  autocmd User Flags call Hoist('buffer', function('FugitiveStatusline'))
-
-  autocmd User ProjectionistDetect call s:ProjectionistDetect()
-augroup END
-
 let g:io_fugitive = {
       \ 'simplify': function('fugitive#simplify'),
       \ 'resolve': function('fugitive#resolve'),
@@ -353,3 +411,177 @@ let g:io_fugitive = {
       \ 'glob': function('fugitive#glob'),
       \ 'delete': function('fugitive#delete'),
       \ 'Real': function('FugitiveReal')}
+
+augroup fugitive
+  autocmd!
+
+  autocmd BufNewFile,BufReadPost * call FugitiveDetect(expand('<amatch>:p'))
+  autocmd FileType           netrw call FugitiveDetect(fnamemodify(get(b:, 'netrw_curdir', expand('<amatch>')), ':p'))
+
+  autocmd FileType git
+        \ call fugitive#MapCfile()
+  autocmd FileType gitcommit
+        \ call fugitive#MapCfile('fugitive#MessageCfile()')
+  autocmd FileType git,gitcommit
+        \ if &foldtext ==# 'foldtext()' |
+        \    setlocal foldtext=fugitive#Foldtext() |
+        \ endif
+  autocmd FileType fugitive
+        \ call fugitive#MapCfile('fugitive#StatusCfile()')
+  autocmd FileType gitrebase
+        \ let &l:include = '^\%(pick\|squash\|edit\|reword\|fixup\|drop\|[pserfd]\)\>' |
+        \ if &l:includeexpr !~# 'Fugitive' |
+        \   let &l:includeexpr = 'v:fname =~# ''^\x\{4,\}$'' && len(FugitiveGitDir()) ? FugitiveFind(v:fname) : ' .
+        \     (len(&l:includeexpr) ? &l:includeexpr : 'v:fname') |
+        \ endif |
+        \ let b:undo_ftplugin = get(b:, 'undo_ftplugin', 'exe') . '|setl inex= inc='
+
+  autocmd BufReadCmd index{,.lock}
+        \ if FugitiveIsGitDir(expand('<amatch>:p:h')) |
+        \   let b:git_dir = s:Slash(expand('<amatch>:p:h')) |
+        \   exe fugitive#BufReadStatus() |
+        \ elseif filereadable(expand('<amatch>')) |
+        \   silent doautocmd BufReadPre |
+        \   keepalt read <amatch> |
+        \   1delete_ |
+        \   silent doautocmd BufReadPost |
+        \ else |
+        \   silent doautocmd BufNewFile |
+        \ endif
+
+  autocmd BufReadCmd    fugitive://*//*             exe fugitive#BufReadCmd() |
+        \ if &path =~# '^\.\%(,\|$\)' |
+        \   let &l:path = substitute(&path, '^\.,\=', '', '') |
+        \ endif
+  autocmd BufWriteCmd   fugitive://*//[0-3]/*       exe fugitive#BufWriteCmd()
+  autocmd FileReadCmd   fugitive://*//*             exe fugitive#FileReadCmd()
+  autocmd FileWriteCmd  fugitive://*//[0-3]/*       exe fugitive#FileWriteCmd()
+  if exists('##SourceCmd')
+    autocmd SourceCmd     fugitive://*//*    nested exe fugitive#SourceCmd()
+  endif
+
+  autocmd User Flags call Hoist('buffer', function('FugitiveStatusline'))
+
+  autocmd User ProjectionistDetect call s:ProjectionistDetect()
+augroup END
+
+let s:addr_other = has('patch-8.1.560') ? '-addr=other' : ''
+let s:addr_tabs  = has('patch-7.4.542') ? '-addr=tabs' : ''
+let s:addr_wins  = has('patch-7.4.542') ? '-addr=windows' : ''
+
+if exists(':G') != 2
+  command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#Complete G   exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)
+endif
+command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#Complete Git exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)
+
+if exists(':Gstatus') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bang -bar     -range=-1' s:addr_other 'Gstatus exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+        \ '|echohl WarningMSG|echo ":Gstatus is deprecated in favor of :Git (with no arguments)"|echohl NONE'
+endif
+
+for s:cmd in ['Commit', 'Revert', 'Merge', 'Rebase', 'Pull', 'Push', 'Fetch', 'Blame']
+  if exists(':G' . tolower(s:cmd)) != 2 && get(g:, 'fugitive_legacy_commands', 1)
+    exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#' . s:cmd . 'Complete G' . tolower(s:cmd)
+          \ 'echohl WarningMSG|echo ":G' . tolower(s:cmd) . ' is deprecated in favor of :Git ' . tolower(s:cmd) . '"|echohl NONE|'
+          \ 'exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "' . tolower(s:cmd) . ' " . <q-args>)'
+  endif
+endfor
+unlet s:cmd
+
+exe "command! -bar -bang -nargs=? -complete=customlist,fugitive#CdComplete Gcd  exe fugitive#Cd(<q-args>, 0)"
+exe "command! -bar -bang -nargs=? -complete=customlist,fugitive#CdComplete Glcd exe fugitive#Cd(<q-args>, 1)"
+
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Ggrep  exe fugitive#GrepCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Gcgrep exe fugitive#GrepCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Glgrep exe fugitive#GrepCommand(0, <count> > 0 ? <count> : 0, +"<range>", <bang>0, "<mods>", <q-args>)'
+
+if exists(':Glog') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Glog  :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "")'
+        \ '|echohl WarningMSG|echo ":Glog is deprecated in favor of :Gclog"|echohl NONE'
+endif
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Gclog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "c")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete GcLog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "c")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Gllog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "l")'
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete GlLog :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "l")'
+
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Ge       exe fugitive#Open("edit<bang>", 0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#EditComplete   Gedit    exe fugitive#Open("edit<bang>", 0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=*                          -complete=customlist,fugitive#ReadComplete   Gpedit   exe fugitive#Open("pedit", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#ReadComplete   Gsplit   exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "split" : "edit"), <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_other '-complete=customlist,fugitive#ReadComplete   Gvsplit  exe fugitive#Open((<count> > 0 ? <count> : "").(<count> ? "vsplit" : "edit!"), <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -range=-1' s:addr_tabs  '-complete=customlist,fugitive#ReadComplete   Gtabedit exe fugitive#Open((<count> >= 0 ? <count> : "")."tabedit", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+if exists(':Gr') != 2
+  exe 'command! -bar -bang -nargs=* -range=-1                -complete=customlist,fugitive#ReadComplete   Gr     exe fugitive#ReadCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+endif
+exe 'command! -bar -bang -nargs=* -range=-1                -complete=customlist,fugitive#ReadComplete   Gread    exe fugitive#ReadCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gdiffsplit  exe fugitive#Diffsplit(1, <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Ghdiffsplit exe fugitive#Diffsplit(0, <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gvdiffsplit exe fugitive#Diffsplit(0, <bang>0, "vert <mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gw     exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwrite exe fugitive#WriteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=* -complete=customlist,fugitive#EditComplete Gwq    exe fugitive#WqCommand(   <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+
+exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject GRemove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject GDelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject GMove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete GRename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+if exists(':Gremove') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject Gremove exe fugitive#RemoveCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+        \ '|echohl WarningMSG|echo ":Gremove is deprecated in favor of :GRemove"|echohl NONE'
+endif
+if exists(':Gdelete') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bar -bang -nargs=0 -complete=customlist,fugitive#CompleteObject Gdelete exe fugitive#DeleteCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+        \ '|echohl WarningMSG|echo ":Gdelete is deprecated in favor of :GDelete"|echohl NONE'
+endif
+if exists(':Gmove') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#CompleteObject Gmove   exe fugitive#MoveCommand(  <line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+        \ '|echohl WarningMSG|echo ":Gmove is deprecated in favor of :GMove"|echohl NONE'
+endif
+if exists(':Grename') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bar -bang -nargs=1 -complete=customlist,fugitive#RenameComplete Grename exe fugitive#RenameCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+        \ '|echohl WarningMSG|echo ":Grename is deprecated in favor of :GRename"|echohl NONE'
+endif
+
+exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject GBrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+if exists(':Gbrowse') != 2 && get(g:, 'fugitive_legacy_commands', 1)
+  exe 'command! -bar -bang -range=-1 -nargs=* -complete=customlist,fugitive#CompleteObject Gbrowse exe fugitive#BrowseCommand(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>, [<f-args>])'
+        \ '|if <bang>1|redraw!|endif|echohl WarningMSG|echo ":Gbrowse is deprecated in favor of :GBrowse"|echohl NONE'
+endif
+
+if get(g:, 'fugitive_no_maps')
+  finish
+endif
+
+let s:nowait = v:version >= 704 ? '<nowait>' : ''
+
+function! s:Map(mode, lhs, rhs, ...) abort
+  for mode in split(a:mode, '\zs')
+    let flags = (a:0 ? a:1 : '') . (a:rhs =~# '<Plug>' ? '' : '<script>')
+    let head = a:lhs
+    let tail = ''
+    let keys = get(g:, mode.'remap', {})
+    if type(keys) == type([])
+      return
+    endif
+    while !empty(head)
+      if has_key(keys, head)
+        let head = keys[head]
+        if empty(head)
+          return
+        endif
+        break
+      endif
+      let tail = matchstr(head, '<[^<>]*>$\|.$') . tail
+      let head = substitute(head, '<[^<>]*>$\|.$', '', '')
+    endwhile
+    if flags !~# '<unique>' || empty(mapcheck(head.tail, mode))
+      exe mode.'map' s:nowait flags head.tail a:rhs
+    endif
+  endfor
+endfunction
+
+call s:Map('c', '<C-R><C-G>', 'fnameescape(fugitive#Object(@%))', '<expr>')
+call s:Map('n', 'y<C-G>', ':<C-U>call setreg(v:register, fugitive#Object(@%))<CR>', '<silent>')

syntax/fugitive.vim

@@ -8,6 +8,9 @@ syn spell notoplevel
 syn include @fugitiveDiff syntax/diff.vim
 
 syn match fugitiveHeader /^[A-Z][a-z][^:]*:/ nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
+syn match fugitiveBareHeader /^Bare:/
+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
@@ -20,8 +23,8 @@ syn match fugitiveDone /^done\>/ contained containedin=@fugitiveSection nextgrou
 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,\}\>/ contained containedin=@fugitiveSection
+syn match fugitiveHash /^\x\{4,\}\S\@!/ contained containedin=@fugitiveSection
-syn match fugitiveHash /\<\x\{4,\}\>/ contained
+syn match fugitiveHash /\S\@<!\x\{4,\}\S\@!/ contained
 
 syn region fugitiveHunk start=/^\%(@@\+ -\)\@=/ end=/^\%([A-Za-z?@]\|$\)\@=/ contains=@fugitiveDiff containedin=@fugitiveSection fold
 
@@ -33,7 +36,10 @@ for s:section in ['Untracked', 'Unstaged', 'Staged']
 endfor
 unlet s:section
 
+hi def link fugitiveBareHeader fugitiveHeader
+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