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:

        # 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
        # Case 2: file exists in just one
        if [ -z "$2" || -z "$3" ] then
                cat "$2""$3" > "$4"
                update-cache --add -- "$4"
                exit 0
        # Case 3: file exists in both
        if [ -z "$1" ]; then
        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..

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

Reply via email to