29

I know that :Glog will populate the quickfix list with all the versions of the file in the current buffer and that I can hit <enter> on these to see the file at that particular version, but is there an easy way to see the diff of a particular version with the previous version (to easily see what has changed)?

EDIT: What I'm after is seeing each of these changes in a vertical diff in vim: git log -p -- path/to/file.txt.

zoran119
  • 10,657
  • 12
  • 46
  • 88

10 Answers10

25

This is what I use:

:Gdiff [revision]

See :help Gdiff for other options as well (vertical vs horizontal splits, etc).

For example:

:Gdiff HEAD

or if you have a revision number (ie: aaffdfdstsdgssetds):

:Gdiff aaffdfds
David
  • 13,133
  • 1
  • 30
  • 39
7

I believe it is as simple as:

:vert diffsplit #
cforbish
  • 8,567
  • 3
  • 28
  • 32
4

Could not get fugitive to do what I want (it either doesn't do it or I don't know how to use it), but I did find the plugin which gives the desired behaviour: https://github.com/kablamo/vim-git-log.

(it does not show the diff in quickfix list but in a full sized buffer, which is OK)

zoran119
  • 10,657
  • 12
  • 46
  • 88
  • Sadly, [`vim-git-log`](https://github.com/kablamo/vim-git-log) is dormant with [six outstanding issues](https://github.com/kablamo/vim-git-log/issues). (Last commit: early 2013.) It's also ugly as sin. The only other alternative is [`vimgitlog`](https://github.com/PAntoine/vimgitlog). While actively maintained, the latter is non-trivial to install and (on my machine, at least) fundamentally broken – presumably due to _not_ using `vim-fugitive` under the hood. Who thought that was a good idea? So, I'd love it if someone could fork and begin actively maintaining `vim-git-log` again. _Pleaaase._ – Cecil Curry Aug 16 '15 at 07:37
4

First, open the file you want to diff with.

If the change is committed, enter :Gdiff HEAD~1.
If the change is NOT committed, enter :Gdiff HEAD.

Kordan Ou
  • 1,502
  • 3
  • 15
  • 25
2

When using :Glog you can simply press <cr> on the line that starts diff --git. It will open the diff. You may also want to look into :Gdiff. You may want to look at Drew Neil's vimcasts, The Fugitive Series.

For more help see

:h fugitive
:h :Glog
:h :Gdiff
Peter Rincker
  • 43,539
  • 9
  • 74
  • 101
  • 1
    The behaviour you described (simply press ``) is exactly what I'd like, but I don't get a diff, I just get the whole file at that particular revision. – zoran119 May 29 '13 at 22:30
  • Make sure you are on the line `diff --get a/somefile b/somefile`. – Peter Rincker May 29 '13 at 22:40
  • So I open a file in vim and then do `:Glog`. This populates a list of versions of the file in the quickfix list. I do not see a `diff --get` line anywhere there... I must be misunderstanding your instructions. – zoran119 May 30 '13 at 01:09
  • You have to go to an actual commit object. Do `:cn` or `:cfirst` – Peter Rincker May 30 '13 at 01:47
  • 1
    Still couldn't get it to work... Found a plugin with the behaviour I wanted: https://github.com/kablamo/vim-git-log – zoran119 Aug 29 '13 at 23:25
  • 3
    I believe that @PeterRincker's answer is dependent on running `:Glog -- %` first. This will (from `:h :Glog`): Load all "... previous commits rather than previous file revisions ..." for the current buffer. This is very different than just `:Glog`, which will: "Load all previous revisions of the current file into the quickfix list." When the buffer contains a commit, instead of a file revision, you will see the `diff --get a/somefile b/somefile` lines and will be able to follow his answer. – irkenInvader Sep 30 '13 at 17:33
2

To diff with its previous version, follow these steps:

  1. use Glog
  2. navigate to the desired version
  3. type C, which opens the commit
  4. go to the line contains diff --git a/you/file b/you/file and press <cr>

Moreover, to diff a previous version with the version in index (the working version), you can do this:

  1. use Glog
  2. navigate to the desired version
  3. use Gdiff in this new window without parameter. Done!

Gdiff without parameter will diff the current buffer with the one in index, which is exactly what you want

You can also consider using the plugin vim-unimpaired, which provides two maps ]q and [q to navigate the quickfix list. (Also ]Q and [Q)

doraemon
  • 2,296
  • 1
  • 17
  • 36
1

You can achieve this by following these steps:

  1. Change focus to the quickfix window and navigate to the line corresponding to the commit you're interested in.
  2. Find the commit hash in the line and yank it (the hash is now in the 0 register.
  3. Close the quickfix buffer, and do :Gdiff <C-r>0.

That should fire up the proper diff.

You can automate steps 2 and 3 by adding this mapping to your .vimrc file:

nnoremap <Leader>gd /\.git<CR>wwwyw<Esc>:cclose<CR>:Gdiff <C-r>0<CR>

Notice that the mapping assumes your cursor is at the beginning of the line (before the .git// part).

sdeleon28
  • 329
  • 1
  • 11
1

Try :vert Gdiff. This will show the diff of the current file in left-right mode.

Wong Jia Hau
  • 2,639
  • 2
  • 18
  • 30
0

One way to see diff of a commit is this:

:Gedit [revision]
sirex
  • 4,593
  • 2
  • 32
  • 21
0

I wrote a function that allows you to diff against a previous revision of the current file. I use this to view the diff between the working copy and revisions "n" times back.

Here's the code to put in your .vimrc (requires https://github.com/tpope/vim-fugitive):

"Diff the current file against n revision (instead of n commit)
function! Diffrev(...)

  let a:target = @%

  "check argument count
  if a:0 == 0
    "no revision number specified
    let a:revnum=0
  else
    "revision number specified
    let a:revnum=a:1
  endif

  let a:hash = system('git log -1 --skip='.a:revnum.' --pretty=format:"%h" ' . a:target)
  execute 'Gdiff' . a:hash
endfunc

You can call the function like so (example below diffs against 3rd revision back):

:call Diffrev(2)

user3751385
  • 3,752
  • 2
  • 24
  • 24