fugitive.vim 3.2

* Provide :Git mergetool to load conflicts into quickfix list.
* Provide :Git difftool to load arbitrary changesets into quickfix list.
* Call FugitiveBlob/FugitiveCommit/etc autocommands on Fugitive buffer load.
* :Git --paginate display results in temp buffer.
* :Git --no-pager no longer displays results in temp buffer.
* Accomodate loading Fugitive buffers in popup window.
* Better PowerShell support.
* Bug fixes.

.github/FUNDING.yml

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

README.markdown

@@ -4,8 +4,8 @@ I'm not going to lie to you; fugitive.vim may very well be the best
 Git wrapper of all time.  Check out these features:
 
 Bring up an enhanced version of `git status` with `:G` (also known as
-`:Gstatus`).  Press `g?` to bring up a list of mappings for numerous
+`:Gstatus`).  Press `g?` to bring up a list of maps for numerous operations
-operations including diffing, staging, committing, rebasing, and stashing.
+including diffing, staging, committing, rebasing, and stashing.
 
 View any blob, tree, commit, or tag in the repository with `:Gedit` (and
 `:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
@@ -33,6 +33,9 @@ Use `:Ggrep` to search the work tree (or any arbitrary commit) with
 list.  Give them a range (e.g., using visual mode and `:'<,'>Gclog`) to
 iterate over every change to that portion of the current file.
 
+`:Git mergetool` loads conflicts into the quickfix list.  `:Git difftool` does
+the same for any arbitrary set of changes.
+
 `: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.
@@ -43,13 +46,16 @@ making it like `git add` when called from a work tree file and like
 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
 are available for popular providers such as [GitHub][rhubarb.vim],
-[GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim], and
+[GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim],
-[Gitee][fugitive-gitee.vim].
+[Gitee][fugitive-gitee.vim], [Pagure][pagure], and
+[Phabricator][vim-phabricator].
 
 [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
 
 Add `%{FugitiveStatusline()}` to `'statusline'` to get an indicator
 with the current branch in your statusline.
@@ -68,22 +74,15 @@ 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?
-
-Fugitive cares about the current file, not the current working directory.
-Edit a file from the repository.  To avoid the blank window problem, favor
-commands like `:split` and `:tabedit` over commands like `:new` and `:tabnew`.
-
 > Why can't I enter my password when I `:Gpush`?
 
 It is highly recommended to use SSH keys or [credentials caching][] to avoid
@@ -93,9 +92,8 @@ 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
+If you absolutely must type in your password by hand, sidestep Fugitive and
-recognizes the pagination request and fires up a `:terminal`, which allows for
+use `:terminal git push`.
-interactive password entry.
 
 [credentials caching]: https://help.github.com/en/articles/caching-your-github-password-in-git
 

doc/fugitive.txt

@@ -15,186 +15,62 @@ 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.
-:Gstatus                Press g? or see |fugitive-mappings| for usage.
-
-                                                *fugitive-:Git*
 :Git {args}             Run an arbitrary git command. Similar to :!git [args]
 :G {args}               but chdir to the repository tree first.  For some
                         subcommands, a Fugitive command is called instead.
-                        Invoking :Git push will call :Gpush for example.
 
-                                                *fugitive-:Git!*
 :Git! {args}            Like |:Git|, but capture the output into a temp file,
-:Git --no-pager {args}  and |:split| that temp file.  Use :0Git to
+:Git --paginate {args}  and |:split| that temp file.  Use :0Git to
-:Git -P {args}          |:edit| the temp file instead.  A temp file is always
+:Git -p {args}          |:edit| the temp file instead.  A temp file is always
                         used for diff and log commands.
 
-                                                *fugitive-:Gcd*
+                                                *:Gstatus*
-:Gcd [directory]        |:cd| relative to the repository.
+:Git                    Bring up a summary window vaguely akin to git-status.
+:G                      Press g? or see |fugitive-maps| for usage.
+:Gstatus
 
-                                                *fugitive-:Glcd*
+                                                *:Git-commit* *:Gcommit*
-:Glcd [directory]       |:lcd| relative to the repository.
+:Git commit [args]      A wrapper around git-commit.  Unless the arguments
-
+:Gcommit [args]         given would skip the invocation of an editor (e.g.,
-                                                *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*
+                                                *:Git-revert* *:Grevert*
-:Grevert [args]         A wrapper around git-revert.  Similar to |:Gcommit|.
+:Git revert [args]      A wrapper around git-revert.  Similar to |:Gcommit|.
+:Grevert [args]
 
-                                                *fugitive-:Gmerge*
+                                                *:Git-merge* *:Gmerge*
-:Gmerge [args]          Calls git-merge and loads errors and conflicted files
+:Git merge [args]       Calls git-merge and loads errors and conflicted files
-                        into the |quickfix| list.  Opens a |:Gcommit| style
+:Gmerge [args]          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*
+                                                *:Git-pull* *:Gpull*
-:Gpull [args]           Like |:Gmerge|, but for git-pull.
+:Git pull [args]        Like |:Gmerge|, but for git-pull.
+:Gpull [args]
 
-                                                *fugitive-:Grebase*
+                                                *:Git-rebase* *:Grebase*
-:Grebase [args]         Like |:Gmerge|, but for git-rebase.  Interactive
+:Git rebase [args]      Like |:Gmerge|, but for git-rebase.  Interactive
-                        rebase is experimentally supported.
+:Grebase [args]         rebase is experimentally supported.
 
-                                                *fugitive-:Gpush*
+                                                *:Git-push* *:Gpush*
-:Gpush [args]           Invoke git-push, load the results into the |quickfix|
+:Git push [args]        Invoke git-push, load the results into the |quickfix|
-                        list, and invoke |:cwindow| to reveal any errors.
+:Gpush [args]           list, and invoke |:cwindow| to reveal any errors.
                         |:Dispatch| is used if available for asynchronous
                         invocation.
 
-                                                *fugitive-:Gfetch*
+                                                *:Git-fetch* *:Gfetch*
-:Gfetch [args]          Like |:Gpush|, but for git-fetch.
+:Git fetch [args]       Like |:Gpush|, but for git-fetch.
+:Gfetch [args]
 
-                                        *fugitive-:Ggrep* *fugitive-:Gcgrep*
+                                                *:Git-blame* *:Gblame*
-:Ggrep[!] [args]        |:grep|[!] with git-grep as 'grepprg'.
+:Git blame [flags]      Run git-blame [flags] on the current file and open the
-
+:Gblame [flags]         results in a scroll-bound vertical split.  The
-                                                *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:
 
@@ -215,10 +91,152 @@ that are part of Git repositories).
 
 :[range]Gblame [flags]  If a range is given, just that part of the file will
 :Gblame [flags] {file}  be blamed, and a horizontal split without
-                        scrollbinding is used.  You can also give an arbitrary
+:Git blame ...          scrollbinding is used.  You can also give an arbitrary
                         filename.
 
-                                                *fugitive-:Gbrowse*
+                                                *: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]
+
+                                                *: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.
+
+                                                 *:Gclog* *:Glog*
+:Gclog[!] [args]        Use git-log [args] to load the commit history into the
+:Glog[!] [args]         |quickfix| list.  Jumps 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.
+
+                                                *: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|.
+
+:Gsplit! [args]                                 *:Gsplit!* *:Gvsplit!*
+:Gvsplit! [args]                                *:Gtabedit!* *: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.
+
+                                                *: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* *:Gsdiff*
+: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.
                         If a range is given, it is appropriately appended to
@@ -244,15 +262,15 @@ that are part of Git repositories).
 :[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 |:Gstatus| buffer and Fugitive object
-buffers, although not all mappings make sense in all buffers.  Mappings that
+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-mappings*
+                                                *fugitive-staging-maps*
-Staging/unstaging mappings ~
+Staging/unstaging maps ~
 
                                                 *fugitive_s*
 s                       Stage (add) the file or hunk under the cursor.
@@ -294,7 +312,7 @@ 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.
                         Deprecated in favor of inline diffs.
@@ -315,8 +333,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.
@@ -426,7 +444,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 +473,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,28 +481,28 @@ 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`.
@@ -502,12 +520,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 +556,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 +571,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 +584,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 +604,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)

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.2
 " GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
 
 if exists('g:loaded_fugitive')
@@ -9,8 +9,15 @@ endif
 let g:loaded_fugitive = 1
 
 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())
+    endif
+    return dir
   elseif type(a:1) == type(0)
     return getbufvar(a:1, 'git_dir')
   elseif type(a:1) == type('')
@@ -59,8 +66,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:'
@@ -96,6 +103,24 @@ function! FugitiveConfig(...) abort
   endif
 endfunction
 
+" Retrieve 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
+
+" Like FugitiveConfigGet(), but return a list of all values.
+function! FugitiveConfigGetAll(name, ...) abort
+  if a:0 && type(a:1) ==# type({})
+    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
+
 function! FugitiveRemoteUrl(...) abort
   return fugitive#RemoteUrl(a:0 ? a:1 : '', FugitiveGitDir(a:0 > 1 ? a:2 : -1))
 endfunction
@@ -150,16 +175,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 +195,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 +238,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)
@@ -278,17 +322,31 @@ function! s:ProjectionistDetect() abort
   endif
 endfunction
 
+if v:version + has('patch061') < 703
+  runtime! autoload/fugitive.vim
+endif
+let g:io_fugitive = {
+      \ 'simplify': function('fugitive#simplify'),
+      \ 'resolve': function('fugitive#resolve'),
+      \ 'getftime': function('fugitive#getftime'),
+      \ 'getfsize': function('fugitive#getfsize'),
+      \ 'getftype': function('fugitive#getftype'),
+      \ 'filereadable': function('fugitive#filereadable'),
+      \ 'filewritable': function('fugitive#filewritable'),
+      \ 'isdirectory': function('fugitive#isdirectory'),
+      \ 'getfperm': function('fugitive#getfperm'),
+      \ 'setfperm': function('fugitive#setfperm'),
+      \ 'readfile': function('fugitive#readfile'),
+      \ 'writefile': function('fugitive#writefile'),
+      \ '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 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()) |
@@ -324,7 +382,10 @@ augroup fugitive
         \   silent doautocmd BufNewFile |
         \ endif
 
-  autocmd BufReadCmd    fugitive://*//*             exe fugitive#BufReadCmd()
+  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()
@@ -337,19 +398,93 @@ augroup fugitive
   autocmd User ProjectionistDetect call s:ProjectionistDetect()
 augroup END
 
-let g:io_fugitive = {
+let s:addr_other = has('patch-8.1.560') ? '-addr=other' : ''
-      \ 'simplify': function('fugitive#simplify'),
+let s:addr_tabs  = has('patch-7.4.542') ? '-addr=tabs' : ''
-      \ 'resolve': function('fugitive#resolve'),
+let s:addr_wins  = has('patch-7.4.542') ? '-addr=windows' : ''
-      \ 'getftime': function('fugitive#getftime'),
+
-      \ 'getfsize': function('fugitive#getfsize'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#Complete G   exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
-      \ 'getftype': function('fugitive#getftype'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#Complete Git exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
-      \ 'filereadable': function('fugitive#filereadable'),
+
-      \ 'filewritable': function('fugitive#filewritable'),
+exe 'command! -bang -bar     -range=-1' s:addr_other 'Gstatus exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", <q-args>)'
-      \ 'isdirectory': function('fugitive#isdirectory'),
+
-      \ 'getfperm': function('fugitive#getfperm'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#CommitComplete Gcommit exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "commit " . <q-args>)'
-      \ 'setfperm': function('fugitive#setfperm'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#RevertComplete Grevert exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "revert " . <q-args>)'
-      \ 'readfile': function('fugitive#readfile'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#MergeComplete  Gmerge  exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "merge " . <q-args>)'
-      \ 'writefile': function('fugitive#writefile'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#RebaseComplete Grebase exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "rebase " . <q-args>)'
-      \ 'glob': function('fugitive#glob'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#PullComplete   Gpull   exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "pull " . <q-args>)'
-      \ 'delete': function('fugitive#delete'),
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#PushComplete   Gpush   exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "push " . <q-args>)'
-      \ 'Real': function('FugitiveReal')}
+exe 'command! -bang -nargs=? -range=-1' s:addr_other '-complete=customlist,fugitive#FetchComplete  Gfetch  exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "fetch " . <q-args>)'
+exe 'command! -bang -nargs=? -range=-1                -complete=customlist,fugitive#BlameComplete  Gblame  exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "blame " . <q-args>)'
+
+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#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "grep " . <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Gcgrep exe fugitive#Command(<line1>, <count>, +"<range>", <bang>0, "<mods>", "grep " . <q-args>)'
+exe 'command! -bang -nargs=? -range=-1' s:addr_wins '-complete=customlist,fugitive#GrepComplete Glgrep exe fugitive#Command(0, <count> > 0 ? <count> : 0, +"<range>", <bang>0, "<mods>", "grep " . <q-args>)'
+
+exe 'command! -bang -nargs=? -range=-1 -complete=customlist,fugitive#LogComplete Glog  :exe fugitive#LogCommand(<line1>,<count>,+"<range>",<bang>0,"<mods>",<q-args>, "")'
+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! -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>])'
+
+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 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>')