rebase: implement --[no-]autostash and rebase.autostash

This new feature allows a rebase to be executed on a dirty worktree or
index.  It works by creating a temporary "dangling merge commit" out
of the worktree and index changes (via 'git stash create'), and
automatically applying it after a successful rebase or abort.

rebase stores the SHA-1 hex of the temporary merge commit, along with
the rest of the rebase state, in either
.git/{rebase-merge,rebase-apply}/autostash depending on the kind of
rebase.  Since $state_dir is automatically removed at the end of a
successful rebase or abort, so is the autostash.

The advantage of this approach is that we do not affect the normal
stash's reflogs, making the autostash invisible to the end-user.  This
means that you can use 'git stash' during a rebase as usual.

When the autostash application results in a conflict, we push
$state_dir/autostash onto the normal stash and remove $state_dir
ending the rebase.  The user can inspect the stash, and pop or drop at
any time.

Most significantly, this feature means that a caller like pull (with
pull.rebase set to true) can easily be patched to remove the
require_clean_work_tree restriction.

Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 6e53fc507489fb2add3184998b8ec2a43e84b249..7fd4035cb52dfb746fad496fd27347f538c31006 100644 (file)
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -1867,6 +1867,14 @@ rebase.stat::
 rebase.autosquash::
        If set to true enable '--autosquash' option by default.
 
+rebase.autostash::
+       When set to true, automatically create a temporary stash
+       before the operation begins, and apply it after the operation
+       ends.  This means that you can run rebase on a dirty worktree.
+       However, use with care: the final stash application after a
+       successful rebase might result in non-trivial conflicts.
+       Defaults to false.
+
 receive.autogc::
        By default, git-receive-pack will run "git-gc --auto" after
        receiving data from git-push and updating refs.  You can stop

diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt
index aca840525eee7bb3743baf7f72d8c0f240ff1b60..c84854ae87df094683600c559e88c13a8b770e01 100644 (file)
--- a/Documentation/git-rebase.txt
+++ b/Documentation/git-rebase.txt
@@ -208,6 +208,9 @@ rebase.stat::
 rebase.autosquash::
        If set to true enable '--autosquash' option by default.
 
+rebase.autostash::
+       If set to true enable '--autostash' option by default.
+
 OPTIONS
 -------
 --onto <newbase>::
@@ -394,6 +397,13 @@ If the '--autosquash' option is enabled by default using the
 configuration variable `rebase.autosquash`, this option can be
 used to override and disable this setting.
 
+--[no-]autostash::
+       Automatically create a temporary stash before the operation
+       begins, and apply it after the operation ends.  This means
+       that you can run rebase on a dirty worktree.  However, use
+       with care: the final stash application after a successful
+       rebase might result in non-trivial conflicts.
+
 --no-ff::
        With --interactive, cherry-pick all rebased commits instead of
        fast-forwarding over the unchanged ones.  This ensures that the

diff --git a/git-rebase.sh b/git-rebase.sh
index f8b533d18352c86b16b4507870517b8fe57b26ee..d0c11a910a69603ac19c83a5d29af9f32f780267 100755 (executable)
--- a/git-rebase.sh
+++ b/git-rebase.sh
@@ -13,6 +13,7 @@ git-rebase --continue | --abort | --skip | --edit-todo
  Available options are
 v,verbose!         display a diffstat of what changed upstream
 q,quiet!           be quiet. implies --no-stat
+autostash!         automatically stash/stash pop before and after
 onto=!             rebase onto given branch instead of upstream
 p,preserve-merges! try to recreate merges instead of ignoring them
 s,strategy=!       use the given merge strategy
@@ -64,6 +65,7 @@ apply_dir="$GIT_DIR"/rebase-apply
 verbose=
 diffstat=
 test "$(git config --bool rebase.stat)" = true && diffstat=t
+autostash="$(git config --bool rebase.autostash || echo false)"
 git_am_opt=
 rebase_root=
 force_rebase=
@@ -143,6 +145,29 @@ move_to_original_branch () {
        esac
 }
 
+finish_rebase () {
+       if test -f "$state_dir/autostash"
+       then
+               stash_sha1=$(cat "$state_dir/autostash")
+               if git stash apply $stash_sha1 2>&1 >/dev/null
+               then
+                       echo "$(gettext 'Applied autostash.')"
+               else
+                       ref_stash=refs/stash &&
+                       >>"$GIT_DIR/logs/$ref_stash" &&
+                       git update-ref -m "autostash" $ref_stash $stash_sha1 ||
+                       die "$(eval_gettext 'Cannot store $stash_sha1')"
+
+                       gettext 'Applying autostash resulted in conflicts.
+Your changes are safe in the stash.
+You can run "git stash pop" or "git stash drop" it at any time.
+'
+               fi
+       fi
+       git gc --auto &&
+       rm -rf "$state_dir"
+}
+
 run_specific_rebase () {
        if [ "$interactive_rebase" = implied ]; then
                GIT_EDITOR=:
@@ -153,8 +178,7 @@ run_specific_rebase () {
        ret=$?
        if test $ret -eq 0
        then
-               git gc --auto &&
-               rm -rf "$state_dir"
+               finish_rebase
        fi
        exit $ret
 }
@@ -248,6 +272,9 @@ do
        --stat)
                diffstat=t
                ;;
