Attempt to allow :Gbrowse on HTTP GitHub FI

Escape # in :Glog
Closes #265.
2026-04-25 00:34:00 +08:00 · 2012-11-18 21:35:45 -05:00 · 2012-11-04 19:32:13 -05:00 · 2012-10-22 17:02:30 -04:00 · 2012-10-21 23:21:12 -04:00 · 2012-10-21 22:54:59 -04:00
4 changed files with 1491 additions and 365 deletions
@@ -0,0 +1 @@
 /doc/tags
@@ -0,0 +1,150 @@
 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.
 Last but not least, there's `:Git` for running any arbitrary command,
 and `Git!` to open the output of a command in a temp file.
 Screencasts
 -----------
 * [A complement to command line git](http://vimcasts.org/e/31)
 * [Working with the git index](http://vimcasts.org/e/32)
 * [Resolving merge conflicts with vimdiff](http://vimcasts.org/e/33)
 * [Browsing the git object database](http://vimcasts.org/e/34)
 * [Exploring the history of a git repository](http://vimcasts.org/e/35)
 Installation
 ------------
 If you don't have a preferred installation method, I recommend
 installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
 then simply copy and paste:
    cd ~/.vim/bundle
    git clone git://github.com/tpope/vim-fugitive.git
 Once help tags have been generated, you can view the manual with
 `:help fugitive`.
 If your Vim version is below 7.2, I recommend also installing
 [vim-git](https://github.com/tpope/vim-git) for syntax highlighting and
 other Git niceties.
 FAQ
 ---
 > 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.
 > Why is `:Gbrowse` not using the right browser?
 `:Gbrowse` delegates to `git web--browse`, which is less than perfect
 when it comes to finding the right browser.  You can tell it the correct
 browser to use with `git config --global web.browser ...`.  On OS X, for
 example, you might want to set this to `open`.  See `git web--browse --help`
 for details.
 > Here's a patch that automatically opens the quickfix window after
 > `:Ggrep`.
 This is a great example of why I recommend asking before patching.
 There are valid arguments to be made both for and against automatically
 opening the quickfix window.  Whenever I have to make an arbitrary
 decision like this, I ask what Vim would do.  And Vim does not open a
 quickfix window after `:grep`.
 Luckily, it's easy to implement the desired behavior without changing
 fugitive.vim.  The following autocommand will cause the quickfix window
 to open after any grep invocation:
    autocmd QuickFixCmdPost *grep* cwindow
 Contributing
 ------------
 Before reporting a bug, you should try stripping down your Vim
 configuration and removing other plugins.  The sad nature of VimScript
 is that it is fraught with incompatibilities waiting to happen.  I'm
 happy to work around them where I can, but it's up to you to isolate
 the conflict.
 If your [commit message sucks](http://stopwritingramblingcommitmessages.com/),
 I'm not going to accept your pull request.  I've explained very politely
 dozens of times that
 [my general guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
 are absolute rules on my own repositories, so I may lack the energy to
 explain it to you yet another time.  And please, if I ask you to change
 something, `git commit --amend`.
 Beyond that, don't be shy about asking before patching.  What takes you
 hours might take me minutes simply because I have both domain knowledge
 and a perverse knowledge of VimScript so vast that many would consider
 it a symptom of mental illness.  On the flip side, some ideas I'll
 reject no matter how good the implementation is.  "Send a patch" is an
 edge case answer in my book.
 Self-Promotion
 --------------
 Like fugitive.vim? Follow the repository on
 [GitHub](https://github.com/tpope/vim-fugitive) and vote for it on
 [vim.org](http://www.vim.org/scripts/script.php?script_id=2975).  And if
 you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
 [Twitter](http://twitter.com/tpope) and
 [GitHub](https://github.com/tpope).
 License
 -------
 Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
 See `:help license`.
@@ -1,38 +1,14 @@
 *fugitive.txt*  A Git wrapper so awesome, it should be illegal
-Author:  Tim Pope <vimNOSPAM@tpope.info>        *fugitive-author*
+Author:  Tim Pope <http://tpo.pe/>
 License: Same terms as Vim itself (see |license|)
 This plugin is only available if 'compatible' is not set.
 INTRODUCTION                                    *fugitive*
-Install in ~/.vim, or in ~\vimfiles if you're on Windows and feeling lucky.
+Whenever you edit a file from a Git repository, a set of commands is defined
-Vim 7.2 is recommended as it ships with syntax highlighting for many Git file
+that serve as a gateway to Git.
 types.
 If you're in a hurry to get started, here are some things to try:
 In any file in your repository, run |:Gedit| HEAD.  Press <CR> to jump to the
 current branch.  Press <CR> again to jump to the top most commit.  Keep using
 <CR> to explore parent commits, trees, and blobs.  Use C in a tree or blob to
 get back to the commit.
 Edit a file in the work tree and make some changes.  Use |:Gdiff| to open up
 the indexed version.  Use |do| and |dp| on various hunks to bring the files in
 sync, or use |:Gread| to pull in all changes.  Write the indexed version to
 stage the file.
 Run |:Gstatus| to check your repository's status.  Use "-" to stage and reset
 files and "p" to add/reset --patch them.  Invoke |:Gcommit| to commit your
 changes.
 Run |:Gblame| in a work tree file to see a blame in a vertical split.  Press
 <CR> on any line to reopen and reblame that file as it stood in that commit.
 Press o or O on any line to inspect that commit in a split or a tab.
 Run |:Ggrep| to search the work tree or history.  Run |:Gmove| to rename a
 file.  Run |:Gremove| to delete a file.
 COMMANDS                                        *fugitive-commands*
@@ -43,6 +19,10 @@ that are part of Git repositories).
 :Git [args]             Run an arbitrary git command. Similar to :!git [args]
                        but chdir to the repository tree first.
                                                *fugitive-:Git!*
 :Git! [args]            Like |:Git|, but capture the output into a temp file,
                        and edit that temp file.
                                                *fugitive-:Gcd*
 :Gcd [directory]        |:cd| relative to the repository.
@@ -51,9 +31,31 @@ 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
+                        window.  The following maps, which work on the cursor
-                        cursor line.  Press p to do so on a per hunk basis
+                        line file where sensible, are provided:
-                        (--patch).  Press C to invoke |:Gcommit|.
+
                        <C-N> next file
                        <C-P> previous file
                        <CR>  |:Gedit|
                        -     |:Git| add
                        -     |:Git| reset (staged files)
                        cA    |:Gcommit| --amend --reuse-message=HEAD
                        ca    |:Gcommit| --amend
                        cc    |:Gcommit|
                        cva   |:Gcommit| --amend --verbose
                        cvc   |:Gcommit| --verbose
                        D     |:Gdiff|
                        ds    |:Gsdiff|
                        dp    |:Git!| diff (p for patch; use :Gw to apply)
                        dp    |:Git| add --intent-to-add (untracked files)
                        dv    |:Gvdiff|
                        O     |:Gtabedit|
                        o     |:Gsplit|
                        p     |:Git| add --patch
                        p     |:Git| reset --patch (staged files)
                        q     close status
                        R     reload status
                        S     |:Gvsplit|
                                                *fugitive-:Gcommit*
 :Gcommit [args]         A wrapper around git-commit.  If there is nothing
@@ -70,12 +72,20 @@ that are part of Git repositories).
                                                *fugitive-:Ggrep*
 :Ggrep [args]           |:grep| with git-grep as 'grepprg'.
                                                *fugitive-:Glgrep*
 :Glgrep [args]          |:lgrep| with git-grep as 'grepprg'.
                                                *fugitive-:Glog*
 :Glog [args]            Load all previous revisions of the current file into
                        the quickfix list.  Additional git-log arguments can
                        be given (for example, --reverse).  If "--" appears as
                        an argument, no file specific filtering is done, and
-                        commits are loaded into the quickfix list.
+                        previous commits rather than previous file revisions
                        are loaded.
                                                *fugitive-:Gllog*
 :Gllog [args]           Like |:Glog|, but use the location list instead of the
                        quickfix list.
                                        *fugitive-:Gedit* *fugitive-:Ge*
 :Gedit [revision]       |:edit| a |fugitive-revision|.
@@ -87,10 +97,15 @@ that are part of Git repositories).
 :Gvsplit [revision]     |:vsplit| a |fugitive-revision|.
                                                *fugitive-:Gtabedit*
-:Gtabedit [revision]    |:tabedit| a |fugitive-revision|
+:Gtabedit [revision]    |:tabedit| a |fugitive-revision|.
                                                *fugitive-:Gpedit*
-:Gpedit [revision]      |:pedit| a |fugitive-revision|
+:Gpedit [revision]      |:pedit| a |fugitive-revision|.
 :Gsplit! [args]                 *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
 :Gvsplit! [args]                *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
 :Gtabedit! [args]       Like |:Git!|, but open the resulting temp file in a
 :Gpedit! [args]         split, tab, or preview window.
                                                *fugitive-:Gread*
 :Gread [revision]       Empty the buffer and |:read| a |fugitive-revision|.
@@ -102,7 +117,10 @@ that are part of Git repositories).
                        |:read| in a |fugitive-revision| after {range}.
                                                *fugitive-:Gread!*
-:Gread! [revision]      Deprecated synonym for |: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-:Gwrite*
 :Gwrite                 Write to the current file's path and stage the results.
@@ -117,6 +135,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 +151,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,14 +170,66 @@ 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 ltfnsewMC as flags and they will be passed
                        along to git-blame.  The following maps, which work on
                        the cursor line commit where sensible, are provided:
-:[range]Gblame          Run git-blame on the given range.
+                        A     resize to end of author column
                        C     resize to end of commit column
                        D     resize to end of date/time column
                        q     close blame and return to blamed window
                        gq    q, then |:Gedit| to return to work tree version
                        i     q, then open commit
                        o     open commit in horizontal split
                        O     open commit in new tab
                        -     reblame at commit
                        ~     reblame at [count]th first grandparent
                        P     reblame at [count]th parent (like HEAD^[count])
 :[range]Gblame [flags]  Run git-blame on the given range.
                                                *fugitive-:Gbrowse*
 :[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.
                        To use with GitHub FI, point g:fugitive_github_domains
                        at a list of domains:
 >
                        let g:fugitive_github_domains = ['git.example.com']
 ~
 :[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*
 These maps are available everywhere.
                                                *fugitive-c_CTRL-R_CTRL-G*
 <C-R><C-G>              On the command line, recall the path to the current
                        object (that is, a representation of the object
                        recognized by |:Gedit|).
                                                *fugitive-y_CTRL-G*
 ["x]y<C-G>              Yank the commit SHA and path to the current object.
 These maps are available in Git objects.
                                                *fugitive-<CR>*
@@ -155,9 +238,16 @@ These maps are available in Git objects.
                                                *fugitive-o*
 o                       Jump to the revision under the cursor in a new split.
                                                *fugitive-S*
 S                       Jump to the revision under the cursor in a new
                        vertical split.
                                                *fugitive-O*
 O                       Jump to the revision under the cursor in a new tab.
                                                *fugitive--*
 -                       Go to the tree containing the current tree or blob.
                                                *fugitive-~*
 ~                       Go to the current file in the [count]th first
                        ancestor.
@@ -208,6 +298,12 @@ a statusline, this one matches the default when 'ruler' is set:
 >
    set statusline=%<%f\ %h%m%r%{fugitive#statusline()}%=%-14.(%l,%c%V%)\ %P
 <
                                                *fugitive#head(...)*
 Use fugitive#head() to return the name of the current branch. If the current
 HEAD is detached, fugitive#head() 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.
 ABOUT                                           *fugitive-about*
 Grab the latest version or report a bug on GitHub: