How to patch add in Fugitive plugin?

Question

This screen I got after running the :Gstatus command:

Then I moved the cursor to init.vim file and pressed the p key, i.e. run git add –patch for the current file.

Now I have this screen:

As you can see, here's the usual interaction for git add patch in a terminal. In the terminal I can press y to add the current chunk of code to the stage area, press n to skip the current one and so on.

But here in fugitive.vim I can't figure out what I should press. Should I press :w to add the current chunk to stage? Or should I press -, or :q to skip?

P.S. I'm using Neovim

Answer 1

Short Answer

Just use the normal interactive buttons. In (regular) vim, pressing p drops you into the interactive terminal patch, so it's the interface you're used to.

For neovim users: Just enter insert mode (i), then it works as a terminal, the cursor goes to 'stage this hunk...' line.

In newer versions, you can use P instead, and the interface is builtin (not an external terminal).

Long Answer: Don't use p!

If you're already using plugin-fugitive, I'd highly recommend learning how to use it properly powerfully.

From the :Git window, you can trigger a number of commands.

Pro tip: ) moves to the next file in the window (and ( previous). g? brings up a list of other shortcuts.

Another answer covers recent updates to the status window that may be even easier to use for patch-like adding than the diff method below, using - and =. This is my preferred method.

You can hit dd on any file to bring up a :Gdiffsplit window. This window will show you the differences between the file on disk and the file in the git index. You add pieces to the git index (simulating git add --patch), but in a much more "vim-like" way.

Pro tip: in any vimdiff window (including :Gdiffsplit), use ]c and [c to jump between diffs

The working copy is always on the right, and the version in the index is always on the left. Note that updating the index ('patching' pieces of the file) is as simple as pulling changes from the working copy to the index. We have the commands do and dp for this. Which to run depends on where you are.

• do (or 'diff-obtain'--:diffget) pulls the nearby diff over from the other side
• dp (or 'diff-put'--:diffput) puts the nearby diff in the other side

The result? From the working copy, use dp to add changes you want to stage, or do to reset changes. (You can actually also run these from the index, but it's slightly less intuitive to me.)

:diffget and :diffput work with ranges (read: visual mode), if you don't want to stage an entire diff hunk at once.

Tip: if the colors look weird, try :diffupdate

I added changes to the index, now what?

Write the index file (e.g. :w) and watch the status window update!

References

• Vimcast on fugitive and the git index

• Fugitive help

• Vim help

Answer 2

Here's another way to do it, all within fugitive. I believe some of this is new with the 3.0 release on Aug 20, 2019. Someone had created a "What's New?" video, which I sadly can't find now. The :Git command received a lot of attention.

In the :Git window, you can use these subcommands. There are many others, but these serve me well.

• <C-N> or <C-P> to jump to the next/previous file (as mentioned above)
• - on a file, stages (or unstages) the entire file.
• = shows the git diff of the file your cursor is on.
• - on a hunk, stages (or unstages) the hunk.
• - in a visual selection, stages (or unstages) the selected lines in the hunk.
• cvc - commits the staged changes in verbose mode. I like the last chance it gives me to verify the right changes have been staged, and it helps inform the commit message.

I really like the inline diffing in the :Git window. For me, it's easier than dealing with the separate windows and the do and dp commands.

Before I learned this, I would always go to the shell and do a git commit -pv, but now I can stay entirely in Vim.