fugitive.vim 1.2

This reverts commit 68b3f3b3d6.  Since
:saveas changes the alternate file, :Gmove should too.

.gitignore

@@ -0,0 +1 @@
+/doc/tags

README.markdown

@@ -0,0 +1,70 @@
+fugitive.vim
+============
+
+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:
+
+View any blob, tree, commit, or tag in the repository with `:Gedit` (and
+`:Gsplit`, `:Gvsplit`, `:Gtabedit`, ...).  Edit a file in the index and
+write to it to stage the changes.  Use `:Gdiff` to bring up the staged
+version of the file side by side with the working tree version and use
+Vim's diff handling capabilities to stage a subset of the file's
+changes.
+
+Bring up the output of `git status` with `:Gstatus`.  Press `-` to
+`add`/`reset` a file's changes, or `p` to `add`/`reset` `--patch` that
+mofo.  And guess what `:Gcommit` does!
+
+`:Gblame` brings up an interactive vertical split with `git blame`
+output.  Press enter on a line to reblame the file as it stood in that
+commit, or `o` to open that commit in a split.  When you're done, use
+`:Gedit` in the historic buffer to go back to the work tree version.
+
+`:Gmove` does a `git mv` on a file and simultaneously renames the
+buffer.  `:Gremove` does a `git rm` on a file and simultaneously deletes
+the buffer.
+
+Use `:Ggrep` to search the work tree (or any arbitrary commit) with
+`git grep`, skipping over that which is not tracked in the repository.
+`:Glog` loads all previous revisions of a file into the quickfix list so
+you can iterate over them and watch the file evolve!
+
+`:Gread` is a variant of `git checkout -- filename` that operates on the
+buffer rather than the filename.  This means you can use `u` to undo it
+and you never get any warnings about the file changing outside Vim.
+`:Gwrite` writes to both the work tree and index versions of a file,
+making it like `git add` when called from a work tree file and like
+`git checkout` when called from the index or a blob in history.
+
+Use `:Gbrowse` to open the current file on GitHub, with optional line
+range (try it in visual mode!).  If your current repository isn't on
+GitHub, `git instaweb` will be spun up instead.
+
+Add `%{fugitive#statusline()}` to `'statusline'` to get an indicator
+with the current branch in (surprise!) your statusline.
+
+Oh, and of course there's `:Git` for running any arbitrary command.
+
+Like fugitive.vim? Follow the repository on
+[GitHub](http://github.com/tpope/vim-fugitive) and vote for it on
+[vim.org](http://www.vim.org/scripts/script.php?script_id=2975).
+
+FAQ
+---
+
+> I installed the plugin and started Vim.  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.
+
+> I opened a new tab.  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.
+
+> I changed the current working directory.  Why do all the commands use
+> the old directory?
+
+Fugitive cares about the current file, not the current working
+directory.  Edit a file from the repository.

doc/fugitive.txt

@@ -1,6 +1,6 @@
 *fugitive.txt*  A Git wrapper so awesome, it should be illegal
 
-Author:  Tim Pope <vimNOSPAM@tpope.info>        *fugitive-author*
+Author:  Tim Pope <vimNOSPAM@tpope.org>         *fugitive-author*
 License: Same terms as Vim itself (see |license|)
 
 This plugin is only available if 'compatible' is not set.
@@ -51,9 +51,15 @@ that are part of Git repositories).
 
                                                 *fugitive-:Gstatus*
 :Gstatus                Bring up the output of git-status in the preview
-                        window.  Press - to stage or unstage the file on the
-                        cursor line.  Press p to do so on a per hunk basis
-                        (--patch).  Press C to invoke |:Gcommit|.
+                        window.  In addition to standard motions, you can
+                        use <C-N> and <C-P> to jump from filename to
+                        filename.  Press C to invoke |:Gcommit|.  Press D to
+                        |:Gdiff| the file on the cursor line, or ds to
+                        |:Gsdiff|.  Press - to stage or unstage the file on
+                        the cursor line.  Press p to do so on a per hunk basis
+                        (--patch).  All of D, -, and p have a different,
+                        sensible (and hopefully intuitive) behavior when
+                        invoked on a heading rather than a file name.
 
                                                 *fugitive-:Gcommit*
 :Gcommit [args]         A wrapper around git-commit.  If there is nothing
@@ -101,9 +107,6 @@ that are part of Git repositories).
 :{range}Gread [revision]
                         |:read| in a |fugitive-revision| after {range}.
 
-                                                *fugitive-:Gread!*
-:Gread! [revision]      Deprecated synonym for |:Gread|.
-
                                                 *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
@@ -117,6 +120,13 @@ that are part of Git repositories).
                         :0:foo.txt or even :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-:Gdiff*
 :Gdiff [revision]       Perform a |vimdiff| against the current file in the
                         given revision.  With no argument, the version in the
@@ -126,6 +136,12 @@ that are part of Git repositories).
                         to the right.  Use |do| and |dp| and write to the
                         index file to simulate "git add --patch".
 
+                                                *fugitive-:Gsdiff*
+:Gsdiff [revision]      Like |:Gdiff|, but split horizontally.
+
+                                                *fugitive-:Gvdiff*
+:Gvdiff [revision]      Identical to |:Gdiff|.  For symmetry with |:Gsdiff|.
+
                                                 *fugitive-:Gmove*
 :Gmove {destination}    Wrapper around git-mv that renames the buffer
                         afterward.  The destination is relative to the current
@@ -139,11 +155,35 @@ that are part of Git repositories).
                         buffer.
 
                                                 *fugitive-:Gblame*
-:Gblame                 Run git-blame on the file and open the results in a
+:Gblame [flags]         Run git-blame on the file and open the results in a
                         scroll bound vertical split.  Press enter on a line to
-                        reblame the file as it was in that commit.
+                        reblame the file as it was in that commit.  You can
+                        give any of ltwfsMC as flags and they will be passed
+                        along to git-blame.
 
-:[range]Gblame          Run git-blame on the given range.
+:[range]Gblame [flags]  Run git-blame on the given range.
+
+                                                *fugitive-:Gbrowse*
+:[range]Gbrowse         If the remote for the current branch is on GitHub,
+                        open the current file, blob, tree, commit, or tag
+                        (with git-web--browse) on GitHub.  Otherwise, open the
+                        current file, blob, tree, commit, or tag in
+                        git-instaweb (if you have issues, verify you can run
+                        "git instaweb" from a terminal).  If a range is given,
+                        it is appropriately appended to the URL as an anchor.
+
+:[range]Gbrowse!        Like :Gbrowse, but put the URL on the clipboard rather
+                        than opening it.
+
+:[range]Gbrowse {revision}
+                        Like :Gbrowse, but for a given |fugitive-revision|.  A
+                        useful value here is -, which ties the URL to the
+                        latest commit rather than a volatile branch.
+
+:[range]Gbrowse [...]@{remote}
+                        Force using the given remote rather than the remote
+                        for the current branch.  The remote is used to
+                        determine which GitHub repository to link to.
 
 MAPPINGS                                        *fugitive-mappings*