8

I have a commit in a git repository where git show says only one file is modified while git diff shows two files as being modified.

I have created a simple sample repository that exhibits the same behaviour.

In the sample repo we have this simple history:

*   c248261      (HEAD, origin/master, master) Merged feature into master.
|\  
| * d23c497      (feature) Modified fileA and fileB in feature.
* | 06a7f5e      Modified fileA and fileC in master.
* |   9cd1a6e    Merged feature into master.
|\ \  
| |/  
| * aed2e5e      Modified fileA and fileB in feature.
* | c6e4fe7      Mofified fileC in master.
* |   19ed298    Merged feature to master.
|\ \  
| |/  
| * c0f2abc      Added fileB and modified fileA in feature.
* | 47c67cf      Added fileC in master.
|/  
* 56a9b73        Added fileA in master.

When I look at commit c248261 in e.g. SourceTree, I can see that fileA and fileB is modified. Using git diff gives the same result:

$ git diff --name-only c248261^..c248261
fileA
fileB
$

or using the shorthand notation:

$ git diff --name-only c248261^!
fileA
fileB
$

When I try to get the same information using git show, only one of the two files show up:

$ git show --name-only c248261
commit c2482616b6b6781d0580ec1008ef7d0ab5f73a70
Merge: 06a7f5e d23c497
Author: ...
Date:   Fri Aug 15 16:19:02 2014 +0200

    Merged feature into master.

fileA
$

Similarly, git diff-tree shows nothing:

$ git diff-tree c248261
$

Can anybody explain the difference, please?

I am using git version 2.0.4.

Improve this question

3 Answers 3

Reset to default
7

What is git show?

The command git show is a generic command for displaying information about an object in git.

From the man page (git help show):

Shows one or more objects (blobs, trees, tags and commits).
...
For commits it shows the log message and textual diff.
It also presents the merge commit in a special format as produced by
  git diff-tree --cc
...

So, the output of git show is different because this is a merge commit rather than a plain commit.

The man page for git diff-tree --cc says:

--cc
    This flag changes the way a merge commit patch is displayed, in a 
    similar way to the -c option. It implies the -c and -p options and
    further compresses the patch output by omitting uninteresting hunks whose
    the contents in the parents have only two variants and the merge result
    picks one of them without modification. When all hunks are uninteresting,
    the commit itself and the commit log message is not shown, just like in
    any other "empty diff" case.

further

-c
    This flag changes the way a merge commit is displayed (which means
    it is useful only when the command is given one <tree-ish>, or
    --stdin). It shows the differences from each of the parents to the
    merge result simultaneously instead of showing pairwise diff
    between a parent and the result one at a time (which is what the -m
    option does). Furthermore, it lists only files which were modified
    from all parents.

Please take notice of that last line which I repeat here:

Furthermore, it lists only files which were modified from all parents.

So git show on a merge commit will only list the files that were modified when comparing the commit to all parents of the merge. For an ordinary merge (i.e. 2 parents) this is exactly the files that were merged. If, for example, you do this merge:

git checkout master
git merge feature

The files listed by git show are the files that were modified in both master and feature prior to the merge and were merged together in the merge commit.

For an octopus merge – i.e. more than two parents – the resulting file must differ from the file in all parents to be displayed by git show.

Please note, that other files can also show up when using git show on a merge commit. If, for example, you call git merge --no-commit and then before committing do any of the following, then these files will also be displayed by git show on the merge commit:

  • Add a new file.
  • Delete an existing file.
  • Modify any file – including any of the files already staged by git merge.

Conclusion

What git show is doing is displaying a so-called combined diff.

The result of running the command git show on a merge commit can be thought of as showing only the files which were merged and not the files that were simply taken unchanged from one of the two parents.

This is a bit surprising as many people expect to see which files were modified compared to the branch into which you just merged.

So what to do if you want to look at the diff between either of the parents?

Let's have a final look at the man page of git show:

COMBINED DIFF FORMAT
  Any diff-generating command can take the `-c` or --cc option to produce
  a combined diff when showing a merge. This is the default format when
  showing merges with git-diff(1) or git-show(1). Note also that you can
  give the `-m' option to any of these commands to force generation of
  diffs with individual parents of a merge.

So we can use the -m option to get both diffs like this:

git show -m commit

This will give you the diffs against all parents one by one.

To see the difference between the merge commit and the previous commit on the branch into which you merged (i.e. the first parent), use either of these commands:

git show --first-parent commit
git diff commit^..commit
git diff commit^!

The --first-parent option really belongs to git log but also works for git show. The notation commit^! is a shorthand for commit^..commit.

To see the difference between the merge commit and the branch from which you merged (e.g. to see what you left out from the other branch), use

git diff commit^2..commit

The notation commit^2 means the 2nd parent of commit.

If you have more than 2 parents (i.e. an octopus merge) I am sure you can guess how to diff against the 3rd, 4th, etc. commits.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

From the man page (git help show)

For commits it shows the log message and textual diff.
It also presents the merge commit in a special format as produced by
  git diff-tree --cc
...
For plain blobs, it shows the plain contents.

So, the output of git show is different because this is a merge commit rather than a plain blob. The docs for git diff-tree --cc say:

--cc
    This flag changes the way a merge commit patch is displayed, in a 
    similar way to the -c option. It implies the -c and -p options and
    further compresses the patch output by omitting uninteresting hunks whose
    the contents in the parents have only two variants and the merge result
    picks one of them without modification. When all hunks are uninteresting,
    the commit itself and the commit log message is not shown, just like in
    any other "empty diff" case.
Improve this answer

8 Comments

Ok, it becomes interesting now. Calling git diff-tree c248261 returns nothing. However, git diff-tree --name-only c248261^ c248261 returns the expected result. I thought they were equivalent, but reading the man page I can see they are not.
How about git diff-tree -cc c248261, which is what git show is actually running?
Sorry, tried that and the forgot --cc again. Running git diff-tree --cc --name-only c248261 lists only fileA. Leaving out --name-only does the same but also shows the diff. fileB is not listed. BTW, fileA is the only file that is modified in both parents. fileB is only modified in the 2nd parent (the branch from which we merge) and fileC is only modified in the 1st parent (the branch to which we merge).
The man page for git diff-tree says: "If there is only one <tree-ish> given, the commit is compared with its parents (see --stdin below).", and under --stdin: "When a single commit is given, it compares the commit with its parents." Not sure what this means exactly.
Ok, under the man page for git diff-tree it says for --cc that "It implies the -c and -p options..." and for -c it says Furthermore, it lists only files which were modified from all parents. So thats the reason. I'll update the answer.
|
0

By looking at the commit message for commit c248261, probably commit you are looking for is a merge commit. A merge commit has more than one parents.

A suffix ^ to a revision parameter means the first parent of that commit object.

So, when you say,

$ git diff --name-only c248261^..c248261
fileA
fileB
$

It does a diff from the first parent of the commit c248261.

You can try doing,

$ git diff --name-only c248261^2..c248261

which will give you the following result,

fileA
--other files if exist--

After the merge of the two parents, a new commit would have created, i.e. c248261, which has just one file with differences, which is what you see when you say,

git show --name-only c248261
Improve this answer

1 Comment

Yes, it is a merge commit and I am aware it has two parents. What I want to see is the modified files between this commit and its first parent – e.g. what was changed in the branch I merged to. And the merge commit actually modified two files compared to the first parent – not one.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.