+       --autostash)
+               autostash=true
+               ;;
        -v)
                verbose=t
                diffstat=t
@@ -348,7 +375,7 @@ abort)
                ;;
        esac
        output git reset --hard $orig_head
-       rm -r "$state_dir"
+       finish_rebase
        exit
        ;;
 edit-todo)
@@ -487,6 +514,18 @@ case "$#" in
        ;;
 esac
 
+if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
+then
+       stash_sha1=$(git stash create "autostash") ||
+       die "$(gettext 'Cannot autostash')"
+
+       mkdir -p "$state_dir" &&
+       echo $stash_sha1 >"$state_dir/autostash" &&
+       stash_abbrev=$(git rev-parse --short $stash_sha1) &&
+       echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
+       git reset --hard
+fi
+
 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
 
 # Now we are rebasing commits $upstream..$orig_head (or with --root,

diff --git a/t/t3420-rebase-autostash.sh b/t/t3420-rebase-autostash.sh
new file mode 100755 (executable)
index 0000000..479cbb2
--- /dev/null
+++ b/t/t3420-rebase-autostash.sh
@@ -0,0 +1,148 @@
+#!/bin/sh
+#
+# Copyright (c) 2013 Ramkumar Ramachandra
+#
+
+test_description='git rebase --autostash tests'
+. ./test-lib.sh
+
+test_expect_success setup '
+       echo hello-world >file0 &&
+       git add . &&
+       test_tick &&
+       git commit -m "initial commit" &&
+       git checkout -b feature-branch &&
+       echo another-hello >file1 &&
+       echo goodbye >file2 &&
+       git add . &&
+       test_tick &&
+       git commit -m "second commit" &&
+       echo final-goodbye >file3 &&
+       git add . &&
+       test_tick &&
+       git commit -m "third commit" &&
+       git checkout -b unrelated-onto-branch master &&
+       echo unrelated >file4 &&
+       git add . &&
+       test_tick &&
+       git commit -m "unrelated commit" &&
+       git checkout -b related-onto-branch master &&
+       echo conflicting-change >file2 &&
+       git add . &&
+       test_tick &&
+       git commit -m "related commit"
+'
+
+testrebase() {
+       type=$1
+       dotest=$2
+
+       test_expect_success "rebase$type: dirty worktree, non-conflicting rebase" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               git rebase$type unrelated-onto-branch &&
+               grep unrelated file4 &&
+               grep dirty file3 &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: dirty index, non-conflicting rebase" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               git add file3 &&
+               git rebase$type unrelated-onto-branch &&
+               grep unrelated file4 &&
+               grep dirty file3 &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: conflicting rebase" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               test_must_fail git rebase$type related-onto-branch &&
+               test_path_is_file $dotest/autostash &&
+               ! grep dirty file3 &&
+               rm -rf $dotest &&
+               git reset --hard &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: --continue" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               test_must_fail git rebase$type related-onto-branch &&
+               test_path_is_file $dotest/autostash &&
+               ! grep dirty file3 &&
+               echo "conflicting-plus-goodbye" >file2 &&
+               git add file2 &&
+               git rebase --continue &&
+               test_path_is_missing $dotest/autostash &&
+               grep dirty file3 &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: --skip" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               test_must_fail git rebase$type related-onto-branch &&
+               test_path_is_file $dotest/autostash &&
+               ! grep dirty file3 &&
+               git rebase --skip &&
+               test_path_is_missing $dotest/autostash &&
+               grep dirty file3 &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: --abort" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >>file3 &&
+               test_must_fail git rebase$type related-onto-branch &&
+               test_path_is_file $dotest/autostash &&
+               ! grep dirty file3 &&
+               git rebase --abort &&
+               test_path_is_missing $dotest/autostash &&
+               grep dirty file3 &&
+               git checkout feature-branch
+       '
+
+       test_expect_success "rebase$type: non-conflicting rebase, conflicting stash" '
+               test_config rebase.autostash true &&
+               git reset --hard &&
+               git checkout -b rebased-feature-branch feature-branch &&
+               test_when_finished git branch -D rebased-feature-branch &&
+               echo dirty >file4 &&
+               git add file4 &&
+               git rebase$type unrelated-onto-branch &&
+               test_path_is_missing $dotest &&
+               git reset --hard &&
+               grep unrelated file4 &&
+               ! grep dirty file4 &&
+               git checkout feature-branch &&
+               git stash pop &&
+               grep dirty file4
+       '
+}
+
+testrebase "" .git/rebase-apply
+testrebase " --merge" .git/rebase-merge
+testrebase " --interactive" .git/rebase-merge
+
+test_done