[PATCH] Update git-clone documentation

[git.git] / git-merge.sh

diff --git a/git-merge.sh b/git-merge.sh
index 41bc6d9..d12a2a9 100755 (executable)
--- a/git-merge.sh
+++ b/git-merge.sh
@@ -18,8 +18,24 @@ all_strategies='recursive octopus resolve stupid'
 default_strategies='resolve octopus'
 use_strategies=
 
-dropheads() {
-       rm -f -- "$GIT_DIR/MERGE_HEAD" || exit 1
+dropsave() {
+       rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
+                "$GIT_DIR/MERGE_SAVE" || exit 1
+}
+
+savestate() {
+       # Stash away any local modifications.
+       git-diff-index -r -z --name-only $head |
+       cpio -0 -o >"$GIR_DIR/MERGE_SAVE"
+}
+
+restorestate() {
+        if test -f "$GIT_DIR/MERGE_SAVE"
+       then
+               git reset --hard $head
+               cpio -iuv <"$GIT_DIR/MERGE_SAVE"
+               git-update-index --refresh >/dev/null
+       fi
 }
 
 summary() {
@@ -93,23 +109,44 @@ case "$#,$common" in
        # If head can reach all the merge then we are up to date.
        # but first the most common case of merging one remote
        echo "Already up-to-date. Yeeah!"
-       dropheads
+       dropsave
        exit 0
        ;;
 1,"$head")
        # Again the most common case of merging one remote.
        echo "Updating from $head to $1."
        git-update-index --refresh 2>/dev/null
-       git-read-tree -u -m $head "$1" || exit 1
-       git-rev-parse --verify "$1^0" > "$GIT_DIR/HEAD"
+       git-read-tree -u -m $head "$1" &&
+       new_head=$(git-rev-parse --verify "$1^0") &&
+       git-update-ref HEAD "$new_head" "$head" || exit 1
        summary "$1"
-       dropheads
+       dropsave
        exit 0
        ;;
-1,*)
+1,?*"$LF"?*)
        # We are not doing octopus and not fast forward.  Need a
        # real merge.
        ;;
+1,*)
+       # We are not doing octopus, not fast forward, and have only
+       # one common.  See if it is really trivial.
+       echo "Trying really trivial in-index merge..."
+       git-update-index --refresh 2>/dev/null
+       if git-read-tree --trivial -m -u $common $head "$1" &&
+          result_tree=$(git-write-tree)
+       then
+           echo "Wonderful."
+           result_commit=$(
+               echo "$merge_msg" |
+               git-commit-tree $result_tree -p HEAD -p "$1"
+           ) || exit
+           git-update-ref HEAD $result_commit $head
+           summary $result_commit
+           dropsave
+           exit 0
+       fi
+       echo "Nope."
+       ;;
 *)
        # An octopus.  If we can reach all the remote we are up to date.
        up_to_date=t
@@ -125,30 +162,47 @@ case "$#,$common" in
        if test "$up_to_date" = t
        then
                echo "Already up-to-date. Yeeah!"
-               dropheads
+               dropsave
                exit 0
        fi
        ;;
 esac
 
-# At this point we need a real merge.  Require that the tree matches
-# exactly our head.
+# At this point, we need a real merge.  No matter what strategy
+# we use, it would operate on the index, possibly affecting the
+# working tree, and when resolved cleanly, have the desired tree
+# in the index -- this means that the index must be in sync with
+# the $head commit.  The strategies are responsible to ensure this.
 
-git-update-index --refresh &&
-test '' = "`git-diff-index --cached --name-only $head`" || {
-       die "Need real merge but the working tree has local changes."
-}
+case "$use_strategies" in
+?*' '?*)
+    # Stash away the local changes so that we can try more than one.
+    savestate
+    single_strategy=no
+    ;;
+*)
+    rm -f "$GIT_DIR/MERGE_SAVE"
+    single_strategy=yes
+    ;;
+esac
 
 result_tree= best_cnt=-1 best_strategy= wt_strategy=
 for strategy in $use_strategies
 do
     test "$wt_strategy" = '' || {
        echo "Rewinding the tree to pristine..."
-       git reset --hard $head
+       restorestate
     }
-    echo "Trying merge strategy $strategy..."
+    case "$single_strategy" in
+    no)
+       echo "Trying merge strategy $strategy..."
+       ;;
+    esac
+
+    # Remember which strategy left the state in the working tree
     wt_strategy=$strategy
-    git-merge-$strategy $common -- $head_arg "$@" || {
+
+    git-merge-$strategy $common -- "$head_arg" "$@" || {
 
        # The backend exits with 1 when conflicts are left to be resolved,
        # with 2 when it does not handle the given merge at all.
@@ -182,18 +236,18 @@ then
     do
         parents="$parents -p $remote"
     done
-    result_commit=$(echo "$merge_msg" | git-commit-tree $result_tree $parents)
+    result_commit=$(echo "$merge_msg" | git-commit-tree $result_tree $parents) || exit
     echo "Committed merge $result_commit, made by $wt_strategy."
-    echo $result_commit >"$GIT_DIR/HEAD"
+    git-update-ref HEAD $result_commit $head
     summary $result_commit
-    dropheads
+    dropsave
     exit 0
 fi
 
 # Pick the result from the best strategy and have the user fix it up.
 case "$best_strategy" in
 '')
-       git reset --hard $head
+       restorestate
        die "No merge strategy handled the merge."
        ;;
 "$wt_strategy")
@@ -201,13 +255,15 @@ case "$best_strategy" in
        ;;
 *)
        echo "Rewinding the tree to pristine..."
-       git reset --hard $head
+       restorestate
        echo "Using the $best_strategy to prepare resolving by hand."
-       git-merge-$best_strategy $common -- $head_arg "$@"
+       git-merge-$best_strategy $common -- "$head_arg" "$@"
        ;;
 esac
 for remote
 do
        echo $remote
 done >"$GIT_DIR/MERGE_HEAD"
+echo $merge_msg >"$GIT_DIR/MERGE_MSG"
+
 die "Automatic merge failed; fix up by hand"