question about a merge result

Hello,

I'm a little bit confused about a merge I have done and the result suprised me. Thinking about it I'm still not convinced what should be the result.

Here's the use case:

$ mkdir test-git && cd test-git $ date > A $ date > B $ git init $ git add . $ git commit -m "Init"

So far I just created a repo with 2 files A and B

$ git branch b1 $ git rm B $ git commit -m "remove B"

Now I created a branch 'b1' and remove B file in master branch

$ git checkout b1 $ git rm B $ git commit -m "remove B" $ git revert HEAD

Now on 'b1' I did the same as master but I thought that removing B was a bad idea so I revert the previous commit

$ git checkout master $ git pull . b1 $ ls B ls: cannot access B: No such file or directory

So merging 'b1' into master removed the B file even if in branch 'b1' I restored it.

Could anybody explain me why this is the correct behaviour and why not file 'B' is not restored as it was done in branch 'b1' ?

thanks

Francis Moreau schrieb:

well, I'd say the thing is, that in b1 there is no change at all to the tree anymore, so when applied to master (without B) there is no b restored

On Thu, Apr 30, 2009 at 02:34:43PM +0200, Michael Gaber wrote:

That is exactly it. Git's 3-way merge doesn't look at the intervening history at all. It looks _only_ at the two endpoints and their merge-base (well, that is a bit of a simplification, as there may be multiple merge-bases, but it is what is happening here).

-Peff

On Thu, Apr 30, 2009 at 4:26 PM, Jeff King <peff@peff.net> wrote:

Well, obviously it's how git works since it's what I got.

But the question was more about if the cortectness of the end result: should 'B' removed after the merge.

IOW if someone works on its own branch remove B file and thought it was a bad idea and restore it whereas another person remove B file but miss the fact that it was a bad idea, does the merge should silently remove B file ?

On 2009.04.30 17:05:19 +0200, Francis Moreau wrote:

You can also have that in the opposite direction. You make a bugfix in your "master" branch, then cherry-pick that to "maint", but later realize that you actually can't backport it like and and revert the cherry-pick. Then, later, you go to merge "maint" to "master" (to get other bugfixes that were done directly on "maint"): Should the bugfix be reverted on "master"? Obviously not.

git takes an approach that's easy to understand: Look at the changes that the branch made compared to the common ancestor and apply those. And for a "do it and then revert it" case, the answer is: There are no changes.

Björn

On Thu, Apr 30, 2009 at 05:05:19PM +0200, Francis Moreau wrote:

Yes, I meant also "this is what it is supposed to do, by design".

Yes, it should be removed. And it has nothing to do with removal. Both branches performed some action, but only one reverted it. Thus you still have one branch wanting to make the change, and the other side leaving it alone (in aggregate). So we want to take the changed side.

The only other thing that might make sense would be a conflict (because both sides touched the same area and ended with different results). Git doesn't try to find such a conflict because:

  1. Fundamentally, git cares about endpoints, not changelogs. So by
     design, you can arrive at the same tree state by many different
     routes and the merge will still happen in the same way.

  2. Finding such a conflict in the general case would be quite
     expensive, because you have to track every bit of content changed
     on one branch through every commit on the other branch, to see if
     they ever overlap.

If you want the result of the merge to keep it, you should do one of:

  - revert the removal in _both_ branches

  - merge with "--no-commit", add it back in, and then commit. The
    resulting commit will be a merge commit with the state you specify.

  - merge the early part of one branch, with the removal, into the other
    branch. Then "removed" becomes your basis for comparison, and then
    when you re-merge, the branch that re-adds it will be the only
    change.

-Peff

On Thu, 30 Apr 2009, Francis Moreau wrote:

Consider that deciding to remove a file can happen for a variety of reasons. Maybe one branch wiped it out accidentally and restored it, while the other did a bunch of work to make it obsolete and then removed it intentionally. There's no reason to think that the reason behind reverting the delete on one branch applies to the other delete.

Now, if the "b1" branch had gotten the delete from "master" by merging the same commit, and had reverted the commit that deleted the file, then git should (and does) include the file in the merge result, because then some user saw that particular deletion and decided it was wrong and reverted it. (Of course, git doesn't actually consider this in its merge algorithm, but, for clever mathematical reasons, what it does is equivalent.)

	-Daniel
*This .sig left intentionally blank*