On Sun, 17 Apr 2005, Junio C Hamano wrote:
>
> This is the alternative strategy I mentioned in my previous
> message. A new -m option to checkout-cache causes it to store
> contents of unmerged paths in path~1~, path~2~, and path~3~.
I don't think this is wrong, but it all seems a bit hacky. The reason I
didn't apply your other patch was that I just don't feel quite comfortable
with what is the RightThing(tm) to do yet.
I'm actually fairly certain that the right thing to do is to silently
ignore all unmerged entries. They just aren't "interesting" from a
checkout-cache perspective, least of all when given the "-a" flag. So even
warning about them seems to be pointless.
The other issue is that obviously we _do_ need to have some way to merge
them, but as far as I can tell, we've really got that already in
"show-files --unmerged" together with "cat-file blob xxxx". I do believe
that it's a damn ugly script, and that maybe we could create some helper
plumbing to make it more obvious, but I haven't quite decided what the
right helper interface would be.
Writing files to the current working directory I don't like, especially as
we don't even necessarily write all three files (so with your example
code, if there was a left-over xxx~1~ file from a previous merge, your
merger would really get confused now since it thinks it has an original
file that didn't actually really exist). So I'd much rather write them to
a /tmp directory instead, let the user merge them some way.
I'm actually thinking that maybe the _right_ interface is to do something
like this:
merge-cache <program> <filename>
and what that does is to look up the <filename> in the cache, and if it
has any merge entries, unpack all of them (which may be just one file, of
course) into up to three separate files (mkstemp()), and then execve the
supplied program name with those three files as arguments 1,2,3 (empty
argument if no file), and "filename" as argument 4.
So now the program could be a simple script:
#!/bin/sh
#
# This is the git merge script, called with
#
# $1 - original file (or empty string)
# $2 - file in branch1 (or empty string)
# $3 - file in branch2 (or empty string)
# $4 - pathname in repository
#
#
# Case 1: file removed in both
#
if [ -z "$2" && -z "$3" ]; then
rm -- "$4"
update-cache --remove -- "$4"
exit 0
fi
#
# Case 2: file exists in just one
#
if [ -z "$2" || -z "$3" ] then
cat "$2""$3" > "$4"
update-cache --add -- "$4"
exit 0
fi
#
# Case 3: file exists in both
#
src="$1"
if [ -z "$1" ]; then
src=/den/null
fi
merge "$3" "$src" "$2" && cp "$3" "$4" && update-cache --add -- "$4"
or you could so something fancier.
This would _seem_ to be a very simple way to generate a nice merge (the
merge script can obviously be a lot smarter than the above thing,
including doing nice graphical merge interfaces).
An extension of this might be to make "merge-cache" take several
filenames, and merge them one at a time (stopping if the merge program
returns a failure code). And obviously this also expands trivially to the
normal "-a" case, which would do the same, except it would just call the
merge program for any file it finds that needs merging)
What do you think? I can whip up a "merge-cache" program like that in five
minutes, and it _seems_ like the right interface..
Linus
-
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
