doc/fugitive.txt

   1 *fugitive.txt*  A Git wrapper so awesome, it should be illegal
   2
   3 Author:  Tim Pope <http://tpo.pe/>
   4 License: Same terms as Vim itself (see |license|)
   5
   6 This plugin is only available if 'compatible' is not set.
   7
   8 INTRODUCTION                                    *fugitive*
   9
  10 Whenever you edit a file from a Git repository, a set of commands is defined
  11 that serve as a gateway to Git.
  12
  13 COMMANDS                                        *fugitive-commands*
  14
  15 These commands are local to the buffers in which they work (generally, buffers
  16 that are part of Git repositories).
  17
  18                                                 *fugitive-:G*
  19 :G [args]               Same as :Git, but two characters shorter.
  20
  21                                                 *:Git*
  22 :Git {args}             Run an arbitrary git command and display any output.
  23                         On UNIX this uses a pty and on other platforms it uses
  24                         a pipe, which will cause some behavior differences
  25                         such as the absence of progress bars.  Any file the
  26                         command edits (for example, a commit message) will be
  27                         loaded into a split window.  Closing that window will
  28                         resume running the command.  A few Git subcommands
  29                         have different behavior; these are documented below.
  30
  31                                                 *:Git!*
  32 :Git! {args}            Run an arbitrary git command in the background and
  33                         stream the output to the preview window.  Requires a
  34                         Vim with |setbufline()|.  Press CTRL-D during an
  35                         interactive :Git invocation to switch to this mode
  36                         retroactively.
  37
  38                                                 *:Git_--paginate* *:Git_-p*
  39 :Git --paginate {args}  Run an arbitrary git command, capture output to a temp
  40 :Git -p {args}          file, and |:split| that temp file.  Pass ++curwin as
  41                         the first argument to |:edit| the temp file instead.
  42                         A temp file is always used for commands like diff and
  43                         log that typically uses a pager, and for any command
  44                         that has the pager.<cmd> Git configuration option set.
  45
  46 :{range}Git! --paginate {args}
  47 :{range}Git! -p {args}  Run an arbitrary git command, and insert the output
  48                         after {range} in the current buffer.
  49
  50                                                 *fugitive-summary*
  51 :Git                    With no arguments, bring up a summary window vaguely
  52                         akin to git-status.  If a summary window is already
  53                         open for the current repository, it is focused
  54                         instead.  Press g?  or see |fugitive-maps| for usage.
  55
  56                                                 *:Git_blame*
  57 :Git blame [flags]      Run git-blame [flags] on the current file and open the
  58                         results in a scroll-bound vertical split.  The
  59                         following maps, which work on the cursor line commit
  60                         where sensible, are provided:
  61
  62                         g?    show this help
  63                         A     resize to end of author column
  64                         C     resize to end of commit column
  65                         D     resize to end of date/time column
  66                         gq    close blame, then |:Gedit| to return to work
  67                               tree version
  68                         <CR>  close blame, and jump to patch that added line
  69                               (or directly to blob for boundary commit)
  70                         o     jump to patch or blob in horizontal split
  71                         O     jump to patch or blob in new tab
  72                         p     jump to patch or blob in preview window
  73                         -     reblame at commit
  74
  75                         The maps |fugitive_P| and |fugitive_~| are also
  76                         supported to reblame on a parent commit, but this is
  77                         inherently fragile, as the line being blamed will no
  78                         longer exist.  The preferred alternative is to use
  79                         <CR> to open up the commit, select the corresponding
  80                         `-` line that you care about, and press <CR> twice
  81                         more to reblame at that line.  Viewing the commit also
  82                         gives you additional context as to why the line
  83                         changed.
  84
  85                                                 *g:fugitive_dynamic_colors*
  86                         In the GUI or a 256 color terminal, commit hashes will
  87                         be highlighted in different colors. To disable this:
  88 >
  89                         let g:fugitive_dynamic_colors = 0
  90 <
  91 :[range]Git blame [...] If a range is given, just that part of the file will
  92 :Git blame [...] {file} be blamed, and a horizontal split without
  93                         scrollbinding is used.  You can also give an arbitrary
  94                         filename.
  95
  96                                                 *:Git_difftool*
  97 :Git[!] difftool [args] Invoke `git diff [args]` and load the changes into the
  98                         quickfix list.  Each changed hunk gets a separate
  99                         quickfix entry unless you pass an option like
 100                         --name-only or --name-status.  Jumps to the first
 101                         change unless [!] is given.
 102
 103 :Git difftool -y [args] Invoke `git diff [args]`, open each changed file in a
 104                         new tab, and invoke |:Gdiffsplit!| against the
 105                         appropriate commit.
 106
 107                                                 *:Git_mergetool*
 108 :Git mergetool [args]   Like |:Git_difftool|, but target merge conflicts.
 109
 110 Wrappers for Vim built-ins ~
 111
 112 These all directly map onto a built-in Vim command, and generally have names
 113 that prepend "G" to the command they are wrapping.  For example, :Ggrep is G
 114 plus |:grep|.
 115
 116                                                 *:Ggrep* *:Git_grep*
 117 :Ggrep[!] [args]        An approximation of |:grep|[!] with git-grep as
 118 :Git[!] grep -O [args]  'grepprg'.
 119
 120 :Ggrep[!] --quiet [args]
 121 :Ggrep[!] -q [args]     Like |:Ggrep|, but instead of displaying output, open
 122                         the quickfix list.
 123
 124                                                 *:Glgrep*
 125 :Glgrep[!] [args]       :Ggrep but for |:lgrep|.
 126 :0Git[!] grep -O [args]
 127
 128                                                  *:Gclog*
 129 :Gclog[!] [args]        Use git-log [args] to load the commit history into the
 130                         |quickfix| list.  Jumps to the first commit unless [!]
 131                         is given.  This command wraps |:cfile|.
 132
 133                         The quickfix list can be awkward for many use cases
 134                         and exhibits extremely poor performance with larger
 135                         data sets.  Consider using |:Git| log --oneline
 136                         instead.
 137
 138 :{range}Gclog[!] [args] Use git-log -L to load previous revisions of the given
 139                         range of the current file into the |quickfix| list.
 140                         The cursor is positioned on the first line of the
 141                         first diff hunk for each commit.  Use :0Gclog to
 142                         target the entire file.
 143
 144                                                 *:Gllog*
 145 :Gllog [args]           Like |:Gclog|, but use the location list instead of the
 146                         |quickfix| list.
 147
 148                                                 *:Gcd*
 149 :Gcd [directory]        |:cd| relative to the repository.
 150
 151                                                 *:Glcd*
 152 :Glcd [directory]       |:lcd| relative to the repository.
 153
 154                                                 *:Gedit* *fugitive-:Ge*
 155 :Gedit [object]         |:edit| a |fugitive-object|.
 156
 157                                                 *:Gsplit*
 158 :Gsplit [object]        |:split| a |fugitive-object|.
 159
 160                                                 *:Gvsplit*
 161 :Gvsplit [object]       |:vsplit| a |fugitive-object|.
 162
 163                                                 *:Gtabedit*
 164 :Gtabedit [object]      |:tabedit| a |fugitive-object|.
 165
 166                                                 *:Gpedit*
 167 :Gpedit [object]        |:pedit| a |fugitive-object|.
 168
 169                                                 *:Gdrop*
 170 :Gdrop [object]         |:drop| a |fugitive-object|.
 171
 172                                                 *:Gread* *fugitive-:Gr*
 173 :Gread [object]         Empty the buffer and |:read| a |fugitive-object|.
 174                         When the argument is omitted, this is similar to
 175                         git-checkout on a work tree file or git-add on a stage
 176                         file, but without writing anything to disk.
 177
 178 :{range}Gread [object]  |:read| in a |fugitive-object| after {range}.
 179
 180                                                 *:Gwrite* *fugitive-:Gw*
 181 :Gwrite                 Write to the current file's path and stage the results.
 182                         When run in a work tree file, it is effectively git
 183                         add.  Elsewhere, it is effectively git-checkout.  A
 184                         great deal of effort is expended to behave sensibly
 185                         when the work tree or index version of the file is
 186                         open in another buffer.
 187
 188 :Gwrite {path}          You can give |:Gwrite| an explicit path of where in
 189                         the work tree to write.  You can also give a path like
 190                         :0:foo.txt or :0:% to write to just that stage in
 191                         the index.
 192
 193                                                 *:Gwq*
 194 :Gwq [path]             Like |:Gwrite| followed by |:quit| if the write
 195                         succeeded.
 196
 197 :Gwq! [path]            Like |:Gwrite|! followed by |:quit|! if the write
 198                         succeeded.
 199
 200                                                 *:Gdiffsplit*
 201 :Gdiffsplit [object]    Perform a |vimdiff| against the given file, or if a
 202                         commit is given, the current file in that commit.
 203                         With no argument, the version in the index or work
 204                         tree is used, and the work tree version is always
 205                         placed to the right or bottom, depending on available
 206                         width.  Use Vim's |do| and |dp| to stage and unstage
 207                         changes.
 208
 209                                                 *:Gdiffsplit!*
 210 :Gdiffsplit!            Diff against any and all direct ancestors, retaining
 211                         focus on the current window.  During a merge conflict,
 212                         this is a three-way diff against the "ours" and
 213                         "theirs" ancestors.  Additional d2o and d3o maps are
 214                         provided to obtain the hunk from the "ours" or
 215                         "theirs" ancestor, respectively.
 216
 217 :Gdiffsplit! {object}   Like |:Gdiffsplit|, but retain focus on the current
 218                         window.
 219
 220                                                 *:Gvdiffsplit*
 221 :Gvdiffsplit [object]   Like |:Gdiffsplit|, but always split vertically.
 222
 223                                                 *:Ghdiffsplit*
 224 :Gdiffsplit ++novertical [object]
 225 :Ghdiffsplit [object]   Like |:Gdiffsplit|, but with "vertical" removed from
 226                         'diffopt'.  The split will still be vertical if
 227                         combined with |:vertical|.
 228
 229 Other commands ~
 230
 231 These do not directly correspond to any built-in Vim command, and have a
 232 capital letter after the "G" to convey this. For example, the file move
 233 operation has nothing to do with the |:move| built-in, so it is named :GMove,
 234 not :Gmove.
 235
 236                                                 *:GMove*
 237 :GMove {destination}    Wrapper around git-mv that renames the buffer
 238                         afterward.  Add a ! to pass -f.
 239
 240                                                 *:GRename*
 241 :GRename {destination}  Like |:GMove| but operates relative to the parent
 242                         directory of the current file.
 243
 244                                                 *:GDelete*
 245 :GDelete                Wrapper around git-rm that deletes the buffer
 246                         afterward.  When invoked in an index file, --cached is
 247                         passed.  Add a ! to pass -f and forcefully discard the
 248                         buffer.
 249
 250                                                 *:GRemove* *:GUnlink*
 251 :GRemove                Like |:GDelete|, but keep the (now empty) buffer around.
 252 :GUnlink
 253
 254                                                 *:GBrowse*
 255 :GBrowse                Open the current file, blob, tree, commit, or tag
 256                         in your browser at the upstream hosting provider.
 257                         Upstream providers can be added by installing an
 258                         appropriate Vim plugin.  For example, GitHub can be
 259                         supported by installing rhubarb.vim, available at
 260                         <https://github.com/tpope/vim-rhubarb>.
 261
 262 :GBrowse {object}       Like :GBrowse, but for a given |fugitive-object|.
 263
 264 :{range}GBrowse [args]  Appends an anchor to the URL that emphasizes the
 265                         selected lines. This also forces the URL to include a
 266                         commit rather than a branch name so it remains valid
 267                         if the file changes.  You can give a range of "0" to
 268                         force this behavior without including an anchor.
 269
 270 :GBrowse [...]@{remote} Force using the given remote rather than the remote
 271                         for the current branch.  The remote is used to
 272                         determine which upstream repository to link to.
 273
 274 :GBrowse {url}          Open an arbitrary URL in your browser.
 275
 276 :[range]GBrowse! [args] Like :GBrowse, but put the URL on the clipboard rather
 277                         than opening it.
 278
 279 MAPS                                            *fugitive-maps*
 280
 281 These maps are available in both the |fugitive-summary| buffer and Fugitive
 282 object buffers, although not all maps make sense in all buffers.  Mappings
 283 that operate on the file or hunk under the cursor are generally available in
 284 visual mode to operate on multiple files or partial hunks.
 285
 286                                                 *fugitive-staging-maps*
 287 Staging/unstaging maps ~
 288
 289                                                 *fugitive_s*
 290 s                       Stage (add) the file or hunk under the cursor.
 291
 292                                                 *fugitive_u*
 293 u                       Unstage (reset) the file or hunk under the cursor.
 294
 295                                                 *fugitive_-*
 296 -                       Stage or unstage the file or hunk under the cursor.
 297
 298                                                 *fugitive_U*
 299 U                       Unstage everything.
 300
 301                                                 *fugitive_X*
 302 X                       Discard the change under the cursor.  This uses
 303                         `checkout` or `clean` under the hood.  A command is
 304                         echoed that shows how to undo the change.  Consult
 305                         `:messages` to see it again.  During a merge conflict,
 306                         use 2X to call `checkout --ours` or 3X to call
 307                         `checkout --theirs` .
 308
 309                                                 *fugitive_=*
 310 =                       Toggle an inline diff of the file under the cursor.
 311
 312                                                 *fugitive_>*
 313 >                       Insert an inline diff of the file under the cursor.
 314
 315                                                 *fugitive_<*
 316 <                       Remove the inline diff of the file under the cursor.
 317
 318                                                 *fugitive_gI*
 319 gI                      Open .git/info/exclude in a split and add the file
 320                         under the cursor.  Use a count to open .gitignore.
 321
 322                                                 *fugitive_I*
 323 I                       Invoke |:Git| add --patch or reset --patch on the file
 324 P                       under the cursor. On untracked files, this instead
 325                         calls |:Git| add --intent-to-add.
 326
 327                                                 *fugitive_d*
 328 Diff maps ~
 329                                                 *fugitive_dp*
 330 dp                      Invoke |:Git| diff on the file under the cursor.
 331                         Deprecated in favor of inline diffs.
 332
 333                                                 *fugitive_dd*
 334 dd                      Perform a |:Gdiffsplit| on the file under the cursor.
 335
 336                                                 *fugitive_dv*
 337 dv                      Perform a |:Gvdiffsplit| on the file under the cursor.
 338
 339                                                 *fugitive_ds* *fugitive_dh*
 340 ds                      Perform a |:Ghdiffsplit| on the file under the cursor.
 341 dh
 342
 343                                                 *fugitive_dq*
 344 dq                      Close all but one diff buffer, and |:diffoff|! the
 345                         last one.
 346
 347                                                 *fugitive_d?*
 348 d?                      Show this help.
 349
 350                                                 *fugitive-navigation-maps*
 351 Navigation maps ~
 352
 353                                                 *fugitive_<CR>*
 354 <CR>                    Open the file or |fugitive-object| under the cursor.
 355                         In a blob, this and similar maps jump to the patch
 356                         from the diff where this was added, or where it was
 357                         removed if a count was given.  If the line is still in
 358                         the work tree version, passing a count takes you to
 359                         it.
 360
 361                                                 *fugitive_o*
 362 o                       Open the file or |fugitive-object| under the cursor in
 363                         a new split.
 364
 365                                                 *fugitive_gO*
 366 gO                      Open the file or |fugitive-object| under the cursor in
 367                         a new vertical split.
 368
 369                                                 *fugitive_O*
 370 O                       Open the file or |fugitive-object| under the cursor in
 371                         a new tab.
 372
 373                                                 *fugitive_p*
 374 p                       Open the file or |fugitive-object| under the cursor in
 375                         a preview window.  In the status buffer, 1p is
 376                         required to bypass the legacy usage instructions.
 377
 378                                                 *fugitive_~*
 379 ~                       Open the current file in the [count]th first ancestor.
 380
 381                                                 *fugitive_P*
 382 P                       Open the current file in the [count]th parent.
 383
 384                                                 *fugitive_C*
 385 C                       Open the commit containing the current file.
 386
 387                                                 *fugitive_CTRL-P* *fugitive_(*
 388 (                       Jump to the previous file, hunk, or revision.
 389
 390                                                 *fugitive_CTRL-N* *fugitive_)*
 391 )                       Jump to the next file, hunk, or revision.
 392
 393                                                 *fugitive_[c*
 394 [c                      Jump to previous hunk, expanding inline diffs
 395                         automatically.  (This shadows the Vim built-in |[c|
 396                         that provides a similar operation in |diff| mode.)
 397
 398                                                 *fugitive_]c*
 399 ]c                      Jump to next hunk, expanding inline diffs
 400                         automatically.  (This shadows the Vim built-in |]c|
 401                         that provides a similar operation in |diff| mode.)
 402
 403                                                 *fugitive_[/* *fugitive_[m*
 404 [/                      Jump to previous file, collapsing inline diffs
 405 [m                      automatically.  (Mnemonic: "/" appears in filenames,
 406                         "m" appears in "filenames".)
 407
 408                                                 *fugitive_]/* *fugitive_]m*
 409 ]/                      Jump to next file, collapsing inline diffs
 410 ]m                      automatically.  (Mnemonic: "/" appears in filenames,
 411                         "m" appears in "filenames".)
 412
 413                                                 *fugitive_i*
 414 i                       Jump to the next file or hunk, expanding inline diffs
 415                         automatically.
 416
 417                                                 *fugitive_[[*
 418 [[                      Jump [count] sections backward.
 419
 420                                                 *fugitive_]]*
 421 ]]                      Jump [count] sections forward.
 422
 423                                                 *fugitive_[]*
 424 []                      Jump [count] section ends backward.
 425
 426                                                 *fugitive_][*
 427 ][                      Jump [count] section ends forward.
 428
 429                                                 *fugitive_star*
 430 *                       On the first column of a + or - diff line, search for
 431                         the corresponding - or + line.  Otherwise, defer to
 432                         built-in |star|.
 433
 434                                                 *fugitive_#*
 435 #                       Same as "*", but search backward.
 436
 437                                                 *fugitive_gu*
 438 gu                      Jump to file [count] in the "Untracked" or "Unstaged"
 439                         section.
 440
 441                                                 *fugitive_gU*
 442 gU                      Jump to file [count] in the "Unstaged" section.
 443
 444                                                 *fugitive_gs*
 445 gs                      Jump to file [count] in the "Staged" section.
 446
 447                                                 *fugitive_gp*
 448 gp                      Jump to file [count] in the "Unpushed" section.
 449
 450                                                 *fugitive_gP*
 451 gP                      Jump to file [count] in the "Unpulled" section.
 452
 453                                                 *fugitive_gr*
 454 gr                      Jump to file [count] in the "Rebasing" section.
 455
 456                                                 *fugitive_gi*
 457 gi                      Open .git/info/exclude in a split.  Use a count to
 458                         open .gitignore.
 459
 460                                                 *fugitive_c*
 461 Commit maps ~
 462
 463 cc                      Create a commit.
 464
 465 ca                      Amend the last commit and edit the message.
 466
 467 ce                      Amend the last commit without editing the message.
 468
 469 cw                      Reword the last commit.
 470
 471 cvc                     Create a commit with -v.
 472
 473 cva                     Amend the last commit with -v
 474
 475 cf                      Create a `fixup!` commit for the commit under the
 476                         cursor.
 477
 478 cF                      Create a `fixup!` commit for the commit under the
 479                         cursor and immediately rebase it.
 480
 481 cs                      Create a `squash!` commit for the commit under the
 482                         cursor.
 483
 484 cS                      Create a `squash!` commit for the commit under the
 485                         cursor and immediately rebase it.
 486
 487 cA                      Create a `squash!` commit for the commit under the
 488                         cursor and edit the message.
 489
 490 c<Space>                Populate command line with ":Git commit ".
 491
 492                                                 *fugitive_cr*
 493 crc                     Revert the commit under the cursor.
 494
 495 crn                     Revert the commit under the cursor in the index and
 496                         work tree, but do not actually commit the changes.
 497
 498 cr<Space>               Populate command line with ":Git revert ".
 499
 500                                                 *fugitive_cm*
 501 cm<Space>               Populate command line with ":Git merge ".
 502
 503 c?                      Show this help.
 504
 505                                                 *fugitive_cb*
 506                                                 *fugitive_co*
 507 Checkout/branch maps ~
 508
 509 coo                     Check out the commit under the cursor.
 510
 511 cb<Space>               Populate command line with ":Git branch ".
 512
 513 co<Space>               Populate command line with ":Git checkout ".
 514
 515 cb?                     Show this help.
 516 co?
 517
 518                                                 *fugitive_cz*
 519 Stash maps ~
 520
 521 czz                     Push stash.  Pass a [count] of 1 to add
 522                         `--include-untracked` or 2 to add `--all`.
 523
 524 czw                     Push stash of the work-tree.  Like `czz` with
 525                         `--keep-index`.
 526
 527 czs                     Push stash of the stage.  Does not accept a count.
 528
 529 czA                     Apply topmost stash, or stash@{count}.
 530
 531 cza                     Apply topmost stash, or stash@{count}, preserving the
 532                         index.
 533
 534 czP                     Pop topmost stash, or stash@{count}.
 535
 536 czp                     Pop topmost stash, or stash@{count}, preserving the
 537                         index.
 538
 539 cz<Space>               Populate command line with ":Git stash ".
 540
 541 cz?                     Show this help.
 542
 543                                                 *fugitive_r*
 544 Rebase maps ~
 545
 546 ri                      Perform an interactive rebase.  Uses ancestor of
 547 u                       commit under cursor as upstream if available.
 548
 549 rf                      Perform an autosquash rebase without editing the todo
 550                         list.  Uses ancestor of commit under cursor as
 551                         upstream if available.
 552
 553 ru                      Perform an interactive rebase against @{upstream}.
 554
 555 rp                      Perform an interactive rebase against @{push}.
 556
 557 rr                      Continue the current rebase.
 558
 559 rs                      Skip the current commit and continue the current
 560                         rebase.
 561
 562 ra                      Abort the current rebase.
 563
 564 re                      Edit the current rebase todo list.
 565
 566 rw                      Perform an interactive rebase with the commit under
 567                         the cursor set to `reword`.
 568
 569 rm                      Perform an interactive rebase with the commit under
 570                         the cursor set to `edit`.
 571
 572 rd                      Perform an interactive rebase with the commit under
 573                         the cursor set to `drop`.
 574
 575 r<Space>                Populate command line with ":Git rebase ".
 576
 577 r?                      Show this help.
 578
 579                                                 *fugitive-misc-maps*
 580 Miscellaneous maps ~
 581
 582                                                 *fugitive_gq* *fugitive_q*
 583 gq                      Close the status buffer.
 584
 585                                                 *fugitive_.*
 586 .                       Start a |:| command line with the file under the
 587                         cursor prepopulated.
 588
 589                                                 *fugitive_g?*
 590 g?                      Show help for |fugitive-maps|.
 591
 592                                                 *fugitive-global-maps*
 593 Global maps ~
 594
 595                                                 *fugitive_c_CTRL-R_CTRL-G*
 596 <C-R><C-G>              On the command line, recall the path to the current
 597                         |fugitive-object| (that is, a representation of the
 598                         object recognized by |:Gedit|).
 599
 600                                                 *fugitive_y_CTRL-G*
 601 ["x]y<C-G>              Yank the path to the current |fugitive-object|.
 602
 603                                                 *g:fugitive_no_maps*
 604 Global maps can be disabled with the g:fugitive_no_maps option.
 605 >
 606         let g:fugitive_no_maps = 1
 607 <
 608 SPECIFYING OBJECTS                      *fugitive-object* *fugitive-revision*
 609
 610 Fugitive objects are either work tree files or Git revisions as defined in the
 611 "SPECIFYING REVISIONS" section in the git-rev-parse man page, with expansions
 612 inspired by |cmdline-special| layered on top.  For commands that accept an
 613 optional object, the default is the file in the index for work tree files and
 614 the work tree file for everything else.  Example objects follow.
 615
 616 Object          Meaning ~
 617 @               The commit referenced by @ aka HEAD
 618 master          The commit referenced by master
 619 master^         The parent of the commit referenced by master
 620 master...other  The merge base of master and other
 621 master:         The tree referenced by master
 622 ./master        The file named master in the working directory
 623 :(top)master    The file named master in the work tree
 624 Makefile        The file named Makefile in the work tree
 625 @^:Makefile     The file named Makefile in the parent of HEAD
 626 :Makefile       The file named Makefile in the index (writable)
 627 @~2:%           The current file in the grandparent of HEAD
 628 :%              The current file in the index
 629 :1:%            The current file's common ancestor during a conflict
 630 :2:#            The alternate file in the target branch during a conflict
 631 :3:#5           The file from buffer #5 in the merged branch during a conflict
 632 !               The commit owning the current file
 633 !:Makefile      The file named Makefile in the commit owning the current file
 634 !3^2            The second parent of the commit owning buffer #3
 635 .git/config     The repo config file
 636 :               The |fugitive-summary| buffer
 637 -               A temp file containing the last |:Git| invocation's output
 638 <cfile>         The file or commit under the cursor
 639
 640 STATUSLINE                                      *fugitive-statusline*
 641
 642                                 *FugitiveStatusline()* *fugitive#statusline()*
 643 Add %{FugitiveStatusline()} to your statusline to get an indicator including
 644 the current branch and the currently edited file's commit.  If you don't have
 645 a statusline, this one matches the default when 'ruler' is set:
 646 >
 647         set statusline=%<%f\ %h%m%r%{FugitiveStatusline()}%=%-14.(%l,%c%V%)\ %P
 648 <
 649 AUTOCOMMANDS                                    *fugitive-autocommands*
 650
 651 A handful of |User| |autocommands| are provided to allow extending and
 652 overriding Fugitive behaviors.  Example usage:
 653 >
 654         autocmd User FugitiveBlob,FugitiveStageBlob call s:BlobOverrides()
 655 <
 656                                                 *User_FugitiveTag*
 657 FugitiveTag             After loading a tag object.
 658
 659                                                 *User_FugitiveCommit*
 660 FugitiveCommit          After loading a commit object.
 661
 662                                                 *User_FugitiveTree*
 663 FugitiveTree            After loading a tree (directory) object.
 664
 665                                                 *User_FugitiveBlob*
 666 FugitiveBlob            After loading a committed blob (file) object.
 667
 668                                                 *User_FugitiveObject*
 669 FugitiveObject          After loading any of the 4 above buffer types.
 670
 671                                                 *User_FugitiveStageBlob*
 672 FugitiveStageBlob       After loading a staged blob (file) object.  These
 673                         buffers are 'modifiable' and oftentimes don't want the
 674                         same behavior as the other buffer types.
 675
 676                                                 *User_FugitiveIndex*
 677 FugitiveIndex           After loading the |fugitive-summary| buffer.
 678
 679                                                 *User_FugitivePager*
 680 FugitivePager           After loading a temp file created by a command like
 681                         :Git --paginate or :Git blame.
 682
 683                                                 *User_FugitiveEditor*
 684 FugitiveEditor          After a :Git command (e.g., :Git commit) edits a file
 685                         (e.g., the commit message).
 686
 687                                                 *User_FugitiveChanged*
 688 FugitiveChanged         After any event which can potentially change the
 689                         repository, for example, any invocation of |:Git|.
 690                         Originally intended for expiring caches, but can have
 691                         other uses.
 692
 693 API                                             *fugitive-api*
 694
 695 Officially supported functions are documented inline in plugin/fugitive.vim.
 696
 697 DEPRECATIONS                                    *fugitive-deprecated*
 698
 699 The following commands are deprecated in favor of replacements that adhere to
 700 a new naming scheme.  Remember that |:Git| can be shortened to |:G|, so
 701 replacements using it are just one space character longer than the legacy
 702 version.
 703
 704 *:Gremove*      Superseded by |:GRemove|.
 705 *:Gdelete*      Superseded by |:GDelete|.
 706 *:Gmove*        Superseded by |:GMove|.
 707 *:Grename*      Superseded by |:GRename|.
 708 *:Gbrowse*      Superseded by |:GBrowse|.
 709 *:Gdiff*        Superseded by |:Gdiffsplit|
 710 *:Gsdiff*       Superseded by |:Ghdiffsplit|
 711 *:Gvdiff*       Superseded by |:Gvdiffsplit| or |:vert| |:Gdiffsplit|.
 712 *:Gblame*       Superseded by |:Git_blame|.
 713 *:Gcommit*      Superseded by |:Git| commit.
 714 *:Gmerge*       Superseded by |:Git| merge and |:Git_mergetool|.
 715 *:Gpull*        Superseded by |:Git| pull.
 716 *:Grebase*      Superseded by |:Git| rebase.
 717 *:Grevert*      Superseded by |:Git| revert.
 718 *:Gpush*        Superseded by |:Git| push.
 719 *:Gfetch*       Superseded by |:Git| fetch.
 720 *:Glog*         Superseded by |:Gclog|.
 721 *:Gstatus*      Superseded by |:Git| (with no arguments).
 722 *:Gsplit!*      Superseded by |:Git_--paginate|.
 723 *:Gvsplit!*     Superseded by :vert Git --paginate.
 724 *:Gtabsplit!*   Superseded by :tab Git --paginate.
 725 *:Gpedit!*      Superseded by :Git! --paginate.
 726
 727                                                 *User_Fugitive*
 728 Fugitive used to support `:autocmd User Fugitive` to run an autocommand after
 729 loading any buffer belonging to a Git repository, but this has been phased
 730 out.  Instead, one can leverage regular autocommand events like |BufNewFile|
 731 and |BufReadPost|, and check !empty(FugitiveGitDir()) to confirm Fugitive has
 732 found a repository.  See also |fugitive-autocommands| for other, more
 733 selective events.
 734
 735 ABOUT                                           *fugitive-about*
 736
 737 Grab the latest version or report a bug on GitHub:
 738
 739 https://github.com/tpope/vim-fugitive
 740
 741  vim:tw=78:et:ft=help:norl: