mirror of
https://github.com/tpope/vim-fugitive.git
synced 2025-11-08 11:33:47 -05:00
Compare commits
2 Commits
v3.5
...
blame_mess
| Author | SHA1 | Date | |
|---|---|---|---|
|
62c50ff296 | ||
|
|
c2877d0d5c |
2
.gitattributes
vendored
2
.gitattributes
vendored
@@ -1,2 +0,0 @@
|
||||
.git* export-ignore
|
||||
*.markdown export-ignore
|
||||
2
.github/FUNDING.yml
vendored
2
.github/FUNDING.yml
vendored
@@ -1,2 +0,0 @@
|
||||
github: tpope
|
||||
custom: ["https://www.paypal.me/vimpope"]
|
||||
@@ -8,14 +8,8 @@ platform issues, and interactions with other plugins. I end up bisecting a
|
||||
lot more than other projects, and thus I'm especially meticulous here about
|
||||
maintaining a clean, readable, history. Squash and force push any requested
|
||||
changes to a pull request. And if your [commit message
|
||||
sucks](https://commit.style), I'm not going to accept it. Period.
|
||||
|
||||
If your contribution involves adding a configuration option, you are going to
|
||||
need a very compelling justification for it. Options add a maintenance
|
||||
burden, support burden, and documentation bloat, and oftentimes can be
|
||||
achieved much more simply with a custom map or autocommand. If your option
|
||||
controls an underlying Git command, ask yourself why Git itself does not offer
|
||||
such configuration.
|
||||
sucks](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html),
|
||||
I'm not going to accept it. Period.
|
||||
|
||||
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
|
||||
|
||||
161
README.markdown
161
README.markdown
@@ -1,80 +1,55 @@
|
||||
# fugitive.vim
|
||||
|
||||
Fugitive is the premier Vim plugin for Git. Or maybe it's the premier Git
|
||||
plugin for Vim? Either way, it's "so awesome, it should be illegal". That's
|
||||
why it's called Fugitive.
|
||||
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:
|
||||
|
||||
The crown jewel of Fugitive is `:Git` (or just `:G`), which calls any
|
||||
arbitrary Git command. If you know how to use Git at the command line, you
|
||||
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
|
||||
`: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.
|
||||
|
||||
* The default behavior is to directly echo the command's output. Quiet
|
||||
commands like `:Git add` avoid the dreaded "Press ENTER or type command to
|
||||
continue" prompt.
|
||||
* `:Git commit`, `:Git rebase -i`, and other commands that invoke an editor do
|
||||
their editing in the current Vim instance.
|
||||
* `:Git diff`, `:Git log`, and other verbose, paginated commands have their
|
||||
output loaded into a temporary buffer. Force this behavior for any command
|
||||
with `:Git --paginate` or `:Git -p`.
|
||||
* `:Git blame` uses a temporary buffer with maps for additional triage. Press
|
||||
enter on a line to view the commit where the line changed, or `g?` to see
|
||||
other available maps. Omit the filename argument and the currently edited
|
||||
file will be blamed in a vertical, scroll-bound split.
|
||||
* `:Git mergetool` and `:Git difftool` load their changesets into the quickfix
|
||||
list.
|
||||
* Called with no arguments, `:Git` opens a summary window with dirty files and
|
||||
unpushed and unpulled commits. Press `g?` to bring up a list of maps for
|
||||
numerous operations including diffing, staging, committing, rebasing, and
|
||||
stashing. (This is the successor to the old `:Gstatus`.)
|
||||
* This command (along with all other commands) always uses the current
|
||||
buffer's repository, so you don't need to worry about the current working
|
||||
directory.
|
||||
Bring up the output of `git status` with `:Gstatus`. Press `-` to
|
||||
`add`/`reset` a file's changes, or `p` to `add`/`reset` `--patch`. And guess
|
||||
what `:Gcommit` does!
|
||||
|
||||
Additional commands are provided for higher level operations:
|
||||
`:Gblame` brings up an interactive vertical split with `git blame`
|
||||
output. Press enter on a line to edit the commit where the line
|
||||
changed, or `o` to open it in a split. When you're done, use `:Gedit`
|
||||
in the historic buffer to go back to the work tree version.
|
||||
|
||||
* View any blob, tree, commit, or tag in the repository with `:Gedit` (and
|
||||
`:Gsplit`, etc.). For example, `:Gedit HEAD~3:%` loads the current file as
|
||||
it existed 3 commits ago.
|
||||
* `:Gdiffsplit` (or `:Gvdiffsplit`) 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 to the staged version, and write that buffer
|
||||
to stage the changes. You can also give an arbitrary `:Gedit` argument to
|
||||
diff against older versions of the file.
|
||||
* `:Gread` is a variant of `git checkout -- filename` that operates on the
|
||||
buffer rather than the file itself. This means you can use `u` to undo it
|
||||
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.
|
||||
* `:Ggrep` is `:grep` for `git grep`. `:Glgrep` is `:lgrep` for the same.
|
||||
* `:GMove` does a `git mv` on the current file and changes the buffer name to
|
||||
match. `:GRename` does the same with a destination filename relative to the
|
||||
current file's directory.
|
||||
* `:GDelete` does a `git rm` on the current file and simultaneously deletes
|
||||
the buffer. `:GRemove` does the same but leaves the (now empty) buffer
|
||||
open.
|
||||
* `:GBrowse` to open the current file on the web front-end of your favorite
|
||||
hosting provider, with optional line range (try it in visual mode). Plugins
|
||||
are available for popular providers such as [GitHub][rhubarb.vim],
|
||||
[GitLab][fugitive-gitlab.vim], [Bitbucket][fubitive.vim],
|
||||
[Gitee][fugitive-gitee.vim], [Pagure][pagure],
|
||||
[Phabricator][vim-phabricator], [Azure DevOps][fugitive-azure-devops.vim],
|
||||
and [sourcehut][srht.vim].
|
||||
`: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 the web front-end of your favorite
|
||||
hosting provider, with optional line range (try it in visual mode!). Built-in
|
||||
support is provided for `git instaweb`, and plugins are available for popular
|
||||
providers such as [GitHub][rhubarb.vim], [GitLab][fugitive-gitlab.vim], and
|
||||
[Bitbucket][fubitive.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.
|
||||
Add `%{fugitive#statusline()}` to `'statusline'` to get an indicator
|
||||
with the current branch in (surprise!) your statusline.
|
||||
|
||||
For more information, see `:help fugitive`.
|
||||
Last but not least, there's `:Git` for running any arbitrary command,
|
||||
and `Git!` to open the output of a command in a temp file.
|
||||
|
||||
## Screencasts
|
||||
|
||||
@@ -86,29 +61,53 @@ For more information, see `:help fugitive`.
|
||||
|
||||
## Installation
|
||||
|
||||
Install using your favorite package manager, or use Vim's built-in package support:
|
||||
If you don't have a preferred installation method, one option is to install
|
||||
[pathogen.vim](https://github.com/tpope/vim-pathogen), and then copy
|
||||
and paste:
|
||||
|
||||
mkdir -p ~/.vim/pack/tpope/start
|
||||
cd ~/.vim/pack/tpope/start
|
||||
git clone https://tpope.io/vim/fugitive.git
|
||||
vim -u NONE -c "helptags fugitive/doc" -c q
|
||||
cd ~/.vim/bundle
|
||||
git clone git://github.com/tpope/vim-fugitive.git
|
||||
vim -u NONE -c "helptags vim-fugitive/doc" -c q
|
||||
|
||||
If your Vim version is below 7.2, I recommend also installing
|
||||
[vim-git](https://github.com/tpope/vim-git) for syntax highlighting and
|
||||
other Git niceties.
|
||||
|
||||
## FAQ
|
||||
|
||||
> What happened to the dispatch.vim backed asynchronous `:Gpush` and
|
||||
> `:Gfetch`?
|
||||
> I installed the plugin and started Vim. Why don't any of the commands
|
||||
> exist?
|
||||
|
||||
This behavior was divisive, confusing, and complicated inputting passwords, so
|
||||
it was removed. Use `:Git! push` to use Fugitive's own asynchronous
|
||||
execution, or retroactively make `:Git push` asynchronous by pressing
|
||||
`CTRL-D`.
|
||||
Fugitive cares about the current file, not the current working
|
||||
directory. Edit a file from the repository.
|
||||
|
||||
> So I have a symlink and...
|
||||
> I opened a new tab. Why don't any of the commands exist?
|
||||
|
||||
Stop. Just stop. If Git won't deal with your symlink, then Fugitive won't
|
||||
either. Consider using a [plugin that resolves
|
||||
symlinks](https://github.com/aymericbeaumet/symlink.vim), or even better,
|
||||
using fewer symlinks.
|
||||
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
|
||||
|
||||
## Self-Promotion
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
877
doc/fugitive.txt
877
doc/fugitive.txt
@@ -15,156 +15,144 @@ COMMANDS *fugitive-commands*
|
||||
These commands are local to the buffers in which they work (generally, buffers
|
||||
that are part of Git repositories).
|
||||
|
||||
*fugitive-:G*
|
||||
:G [args] Same as :Git, but two characters shorter.
|
||||
*fugitive-:Git*
|
||||
:Git [args] Run an arbitrary git command. Similar to :!git [args]
|
||||
but chdir to the repository tree first.
|
||||
|
||||
*:Git*
|
||||
:Git {args} Run an arbitrary git command and display any output.
|
||||
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! [args] Like |:Git|, but capture the output into a temp file,
|
||||
and edit that temp file.
|
||||
|
||||
*:Git!*
|
||||
:Git! {args} Run an arbitrary git command in the background and
|
||||
stream the output to the preview window. Requires a
|
||||
Vim with |setbufline()|. Press CTRL-D during an
|
||||
interactive :Git invocation to switch to this mode
|
||||
retroactively.
|
||||
|
||||
*:Git_--paginate* *:Git_-p*
|
||||
:Git --paginate {args} Run an arbitrary git command, capture output to a temp
|
||||
:Git -p {args} file, and |:split| that temp file. Pass ++curwin as
|
||||
the first argument to |:edit| the temp file instead.
|
||||
A temp file is always used for commands like diff and
|
||||
log that typically uses a pager, and for any command
|
||||
that has the pager.<cmd> Git configuration option set.
|
||||
|
||||
:{range}Git! --paginate {args}
|
||||
:{range}Git! -p {args} Run an arbitrary git command, and insert the output
|
||||
after {range} in the current buffer.
|
||||
|
||||
*fugitive-summary*
|
||||
:Git With no arguments, bring up a summary window vaguely
|
||||
akin to git-status. Press g? or see |fugitive-maps|
|
||||
for usage.
|
||||
|
||||
*:Git_blame*
|
||||
:Git blame [flags] Run git-blame [flags] on the current file and open the
|
||||
results in a scroll-bound vertical split. The
|
||||
following maps, which work on the cursor line commit
|
||||
where sensible, are provided:
|
||||
|
||||
g? show this help
|
||||
A resize to end of author column
|
||||
C resize to end of commit column
|
||||
D resize to end of date/time column
|
||||
gq close blame, then |:Gedit| to return to work
|
||||
tree version
|
||||
<CR> close blame, and jump to patch that added line
|
||||
(or directly to blob for boundary commit)
|
||||
o jump to patch or blob in horizontal split
|
||||
O jump to patch or blob in new tab
|
||||
p jump to patch or blob in preview window
|
||||
- reblame at commit
|
||||
~ reblame at [count]th first grandparent
|
||||
P reblame at [count]th parent (like HEAD^[count])
|
||||
|
||||
*g:fugitive_dynamic_colors*
|
||||
In the GUI or a 256 color terminal, commit hashes will
|
||||
highlighted in different colors. To disable this:
|
||||
>
|
||||
let g:fugitive_dynamic_colors = 0
|
||||
<
|
||||
:[range]Git blame [...] If a range is given, just that part of the file will
|
||||
:Git blame [...] {file} be blamed, and a horizontal split without
|
||||
scrollbinding is used. You can also give an arbitrary
|
||||
filename.
|
||||
|
||||
*:Git_difftool*
|
||||
:Git[!] difftool [args] Invoke `git diff [args]` and load the changes into the
|
||||
quickfix list. Each changed hunk gets a separate
|
||||
quickfix entry unless you pass an option like
|
||||
--name-only or --name-status. Jumps to the first
|
||||
change unless [!] is given.
|
||||
|
||||
:Git difftool -y [args] Invoke `git diff [args]`, open each changed file in a
|
||||
new tab, and invoke |:Gdiffsplit!| against the
|
||||
appropriate commit.
|
||||
|
||||
*:Git_mergetool*
|
||||
:Git mergetool [args] Like |:Git_difftool|, but target merge conflicts.
|
||||
|
||||
*:Ggrep* *:Git_grep*
|
||||
:Ggrep[!] [args] An approximation of |:grep|[!] with git-grep as
|
||||
:Git[!] grep -O [args] 'grepprg'.
|
||||
|
||||
:Ggrep[!] --quiet [args]
|
||||
:Ggrep[!] -q [args] Like |:Ggrep|, but instead of displaying output, open
|
||||
the quickfix list.
|
||||
|
||||
*:Glgrep*
|
||||
:Glgrep[!] [args] :Ggrep but for |:lgrep|.
|
||||
:0Git[!] grep -O [args]
|
||||
|
||||
*:Gclog*
|
||||
:Gclog[!] [args] Use git-log [args] to load the commit history into the
|
||||
|quickfix| list. Jumps to the first commit unless [!]
|
||||
is given.
|
||||
|
||||
The quickfix list can be awkward for many use cases
|
||||
and exhibits extremely poor performance with larger
|
||||
data sets. Consider using |:Git| log instead.
|
||||
|
||||
:{range}Gclog[!] [args] Use git-log -L to load previous revisions of the given
|
||||
range of the current file into the |quickfix| list.
|
||||
The cursor is positioned on the first line of the
|
||||
first diff hunk for each commit. Use :0Gclog to
|
||||
target the entire file.
|
||||
|
||||
*:Gllog*
|
||||
:Gllog [args] Like |:Gclog|, but use the location list instead of the
|
||||
|quickfix| list.
|
||||
|
||||
*:Gcd*
|
||||
*fugitive-:Gcd*
|
||||
:Gcd [directory] |:cd| relative to the repository.
|
||||
|
||||
*:Glcd*
|
||||
*fugitive-:Glcd*
|
||||
:Glcd [directory] |:lcd| relative to the repository.
|
||||
|
||||
*:Gedit* *fugitive-:Ge*
|
||||
:Gedit [object] |:edit| a |fugitive-object|.
|
||||
*fugitive-:Gstatus*
|
||||
:Gstatus Bring up the output of git-status in the preview
|
||||
window. The following maps, which work on the cursor
|
||||
line file where sensible, are provided:
|
||||
|
||||
*:Gsplit*
|
||||
:Gsplit [object] |:split| a |fugitive-object|.
|
||||
g? show this help
|
||||
<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|
|
||||
U |:Git| checkout
|
||||
U |:Git| checkout HEAD (staged files)
|
||||
U |:Git| clean (untracked files)
|
||||
U |:Git| rm (unmerged files)
|
||||
|
||||
*:Gvsplit*
|
||||
:Gvsplit [object] |:vsplit| a |fugitive-object|.
|
||||
*fugitive-:Gcommit*
|
||||
:Gcommit [args] A wrapper around git-commit. If there is nothing
|
||||
to commit, |:Gstatus| is called instead. Unless the
|
||||
arguments given would skip the invocation of an editor
|
||||
(e.g., -m), a split window will be used to obtain a
|
||||
commit message, or a new tab if -v is given. Write
|
||||
and close that window (:wq or |:Gwrite|) to finish the
|
||||
commit. Unlike when running the actual git-commit
|
||||
command, it is possible (but unadvisable) to alter the
|
||||
index with commands like git-add and git-reset while a
|
||||
commit message is pending.
|
||||
|
||||
*:Gtabedit*
|
||||
:Gtabedit [object] |:tabedit| a |fugitive-object|.
|
||||
*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.
|
||||
|
||||
*:Gpedit*
|
||||
:Gpedit [object] |:pedit| a |fugitive-object|.
|
||||
*fugitive-:Gpull*
|
||||
:Gpull [args] Like |:Gmerge|, but for git-pull.
|
||||
|
||||
*:Gread* *fugitive-:Gr*
|
||||
:Gread [object] Empty the buffer and |:read| a |fugitive-object|.
|
||||
*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*
|
||||
:Ggrep[!] [args] |:grep|[!] with git-grep as 'grepprg'.
|
||||
|
||||
*fugitive-:Glgrep*
|
||||
:Glgrep[!] [args] |:lgrep|[!] with git-grep as 'grepprg'.
|
||||
|
||||
*fugitive-:Glog*
|
||||
:Glog [args] Load all previous revisions of the current file into
|
||||
the quickfix list. Additional git-log arguments can
|
||||
be given (for example, --reverse). If "--" appears as
|
||||
an argument, no file specific filtering is done, and
|
||||
previous commits rather than previous file revisions
|
||||
are loaded.
|
||||
|
||||
:{range}Glog [args] Use git-log -L to load previous revisions of the given
|
||||
range of the current file into the quickfix list. The
|
||||
cursor is positioned on the first line of the first
|
||||
diff hunk for each commit.
|
||||
|
||||
*fugitive-:Gllog*
|
||||
:Gllog [args] Like |:Glog|, but use the location list instead of the
|
||||
quickfix list.
|
||||
|
||||
*fugitive-:Gedit* *fugitive-:Ge*
|
||||
:Gedit [revision] |:edit| a |fugitive-revision|.
|
||||
|
||||
*fugitive-:Gsplit*
|
||||
:Gsplit [revision] |:split| a |fugitive-revision|.
|
||||
|
||||
*fugitive-:Gvsplit*
|
||||
:Gvsplit [revision] |:vsplit| a |fugitive-revision|.
|
||||
|
||||
*fugitive-:Gtabedit*
|
||||
:Gtabedit [revision] |:tabedit| a |fugitive-revision|.
|
||||
|
||||
*fugitive-:Gpedit*
|
||||
:Gpedit [revision] |:pedit| a |fugitive-revision|.
|
||||
|
||||
:Gsplit! [args] *fugitive-:Gsplit!* *fugitive-:Gvsplit!*
|
||||
:Gvsplit! [args] *fugitive-:Gtabedit!* *fugitive-:Gpedit!*
|
||||
:Gtabedit! [args] Like |:Git!|, but open the resulting temp file in a
|
||||
:Gpedit! [args] split, tab, or preview window.
|
||||
|
||||
*fugitive-:Gread*
|
||||
:Gread [revision] Empty the buffer and |:read| a |fugitive-revision|.
|
||||
When the argument is omitted, this is similar to
|
||||
git-checkout on a work tree file or git-add on a stage
|
||||
file, but without writing anything to disk.
|
||||
|
||||
:{range}Gread [object] |:read| in a |fugitive-object| after {range}.
|
||||
:{range}Gread [revision]
|
||||
|:read| in a |fugitive-revision| after {range}.
|
||||
|
||||
*:Gread!* *fugitive-:Gr!*
|
||||
*fugitive-:Gread!*
|
||||
:Gread! [args] Empty the buffer and |:read| the output of a Git
|
||||
command. For example, :Gread! show HEAD:%.
|
||||
|
||||
:{range}Gread! [args] |:read| the output of a Git command after {range}.
|
||||
:{range}Gread! [args] |:read| the output of a Git command after {range}.
|
||||
|
||||
*:Gwrite* *fugitive-:Gw*
|
||||
*fugitive-:Gw* *fugitive-:Gwrite*
|
||||
:Gwrite Write to the current file's path and stage the results.
|
||||
When run in a work tree file, it is effectively git
|
||||
add. Elsewhere, it is effectively git-checkout. A
|
||||
@@ -174,545 +162,196 @@ that are part of Git repositories).
|
||||
|
||||
:Gwrite {path} You can give |:Gwrite| an explicit path of where in
|
||||
the work tree to write. You can also give a path like
|
||||
:0:foo.txt or :0:% to write to just that stage in
|
||||
:0:foo.txt or even :0 to write to just that stage in
|
||||
the index.
|
||||
|
||||
*:Gwq*
|
||||
*fugitive-:Gwq*
|
||||
:Gwq [path] Like |:Gwrite| followed by |:quit| if the write
|
||||
succeeded.
|
||||
|
||||
:Gwq! [path] Like |:Gwrite|! followed by |:quit|! if the write
|
||||
succeeded.
|
||||
|
||||
*:Gdiffsplit*
|
||||
: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, and the work tree version is always
|
||||
placed to the right or bottom, depending on available
|
||||
width. Use Vim's |do| and |dp| to stage and unstage
|
||||
changes.
|
||||
*fugitive-:Gdiff*
|
||||
:Gdiff [revision] Perform a |vimdiff| against the current file in the
|
||||
given revision. With no argument, the version in the
|
||||
index is used (which means a three-way diff during a
|
||||
merge conflict, making it a git-mergetool
|
||||
alternative). 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
|
||||
|do| and |dp| and write to the index file to simulate
|
||||
"git add --patch". For the three-way diff, there is
|
||||
also d2o and d3o pulling the hunk to the middle from
|
||||
the left or the right window, respectively.
|
||||
|
||||
*: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.
|
||||
*fugitive-:Gsdiff*
|
||||
:Gsdiff [revision] Like |:Gdiff|, but always split horizontally.
|
||||
|
||||
:Gdiffsplit! {object} Like |:Gdiffsplit|, but retain focus on the current
|
||||
window.
|
||||
*fugitive-:Gvdiff*
|
||||
:Gvdiff [revision] Like |:Gdiff|, but always split vertically.
|
||||
|
||||
*:Gvdiffsplit*
|
||||
:Gvdiffsplit [object] Like |:Gdiffsplit|, but always split vertically.
|
||||
*fugitive-:Gmove*
|
||||
:Gmove {destination} Wrapper around git-mv that renames the buffer
|
||||
afterward. The destination is relative to the current
|
||||
directory except when started with a /, in which case
|
||||
it is relative to the work tree. Add a ! to pass -f.
|
||||
|
||||
*:Ghdiffsplit*
|
||||
:Gdiffsplit ++novertical [object]
|
||||
:Ghdiffsplit [object] Like |:Gdiffsplit|, but with "vertical" removed from
|
||||
'diffopt'. The split will still be vertical if
|
||||
combined with |:vertical|.
|
||||
|
||||
*:GMove*
|
||||
:GMove {destination} Wrapper around git-mv that renames the buffer
|
||||
afterward. Add a ! to pass -f.
|
||||
|
||||
*:GRename*
|
||||
:GRename {destination} Like |:GMove| but operates relative to the parent
|
||||
directory of the current file.
|
||||
|
||||
*:GDelete*
|
||||
:GDelete Wrapper around git-rm that deletes the buffer
|
||||
*fugitive-:Gremove*
|
||||
:Gremove 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.
|
||||
*fugitive-:Gblame*
|
||||
:Gblame [flags] Run git-blame on the file and open the results in a
|
||||
scroll bound vertical split. You can give any of
|
||||
ltfnsewMC as flags and they will be passed along to
|
||||
git-blame. The following maps, which work on the
|
||||
cursor line commit where sensible, are provided:
|
||||
|
||||
*:GBrowse*
|
||||
:GBrowse Open the current file, blob, tree, commit, or tag
|
||||
g? show this help
|
||||
A resize to end of author column
|
||||
C resize to end of commit column
|
||||
D resize to end of date/time column
|
||||
q close blame and return to blamed window
|
||||
gq q, then |:Gedit| to return to work tree version
|
||||
<CR> q, then open commit
|
||||
o open commit in horizontal split
|
||||
O open commit in new tab
|
||||
- reblame at commit
|
||||
~ reblame at [count]th first grandparent
|
||||
P reblame at [count]th parent (like HEAD^[count])
|
||||
|
||||
:[range]Gblame [flags] Run git-blame on the given range.
|
||||
|
||||
*fugitive-:Gbrowse*
|
||||
:Gbrowse Open the current file, blob, tree, commit, or tag
|
||||
in your browser at the upstream hosting provider.
|
||||
If a range is given, it is appropriately appended to
|
||||
the URL as an anchor.
|
||||
|
||||
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|.
|
||||
The hosting provider is determined by looking at the
|
||||
remote for the current or specified branch and falls
|
||||
back to "origin". In the special case of a "."
|
||||
remote, a local instance of git-instaweb will be
|
||||
started and used.
|
||||
|
||||
:{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.
|
||||
: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.
|
||||
|
||||
:GBrowse [...]@{remote} Force using the given remote rather than the remote
|
||||
:Gbrowse [...]@{remote} Force using the given remote rather than the remote
|
||||
for the current branch. The remote is used to
|
||||
determine which upstream repository to link to.
|
||||
determine which GitHub repository to link to.
|
||||
|
||||
:GBrowse {url} Open an arbitrary URL in your browser.
|
||||
:{range}Gbrowse [args] Appends an anchor to the URL that emphasizes the
|
||||
selected lines. You almost certainly want to give a
|
||||
"-" argument in this case to force the URL to include
|
||||
an exact revision.
|
||||
|
||||
:[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
|
||||
:[range]Gbrowse! [args] Like :Gbrowse, but put the URL on the clipboard rather
|
||||
than opening it.
|
||||
|
||||
MAPS *fugitive-maps*
|
||||
MAPPINGS *fugitive-mappings*
|
||||
|
||||
These maps are available in both the |fugitive-summary| buffer and Fugitive
|
||||
object buffers, although not all maps make sense in all buffers. Mappings
|
||||
that operate on the file or hunk under the cursor are generally available in
|
||||
visual mode to operate on multiple files or partial hunks.
|
||||
These maps are available everywhere.
|
||||
|
||||
*fugitive-staging-maps*
|
||||
Staging/unstaging maps ~
|
||||
|
||||
*fugitive_s*
|
||||
s Stage (add) the file or hunk under the cursor.
|
||||
|
||||
*fugitive_u*
|
||||
u Unstage (reset) the file or hunk under the cursor.
|
||||
|
||||
*fugitive_-*
|
||||
- Stage or unstage the file or hunk under the cursor.
|
||||
|
||||
*fugitive_U*
|
||||
U Unstage everything.
|
||||
|
||||
*fugitive_X*
|
||||
X Discard the change under the cursor. This uses
|
||||
`checkout` or `clean` under the hood. A command is
|
||||
echoed that shows how to undo the change. Consult
|
||||
`:messages` to see it again. During a merge conflict,
|
||||
use 2X to call `checkout --ours` or 3X to call
|
||||
`checkout --theirs` .
|
||||
|
||||
*fugitive_=*
|
||||
= Toggle an inline diff of the file under the cursor.
|
||||
|
||||
*fugitive_>*
|
||||
> Insert an inline diff of the file under the cursor.
|
||||
|
||||
*fugitive_<*
|
||||
< Remove the inline diff of the file under the cursor.
|
||||
|
||||
*fugitive_gI*
|
||||
gI Open .git/info/exclude in a split and add the file
|
||||
under the cursor. Use a count to open .gitignore.
|
||||
|
||||
*fugitive_I*
|
||||
I Invoke |:Git| add --patch or reset --patch on the file
|
||||
P under the cursor. On untracked files, this instead
|
||||
calls |:Git| add --intent-to-add.
|
||||
|
||||
*fugitive_d*
|
||||
Diff maps ~
|
||||
*fugitive_dp*
|
||||
dp Invoke |:Git| diff on the file under the cursor.
|
||||
Deprecated in favor of inline diffs.
|
||||
|
||||
*fugitive_dd*
|
||||
dd Perform a |:Gdiffsplit| on the file under the cursor.
|
||||
|
||||
*fugitive_dv*
|
||||
dv Perform a |:Gvdiffsplit| on the file under the cursor.
|
||||
|
||||
*fugitive_ds* *fugitive_dh*
|
||||
ds Perform a |:Ghdiffsplit| on the file under the cursor.
|
||||
dh
|
||||
|
||||
*fugitive_dq*
|
||||
dq Close all but one diff buffer, and |:diffoff|! the
|
||||
last one.
|
||||
|
||||
*fugitive_d?*
|
||||
d? Show this help.
|
||||
|
||||
*fugitive-navigation-maps*
|
||||
Navigation maps ~
|
||||
|
||||
*fugitive_<CR>*
|
||||
<CR> Open the file or |fugitive-object| under the cursor.
|
||||
In a blob, this and similar maps jump to the patch
|
||||
from the diff where this was added, or where it was
|
||||
removed if a count was given. If the line is still in
|
||||
the work tree version, passing a count takes you to
|
||||
it.
|
||||
|
||||
*fugitive_o*
|
||||
o Open the file or |fugitive-object| under the cursor in
|
||||
a new split.
|
||||
|
||||
*fugitive_gO*
|
||||
gO Open the file or |fugitive-object| under the cursor in
|
||||
a new vertical split.
|
||||
|
||||
*fugitive_O*
|
||||
O Open the file or |fugitive-object| under the cursor in
|
||||
a new tab.
|
||||
|
||||
*fugitive_p*
|
||||
p Open the file or |fugitive-object| under the cursor in
|
||||
a preview window. In the status buffer, 1p is
|
||||
required to bypass the legacy usage instructions.
|
||||
|
||||
*fugitive_~*
|
||||
~ Open the current file in the [count]th first ancestor.
|
||||
|
||||
*fugitive_P*
|
||||
P Open the current file in the [count]th parent.
|
||||
|
||||
*fugitive_C*
|
||||
C Open the commit containing the current file.
|
||||
|
||||
*fugitive_CTRL-P* *fugitive_(*
|
||||
( Jump to the previous file, hunk, or revision.
|
||||
|
||||
*fugitive_CTRL-N* *fugitive_)*
|
||||
) Jump to the next file, hunk, or revision.
|
||||
|
||||
*fugitive_[c*
|
||||
[c Jump to previous hunk, expanding inline diffs
|
||||
automatically. (This shadows the Vim built-in |[c|
|
||||
that provides a similar operation in |diff| mode.)
|
||||
|
||||
*fugitive_]c*
|
||||
]c Jump to next hunk, expanding inline diffs
|
||||
automatically. (This shadows the Vim built-in |]c|
|
||||
that provides a similar operation in |diff| mode.)
|
||||
|
||||
*fugitive_[/* *fugitive_[m*
|
||||
[/ Jump to previous file, collapsing inline diffs
|
||||
[m automatically. (Mnemonic: "/" appears in filenames,
|
||||
"m" appears in "filenames".)
|
||||
|
||||
*fugitive_]/* *fugitive_]m*
|
||||
]/ Jump to next file, collapsing inline diffs
|
||||
]m automatically. (Mnemonic: "/" appears in filenames,
|
||||
"m" appears in "filenames".)
|
||||
|
||||
*fugitive_i*
|
||||
i Jump to the next file or hunk, expanding inline diffs
|
||||
automatically.
|
||||
|
||||
*fugitive_[[*
|
||||
[[ Jump [count] sections backward.
|
||||
|
||||
*fugitive_]]*
|
||||
]] Jump [count] sections forward.
|
||||
|
||||
*fugitive_[]*
|
||||
[] Jump [count] section ends backward.
|
||||
|
||||
*fugitive_][*
|
||||
][ Jump [count] section ends forward.
|
||||
|
||||
*fugitive_star*
|
||||
* On the first column of a + or - diff line, search for
|
||||
the corresponding - or + line. Otherwise, defer to
|
||||
built-in |star|.
|
||||
|
||||
*fugitive_#*
|
||||
# Same as "*", but search backward.
|
||||
|
||||
*fugitive_gu*
|
||||
gu Jump to file [count] in the "Untracked" or "Unstaged"
|
||||
section.
|
||||
|
||||
*fugitive_gU*
|
||||
gU Jump to file [count] in the "Unstaged" section.
|
||||
|
||||
*fugitive_gs*
|
||||
gs Jump to file [count] in the "Staged" section.
|
||||
|
||||
*fugitive_gp*
|
||||
gp Jump to file [count] in the "Unpushed" section.
|
||||
|
||||
*fugitive_gP*
|
||||
gP Jump to file [count] in the "Unpulled" section.
|
||||
|
||||
*fugitive_gr*
|
||||
gr Jump to file [count] in the "Rebasing" section.
|
||||
|
||||
*fugitive_gi*
|
||||
gi Open .git/info/exclude in a split. Use a count to
|
||||
open .gitignore.
|
||||
|
||||
*fugitive_c*
|
||||
Commit maps ~
|
||||
|
||||
cc Create a commit.
|
||||
|
||||
ca Amend the last commit and edit the message.
|
||||
|
||||
ce Amend the last commit without editing the message.
|
||||
|
||||
cw Reword the last commit.
|
||||
|
||||
cvc Create a commit with -v.
|
||||
|
||||
cva Amend the last commit with -v
|
||||
|
||||
cf Create a `fixup!` commit for the commit under the
|
||||
cursor.
|
||||
|
||||
cF Create a `fixup!` commit for the commit under the
|
||||
cursor and immediately rebase it.
|
||||
|
||||
cs Create a `squash!` commit for the commit under the
|
||||
cursor.
|
||||
|
||||
cS Create a `squash!` commit for the commit under the
|
||||
cursor and immediately rebase it.
|
||||
|
||||
cA Create a `squash!` commit for the commit under the
|
||||
cursor and edit the message.
|
||||
|
||||
c<Space> Populate command line with ":Git commit ".
|
||||
|
||||
*fugitive_cr*
|
||||
crc Revert the commit under the cursor.
|
||||
|
||||
crn Revert the commit under the cursor in the index and
|
||||
work tree, but do not actually commit the changes.
|
||||
|
||||
cr<Space> Populate command line with ":Git revert ".
|
||||
|
||||
*fugitive_cm*
|
||||
cm<Space> Populate command line with ":Git merge ".
|
||||
|
||||
c? Show this help.
|
||||
|
||||
*fugitive_cb*
|
||||
*fugitive_co*
|
||||
Checkout/branch maps ~
|
||||
|
||||
coo Check out the commit under the cursor.
|
||||
|
||||
cb<Space> Populate command line with ":Git branch ".
|
||||
|
||||
co<Space> Populate command line with ":Git checkout ".
|
||||
|
||||
cb? Show this help.
|
||||
co?
|
||||
|
||||
*fugitive_cz*
|
||||
Stash maps ~
|
||||
|
||||
czz Push stash. Pass a [count] of 1 to add
|
||||
`--include-untracked` or 2 to add `--all`.
|
||||
|
||||
czw Push stash of worktree. Like `czz` with
|
||||
`--keep-index`.
|
||||
|
||||
czA Apply topmost stash, or stash@{count}.
|
||||
|
||||
cza Apply topmost stash, or stash@{count}, preserving the
|
||||
index.
|
||||
|
||||
czP Pop topmost stash, or stash@{count}.
|
||||
|
||||
czp Pop topmost stash, or stash@{count}, preserving the
|
||||
index.
|
||||
|
||||
cz<Space> Populate command line with ":Git stash ".
|
||||
|
||||
cz? Show this help.
|
||||
|
||||
*fugitive_r*
|
||||
Rebase maps ~
|
||||
|
||||
ri Perform an interactive rebase. Uses ancestor of
|
||||
u commit under cursor as upstream if available.
|
||||
|
||||
rf Perform an autosquash rebase without editing the todo
|
||||
list. Uses ancestor of commit under cursor as
|
||||
upstream if available.
|
||||
|
||||
ru Perform an interactive rebase against @{upstream}.
|
||||
|
||||
rp Perform an interactive rebase against @{push}.
|
||||
|
||||
rr Continue the current rebase.
|
||||
|
||||
rs Skip the current commit and continue the current
|
||||
rebase.
|
||||
|
||||
ra Abort the current rebase.
|
||||
|
||||
re Edit the current rebase todo list.
|
||||
|
||||
rw Perform an interactive rebase with the commit under
|
||||
the cursor set to `reword`.
|
||||
|
||||
rm Perform an interactive rebase with the commit under
|
||||
the cursor set to `edit`.
|
||||
|
||||
rd Perform an interactive rebase with the commit under
|
||||
the cursor set to `drop`.
|
||||
|
||||
r<Space> Populate command line with ":Git rebase ".
|
||||
|
||||
r? Show this help.
|
||||
|
||||
*fugitive-misc-maps*
|
||||
Miscellaneous maps ~
|
||||
|
||||
*fugitive_gq* *fugitive_q*
|
||||
gq Close the status buffer.
|
||||
|
||||
*fugitive_.*
|
||||
. Start a |:| command line with the file under the
|
||||
cursor prepopulated.
|
||||
|
||||
*fugitive_g?*
|
||||
g? Show help for |fugitive-maps|.
|
||||
|
||||
*fugitive-global-maps*
|
||||
Global maps ~
|
||||
|
||||
*fugitive_c_CTRL-R_CTRL-G*
|
||||
*fugitive-c_CTRL-R_CTRL-G*
|
||||
<C-R><C-G> On the command line, recall the path to the current
|
||||
|fugitive-object| (that is, a representation of the
|
||||
object recognized by |:Gedit|).
|
||||
object (that is, a representation of the object
|
||||
recognized by |:Gedit|).
|
||||
|
||||
*fugitive_y_CTRL-G*
|
||||
["x]y<C-G> Yank the path to the current |fugitive-object|.
|
||||
*fugitive-y_CTRL-G*
|
||||
["x]y<C-G> Yank the commit SHA and path to the current 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*
|
||||
These maps are available in Git objects.
|
||||
|
||||
Fugitive objects are either work tree files or Git revisions as defined in the
|
||||
"SPECIFYING REVISIONS" section in the git-rev-parse man page, with expansions
|
||||
inspired by |cmdline-special| layered on top. For commands that accept an
|
||||
optional object, the default is the file in the index for work tree files and
|
||||
the work tree file for everything else. Example objects follow.
|
||||
*fugitive-<CR>*
|
||||
<CR> Jump to the revision under the cursor.
|
||||
|
||||
Object Meaning ~
|
||||
@ The commit referenced by @ aka HEAD
|
||||
master The commit referenced by master
|
||||
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 work tree
|
||||
*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.
|
||||
|
||||
*fugitive-P*
|
||||
P Go to the current file in the [count]th parent.
|
||||
|
||||
*fugitive-C*
|
||||
C Go to the commit containing the current file.
|
||||
|
||||
*fugitive-.*
|
||||
. Start a |:| command line with the current revision
|
||||
prepopulated at the end of the line.
|
||||
|
||||
*fugitive-a*
|
||||
a Show the current tag, commit, or tree in an alternate
|
||||
format.
|
||||
|
||||
SPECIFYING REVISIONS *fugitive-revision*
|
||||
|
||||
Fugitive revisions are similar to Git revisions as defined in the "SPECIFYING
|
||||
REVISIONS" section in the git-rev-parse man page. For commands that accept an
|
||||
optional revision, the default is the file in the index for work tree files
|
||||
and the work tree file for everything else. Example revisions follow.
|
||||
|
||||
Revision Meaning ~
|
||||
HEAD .git/HEAD
|
||||
master .git/refs/heads/master
|
||||
HEAD^{} The commit referenced by HEAD
|
||||
HEAD^ The parent of the commit referenced by HEAD
|
||||
HEAD: The tree referenced by HEAD
|
||||
/HEAD The file named HEAD in the work tree
|
||||
Makefile The file named Makefile in the work tree
|
||||
@^:Makefile The file named Makefile in the parent of HEAD
|
||||
HEAD^:Makefile The file named Makefile in the parent of HEAD
|
||||
:Makefile The file named Makefile in the index (writable)
|
||||
@~2:% The current file in the grandparent of HEAD
|
||||
:% The current file in the index
|
||||
:1:% The current file's common ancestor during a conflict
|
||||
:2:# The alternate file in the target branch during a conflict
|
||||
:3:#5 The file from buffer #5 in the merged branch during a conflict
|
||||
! The commit owning the current file
|
||||
!: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
|
||||
: The |fugitive-summary| buffer
|
||||
- A temp file containing the last |:Git| invocation's output
|
||||
<cfile> The file or commit under the cursor
|
||||
- The current file in HEAD
|
||||
^ The current file in the previous commit
|
||||
~3 The current file 3 commits ago
|
||||
: .git/index (Same as |:Gstatus|)
|
||||
:0 The current file in the index
|
||||
:1 The current file's common ancestor during a conflict
|
||||
:2 The current file in the target branch during a conflict
|
||||
:3 The current file in the merged branch during a conflict
|
||||
:/foo The most recent commit with "foo" in the message
|
||||
|
||||
STATUSLINE *fugitive-statusline*
|
||||
|
||||
*FugitiveStatusline()* *fugitive#statusline()*
|
||||
Add %{FugitiveStatusline()} to your statusline to get an indicator including
|
||||
*fugitive#statusline()*
|
||||
Add %{fugitive#statusline()} to your statusline to get an indicator including
|
||||
the current branch and the currently edited file's commit. If you don't have
|
||||
a statusline, this one matches the default when 'ruler' is set:
|
||||
>
|
||||
set statusline=%<%f\ %h%m%r%{FugitiveStatusline()}%=%-14.(%l,%c%V%)\ %P
|
||||
set statusline=%<%f\ %h%m%r%{fugitive#statusline()}%=%-14.(%l,%c%V%)\ %P
|
||||
<
|
||||
AUTOCOMMANDS *fugitive-autocommands*
|
||||
|
||||
A handful of |User| |autocommands| are provided to allow extending and
|
||||
overriding Fugitive behaviors. Example usage:
|
||||
>
|
||||
autocmd User FugitiveBlob,FugitiveStageBlob call s:BlobOverrides()
|
||||
<
|
||||
*User_FugitiveTag*
|
||||
FugitiveTag After loading a tag object.
|
||||
|
||||
*User_FugitiveCommit*
|
||||
FugitiveCommit After loading a commit object.
|
||||
|
||||
*User_FugitiveTree*
|
||||
FugitiveTree After loading a tree (directory) object.
|
||||
|
||||
*User_FugitiveBlob*
|
||||
FugitiveBlob After loading a committed blob (file) object.
|
||||
|
||||
*User_FugitiveObject*
|
||||
FugitiveObject After loading any of the 4 above buffer types.
|
||||
|
||||
*User_FugitiveStageBlob*
|
||||
FugitiveStageBlob After loading a staged blob (file) object. These
|
||||
buffers are 'modifiable' and oftentimes don't want the
|
||||
same behavior as the other buffer types.
|
||||
|
||||
*User_FugitiveIndex*
|
||||
FugitiveIndex After loading the |fugitive-summary| buffer.
|
||||
|
||||
*User_FugitivePager*
|
||||
FugitivePager After loading a temp file created by a command like
|
||||
:Git --paginate or :Git blame.
|
||||
|
||||
*User_FugitiveEditor*
|
||||
FugitiveEditor After a :Git command (e.g., :Git commit) edits a file
|
||||
(e.g., the commit message).
|
||||
|
||||
*User_FugitiveChanged*
|
||||
FugitiveChanged After any event which can potentially change the
|
||||
repository, for example, any invocation of |:Git|.
|
||||
Originally intended for expiring caches, but can have
|
||||
other uses.
|
||||
|
||||
API *fugitive-api*
|
||||
|
||||
Officially supported functions are documented inline in plugin/fugitive.vim.
|
||||
|
||||
DEPRECATIONS *fugitive-deprecated*
|
||||
|
||||
The following commands are deprecated in favor of replacements that adhere to
|
||||
a new naming scheme. Remember that |:Git| can be shortened to |:G|, so
|
||||
replacements using it are just one space character longer than the legacy
|
||||
version.
|
||||
|
||||
*:Gremove* Superseded by |:GRemove|.
|
||||
*:Gdelete* Superseded by |:GDelete|.
|
||||
*:Gmove* Superseded by |:GMove|.
|
||||
*:Grename* Superseded by |:GRename|.
|
||||
*:Gbrowse* Superseded by |:GBrowse|.
|
||||
*:Gdiff* Superseded by |:Gdiffsplit|
|
||||
*:Gsdiff* Superseded by |:Ghdiffsplit|
|
||||
*:Gvdiff* Superseded by |:Gvdiffsplit| or |:vert| |:Gdiffsplit|.
|
||||
*:Gblame* Superseded by |:Git_blame|.
|
||||
*:Gcommit* Superseded by |:Git| commit.
|
||||
*:Gmerge* Superseded by |:Git| merge and |:Git_mergetool|.
|
||||
*:Gpull* Superseded by |:Git| pull.
|
||||
*:Grebase* Superseded by |:Git| rebase.
|
||||
*:Grevert* Superseded by |:Git| revert.
|
||||
*:Gpush* Superseded by |:Git| push.
|
||||
*:Gfetch* Superseded by |:Git| fetch.
|
||||
*:Glog* Superseded by |:Gclog|.
|
||||
*:Gstatus* Superseded by |:Git| (with no arguments).
|
||||
*:Gsplit!* Superseded by |:Git_--paginate|.
|
||||
*:Gvsplit!* Superseded by :vert Git --paginate.
|
||||
*:Gtabsplit!* Superseded by :tab Git --paginate.
|
||||
*:Gpedit!* Superseded by :Git! --paginate.
|
||||
|
||||
*User_Fugitive*
|
||||
Fugitive used to support `:autocmd User Fugitive` to run an autocommand after
|
||||
loading any buffer belonging to a Git repository, but this is being phased
|
||||
out. Instead, one can leverage regular autocommand events like |BufNewFile|
|
||||
and |BufReadPost|, and check !empty(FugitiveGitDir()) to confirm Fugitive has
|
||||
found a repository. See also |fugitive-autocommands| for other, more
|
||||
selective events.
|
||||
*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:
|
||||
|
||||
https://github.com/tpope/vim-fugitive
|
||||
http://github.com/tpope/vim-fugitive
|
||||
|
||||
vim:tw=78:et:ft=help:norl:
|
||||
|
||||
@@ -1 +0,0 @@
|
||||
autocmd BufReadPost *.fugitiveblame setfiletype fugitiveblame
|
||||
@@ -1,6 +0,0 @@
|
||||
if exists("b:did_ftplugin") || !exists("*FugitiveGitDir")
|
||||
finish
|
||||
endif
|
||||
let b:did_ftplugin = 1
|
||||
|
||||
call fugitive#BlameFileType()
|
||||
3609
plugin/fugitive.vim
3609
plugin/fugitive.vim
File diff suppressed because it is too large
Load Diff
@@ -1,57 +0,0 @@
|
||||
if exists("b:current_syntax")
|
||||
finish
|
||||
endif
|
||||
|
||||
syn sync fromstart
|
||||
syn spell notoplevel
|
||||
|
||||
syn include @fugitiveDiff syntax/diff.vim
|
||||
|
||||
syn match fugitiveHeader /^[A-Z][a-z][^:]*:/
|
||||
syn match fugitiveHeader /^Head:/ nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
|
||||
syn match fugitiveHeader /^Pull:\|^Rebase:\|^Merge:\|^Push:/ nextgroup=fugitiveSymbolicRef skipwhite
|
||||
syn match fugitiveHelpHeader /^Help:/ nextgroup=fugitiveHelpTag skipwhite
|
||||
syn match fugitiveHelpTag /\S\+/ contained
|
||||
|
||||
syn region fugitiveSection start=/^\%(.*(\d\++\=)$\)\@=/ contains=fugitiveHeading end=/^$/
|
||||
syn cluster fugitiveSection contains=fugitiveSection
|
||||
syn match fugitiveHeading /^[A-Z][a-z][^:]*\ze (\d\++\=)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite
|
||||
syn match fugitiveCount /(\d\++\=)/hs=s+1,he=e-1 contained
|
||||
syn match fugitivePreposition /\<\%([io]nto\|from\|to\|Rebasing\%( detached\)\=\)\>/ transparent contained nextgroup=fugitiveHash,fugitiveSymbolicRef skipwhite
|
||||
|
||||
syn match fugitiveInstruction /^\l\l\+\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
|
||||
syn match fugitiveDone /^done\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
|
||||
syn match fugitiveStop /^stop\>/ contained containedin=@fugitiveSection nextgroup=fugitiveHash skipwhite
|
||||
syn match fugitiveModifier /^[MADRCU?]\{1,2} / contained containedin=@fugitiveSection
|
||||
syn match fugitiveSymbolicRef /\.\@!\%(\.\.\@!\|[^[:space:][:cntrl:]\:.]\)\+\.\@<!/ contained
|
||||
syn match fugitiveHash /^\x\{4,\}\S\@!/ contained containedin=@fugitiveSection
|
||||
syn match fugitiveHash /\S\@<!\x\{4,\}\S\@!/ contained
|
||||
|
||||
syn region fugitiveHunk start=/^\%(@@\+ -\)\@=/ end=/^\%([A-Za-z?@]\|$\)\@=/ contains=diffLine,diffRemoved,diffAdded,diffNoEOL containedin=@fugitiveSection fold
|
||||
|
||||
for s:section in ['Untracked', 'Unstaged', 'Staged']
|
||||
exe 'syn region fugitive' . s:section . 'Section start=/^\%(' . s:section . ' .*(\d\++\=)$\)\@=/ contains=fugitive' . s:section . 'Heading end=/^$/'
|
||||
exe 'syn match fugitive' . s:section . 'Modifier /^[MADRCU?] / contained containedin=fugitive' . s:section . 'Section'
|
||||
exe 'syn cluster fugitiveSection add=fugitive' . s:section . 'Section'
|
||||
exe 'syn match fugitive' . s:section . 'Heading /^[A-Z][a-z][^:]*\ze (\d\++\=)$/ contains=fugitivePreposition contained nextgroup=fugitiveCount skipwhite'
|
||||
endfor
|
||||
unlet s:section
|
||||
|
||||
hi def link fugitiveHelpHeader fugitiveHeader
|
||||
hi def link fugitiveHeader Label
|
||||
hi def link fugitiveHelpTag Tag
|
||||
hi def link fugitiveHeading PreProc
|
||||
hi def link fugitiveUntrackedHeading PreCondit
|
||||
hi def link fugitiveUnstagedHeading Macro
|
||||
hi def link fugitiveStagedHeading Include
|
||||
hi def link fugitiveModifier Type
|
||||
hi def link fugitiveUntrackedModifier StorageClass
|
||||
hi def link fugitiveUnstagedModifier Structure
|
||||
hi def link fugitiveStagedModifier Typedef
|
||||
hi def link fugitiveInstruction Type
|
||||
hi def link fugitiveStop Function
|
||||
hi def link fugitiveHash Identifier
|
||||
hi def link fugitiveSymbolicRef Function
|
||||
hi def link fugitiveCount Number
|
||||
|
||||
let b:current_syntax = "fugitive"
|
||||
@@ -1,7 +0,0 @@
|
||||
if exists("b:current_syntax") || !exists("*FugitiveGitDir")
|
||||
finish
|
||||
endif
|
||||
|
||||
call fugitive#BlameSyntax()
|
||||
|
||||
let b:current_syntax = "fugitiveblame"
|
||||
Reference in New Issue
Block a user