2007-06-25 00:11:14 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Copyright (c) 2007 Johannes E. Schindelin
|
|
|
|
#
|
|
|
|
|
|
|
|
test_description='git rebase interactive
|
|
|
|
|
|
|
|
This test runs git rebase "interactively", by faking an edit, and verifies
|
|
|
|
that the result still makes sense.
|
2010-10-31 07:39:51 +00:00
|
|
|
|
|
|
|
Initial setup:
|
|
|
|
|
|
|
|
one - two - three - four (conflict-branch)
|
|
|
|
/
|
|
|
|
A - B - C - D - E (master)
|
|
|
|
| \
|
|
|
|
| F - G - H (branch1)
|
|
|
|
| \
|
|
|
|
|\ I (branch2)
|
|
|
|
| \
|
|
|
|
| J - K - L - M (no-conflict-branch)
|
|
|
|
\
|
|
|
|
N - O - P (no-ff-branch)
|
|
|
|
|
|
|
|
where A, B, D and G all touch file1, and one, two, three, four all
|
|
|
|
touch file "conflict".
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
2009-08-09 08:37:52 +00:00
|
|
|
. "$TEST_DIRECTORY"/lib-rebase.sh
|
2009-01-27 22:34:29 +00:00
|
|
|
|
2010-03-24 20:34:04 +00:00
|
|
|
# WARNING: Modifications to the initial repository can change the SHA ID used
|
|
|
|
# in the expect2 file for the 'stop on conflicting pick' test.
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'setup' '
|
2009-12-07 04:22:58 +00:00
|
|
|
test_commit A file1 &&
|
|
|
|
test_commit B file1 &&
|
|
|
|
test_commit C file2 &&
|
|
|
|
test_commit D file1 &&
|
|
|
|
test_commit E file3 &&
|
2007-06-25 00:11:14 +00:00
|
|
|
git checkout -b branch1 A &&
|
2009-12-07 04:22:58 +00:00
|
|
|
test_commit F file4 &&
|
|
|
|
test_commit G file1 &&
|
|
|
|
test_commit H file5 &&
|
2007-06-25 00:11:14 +00:00
|
|
|
git checkout -b branch2 F &&
|
2010-10-31 07:30:58 +00:00
|
|
|
test_commit I file6 &&
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout -b conflict-branch A &&
|
2010-10-31 07:38:25 +00:00
|
|
|
test_commit one conflict &&
|
|
|
|
test_commit two conflict &&
|
|
|
|
test_commit three conflict &&
|
|
|
|
test_commit four conflict &&
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout -b no-conflict-branch A &&
|
2010-10-31 07:38:25 +00:00
|
|
|
test_commit J fileJ &&
|
|
|
|
test_commit K fileK &&
|
|
|
|
test_commit L fileL &&
|
|
|
|
test_commit M fileM &&
|
2010-03-24 20:34:04 +00:00
|
|
|
git checkout -b no-ff-branch A &&
|
2010-10-31 07:38:25 +00:00
|
|
|
test_commit N fileN &&
|
|
|
|
test_commit O fileO &&
|
|
|
|
test_commit P fileP
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
|
2016-06-29 14:31:03 +00:00
|
|
|
# "exec" commands are run with the user shell by default, but this may
|
2010-08-10 15:17:51 +00:00
|
|
|
# be non-POSIX. For example, if SHELL=zsh then ">file" doesn't work
|
2016-05-10 14:05:58 +00:00
|
|
|
# to create a file. Unsetting SHELL avoids such non-portable behavior
|
2010-12-27 08:03:43 +00:00
|
|
|
# in tests. It must be exported for it to take effect where needed.
|
2010-08-10 15:17:51 +00:00
|
|
|
SHELL=
|
2010-12-27 08:03:43 +00:00
|
|
|
export SHELL
|
2010-08-10 15:17:51 +00:00
|
|
|
|
2014-05-18 20:28:39 +00:00
|
|
|
test_expect_success 'rebase --keep-empty' '
|
|
|
|
git checkout -b emptybranch master &&
|
|
|
|
git commit --allow-empty -m "empty" &&
|
|
|
|
git rebase --keep-empty -i HEAD~2 &&
|
|
|
|
git log --oneline >actual &&
|
|
|
|
test_line_count = 6 actual
|
|
|
|
'
|
|
|
|
|
2010-08-10 15:17:51 +00:00
|
|
|
test_expect_success 'rebase -i with the exec command' '
|
|
|
|
git checkout master &&
|
|
|
|
(
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-08-10 15:17:51 +00:00
|
|
|
FAKE_LINES="1 exec_>touch-one
|
|
|
|
2 exec_>touch-two exec_false exec_>touch-three
|
|
|
|
3 4 exec_>\"touch-file__name_with_spaces\";_>touch-after-semicolon 5" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
test_must_fail git rebase -i A
|
|
|
|
) &&
|
2010-08-10 15:17:52 +00:00
|
|
|
test_path_is_file touch-one &&
|
|
|
|
test_path_is_file touch-two &&
|
|
|
|
test_path_is_missing touch-three " (should have stopped before)" &&
|
2010-10-31 07:40:30 +00:00
|
|
|
test_cmp_rev C HEAD &&
|
2010-08-10 15:17:51 +00:00
|
|
|
git rebase --continue &&
|
2010-08-10 15:17:52 +00:00
|
|
|
test_path_is_file touch-three &&
|
|
|
|
test_path_is_file "touch-file name with spaces" &&
|
|
|
|
test_path_is_file touch-after-semicolon &&
|
2010-10-31 07:40:30 +00:00
|
|
|
test_cmp_rev master HEAD &&
|
2010-08-10 15:17:51 +00:00
|
|
|
rm -f touch-*
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i with the exec command runs from tree root' '
|
|
|
|
git checkout master &&
|
2010-09-06 18:41:06 +00:00
|
|
|
mkdir subdir && (cd subdir &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-08-10 15:17:51 +00:00
|
|
|
FAKE_LINES="1 exec_>touch-subdir" \
|
2010-09-06 18:41:06 +00:00
|
|
|
git rebase -i HEAD^
|
|
|
|
) &&
|
2010-08-10 15:17:52 +00:00
|
|
|
test_path_is_file touch-subdir &&
|
2010-08-10 15:17:51 +00:00
|
|
|
rm -fr subdir
|
|
|
|
'
|
|
|
|
|
2017-10-31 23:07:33 +00:00
|
|
|
test_expect_success 'rebase -i with exec allows git commands in subdirs' '
|
|
|
|
test_when_finished "rm -rf subdir" &&
|
|
|
|
test_when_finished "git rebase --abort ||:" &&
|
|
|
|
git checkout master &&
|
|
|
|
mkdir subdir && (cd subdir &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="1 exec_cd_subdir_&&_git_rev-parse_--is-inside-work-tree" \
|
|
|
|
git rebase -i HEAD^
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2018-07-14 18:38:59 +00:00
|
|
|
test_expect_success 'rebase -i sets work tree properly' '
|
|
|
|
test_when_finished "rm -rf subdir" &&
|
|
|
|
test_when_finished "test_might_fail git rebase --abort" &&
|
|
|
|
mkdir subdir &&
|
|
|
|
git rebase -x "(cd subdir && git rev-parse --show-toplevel)" HEAD^ \
|
|
|
|
>actual &&
|
|
|
|
! grep "/subdir$" actual
|
|
|
|
'
|
|
|
|
|
2010-08-10 15:17:51 +00:00
|
|
|
test_expect_success 'rebase -i with the exec command checks tree cleanness' '
|
|
|
|
git checkout master &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="exec_echo_foo_>file1 1" git rebase -i HEAD^ &&
|
2010-10-31 07:40:30 +00:00
|
|
|
test_cmp_rev master^ HEAD &&
|
2010-08-10 15:17:51 +00:00
|
|
|
git reset --hard &&
|
|
|
|
git rebase --continue
|
|
|
|
'
|
|
|
|
|
2012-09-18 11:15:26 +00:00
|
|
|
test_expect_success 'rebase -i with exec of inexistent command' '
|
|
|
|
git checkout master &&
|
|
|
|
test_when_finished "git rebase --abort" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="exec_this-command-does-not-exist 1" \
|
|
|
|
git rebase -i HEAD^ >actual 2>&1 &&
|
2012-09-18 11:15:26 +00:00
|
|
|
! grep "Maybe git-rebase is broken" actual
|
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'no changes are a nop' '
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout branch2 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-06-25 00:11:14 +00:00
|
|
|
git rebase -i F &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
|
2007-06-25 00:11:14 +00:00
|
|
|
test $(git rev-parse I) = $(git rev-parse HEAD)
|
|
|
|
'
|
|
|
|
|
2007-08-01 22:31:03 +00:00
|
|
|
test_expect_success 'test the [branch] option' '
|
|
|
|
git checkout -b dead-end &&
|
|
|
|
git rm file6 &&
|
|
|
|
git commit -m "stop here" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-08-01 22:31:03 +00:00
|
|
|
git rebase -i F branch2 &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
|
|
|
|
test $(git rev-parse I) = $(git rev-parse branch2) &&
|
2007-08-01 22:31:03 +00:00
|
|
|
test $(git rev-parse I) = $(git rev-parse HEAD)
|
|
|
|
'
|
|
|
|
|
2008-06-21 23:55:50 +00:00
|
|
|
test_expect_success 'test --onto <branch>' '
|
|
|
|
git checkout -b test-onto branch2 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-06-21 23:55:50 +00:00
|
|
|
git rebase -i --onto branch1 F &&
|
|
|
|
test "$(git symbolic-ref -q HEAD)" = "refs/heads/test-onto" &&
|
|
|
|
test $(git rev-parse HEAD^) = $(git rev-parse branch1) &&
|
|
|
|
test $(git rev-parse I) = $(git rev-parse branch2)
|
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'rebase on top of a non-conflicting commit' '
|
|
|
|
git checkout branch1 &&
|
|
|
|
git tag original-branch1 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-06-25 00:11:14 +00:00
|
|
|
git rebase -i branch2 &&
|
|
|
|
test file6 = $(git diff --name-only original-branch1) &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
|
|
|
|
test $(git rev-parse I) = $(git rev-parse branch2) &&
|
2007-06-25 00:11:14 +00:00
|
|
|
test $(git rev-parse I) = $(git rev-parse HEAD~2)
|
|
|
|
'
|
|
|
|
|
2007-06-25 17:58:28 +00:00
|
|
|
test_expect_success 'reflog for the branch shows state before rebase' '
|
|
|
|
test $(git rev-parse branch1@{1}) = $(git rev-parse original-branch1)
|
|
|
|
'
|
|
|
|
|
2017-06-19 17:56:03 +00:00
|
|
|
test_expect_success 'reflog for the branch shows correct finish message' '
|
|
|
|
printf "rebase -i (finish): refs/heads/branch1 onto %s\n" \
|
|
|
|
"$(git rev-parse branch2)" >expected &&
|
|
|
|
git log -g --pretty=%gs -1 refs/heads/branch1 >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'exchange two commits' '
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-06-25 00:11:14 +00:00
|
|
|
FAKE_LINES="2 1" git rebase -i HEAD~2 &&
|
2008-03-12 21:34:34 +00:00
|
|
|
test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
|
|
|
|
test G = $(git cat-file commit HEAD | sed -ne \$p)
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
cat > expect << EOF
|
|
|
|
diff --git a/file1 b/file1
|
2009-12-07 04:22:58 +00:00
|
|
|
index f70f10e..fd79235 100644
|
2007-06-25 00:11:14 +00:00
|
|
|
--- a/file1
|
|
|
|
+++ b/file1
|
2009-12-07 04:22:58 +00:00
|
|
|
@@ -1 +1 @@
|
|
|
|
-A
|
|
|
|
+G
|
2007-06-25 00:11:14 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
cat > expect2 << EOF
|
2009-07-01 20:18:04 +00:00
|
|
|
<<<<<<< HEAD
|
2009-12-07 04:22:58 +00:00
|
|
|
D
|
2007-06-25 00:11:14 +00:00
|
|
|
=======
|
2009-12-07 04:22:58 +00:00
|
|
|
G
|
2010-03-24 20:34:04 +00:00
|
|
|
>>>>>>> 5d18e54... G
|
2007-06-25 00:11:14 +00:00
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'stop on conflicting pick' '
|
|
|
|
git tag new-branch1 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase -i master &&
|
|
|
|
test "$(git rev-parse HEAD~3)" = "$(git rev-parse master)" &&
|
2008-07-16 01:33:44 +00:00
|
|
|
test_cmp expect .git/rebase-merge/patch &&
|
2008-03-12 21:36:36 +00:00
|
|
|
test_cmp expect2 file1 &&
|
2008-09-03 08:59:27 +00:00
|
|
|
test "$(git diff --name-status |
|
2008-06-21 23:55:50 +00:00
|
|
|
sed -n -e "/^U/s/^U[^a-z]*//p")" = file1 &&
|
2008-07-16 01:33:44 +00:00
|
|
|
test 4 = $(grep -v "^#" < .git/rebase-merge/done | wc -l) &&
|
|
|
|
test 0 = $(grep -c "^[^#]" < .git/rebase-merge/git-rebase-todo)
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
|
2018-02-11 09:43:27 +00:00
|
|
|
test_expect_success 'show conflicted patch' '
|
|
|
|
GIT_TRACE=1 git rebase --show-current-patch >/dev/null 2>stderr &&
|
2018-02-11 09:43:28 +00:00
|
|
|
grep "show.*REBASE_HEAD" stderr &&
|
|
|
|
# the original stopped-sha1 is abbreviated
|
|
|
|
stopped_sha1="$(git rev-parse $(cat ".git/rebase-merge/stopped-sha"))" &&
|
|
|
|
test "$(git rev-parse REBASE_HEAD)" = "$stopped_sha1"
|
2018-02-11 09:43:27 +00:00
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'abort' '
|
|
|
|
git rebase --abort &&
|
|
|
|
test $(git rev-parse new-branch1) = $(git rev-parse HEAD) &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
|
2010-08-10 15:17:52 +00:00
|
|
|
test_path_is_missing .git/rebase-merge
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
|
2010-06-08 08:16:11 +00:00
|
|
|
test_expect_success 'abort with error when new base cannot be checked out' '
|
|
|
|
git rm --cached file1 &&
|
|
|
|
git commit -m "remove file in base" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-06-08 08:16:11 +00:00
|
|
|
test_must_fail git rebase -i master > output 2>&1 &&
|
2016-06-17 20:21:08 +00:00
|
|
|
test_i18ngrep "The following untracked working tree files would be overwritten by checkout:" \
|
2010-06-08 08:16:11 +00:00
|
|
|
output &&
|
2016-06-17 20:21:08 +00:00
|
|
|
test_i18ngrep "file1" output &&
|
2010-08-10 15:17:52 +00:00
|
|
|
test_path_is_missing .git/rebase-merge &&
|
2010-06-08 08:16:11 +00:00
|
|
|
git reset --hard HEAD^
|
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'retain authorship' '
|
|
|
|
echo A > file7 &&
|
|
|
|
git add file7 &&
|
2007-06-25 17:56:55 +00:00
|
|
|
test_tick &&
|
2007-06-25 00:11:14 +00:00
|
|
|
GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
|
|
|
|
git tag twerp &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-06-25 00:11:14 +00:00
|
|
|
git rebase -i --onto master HEAD^ &&
|
|
|
|
git show HEAD | grep "^Author: Twerp Snog"
|
|
|
|
'
|
|
|
|
|
2017-01-02 15:35:25 +00:00
|
|
|
test_expect_success 'retain authorship w/ conflicts' '
|
2018-07-12 20:07:51 +00:00
|
|
|
oGIT_AUTHOR_NAME=$GIT_AUTHOR_NAME &&
|
|
|
|
test_when_finished "GIT_AUTHOR_NAME=\$oGIT_AUTHOR_NAME" &&
|
|
|
|
|
2017-01-02 15:35:25 +00:00
|
|
|
git reset --hard twerp &&
|
|
|
|
test_commit a conflict a conflict-a &&
|
|
|
|
git reset --hard twerp &&
|
2018-07-12 20:07:51 +00:00
|
|
|
|
|
|
|
GIT_AUTHOR_NAME=AttributeMe &&
|
|
|
|
export GIT_AUTHOR_NAME &&
|
2017-01-02 15:35:25 +00:00
|
|
|
test_commit b conflict b conflict-b &&
|
2018-07-12 20:07:51 +00:00
|
|
|
GIT_AUTHOR_NAME=$oGIT_AUTHOR_NAME &&
|
|
|
|
|
2017-01-02 15:35:25 +00:00
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail git rebase -i conflict-a &&
|
|
|
|
echo resolved >conflict &&
|
|
|
|
git add conflict &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git rev-parse conflict-a^0) = $(git rev-parse HEAD^) &&
|
|
|
|
git show >out &&
|
|
|
|
grep AttributeMe out
|
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_expect_success 'squash' '
|
|
|
|
git reset --hard twerp &&
|
|
|
|
echo B > file7 &&
|
2007-06-25 17:56:55 +00:00
|
|
|
test_tick &&
|
2007-06-25 00:11:14 +00:00
|
|
|
GIT_AUTHOR_NAME="Nitfol" git commit -m "nitfol" file7 &&
|
|
|
|
echo "******************************" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-01-14 05:54:49 +00:00
|
|
|
FAKE_LINES="1 squash 2" EXPECT_HEADER_COUNT=2 \
|
2010-01-14 05:54:48 +00:00
|
|
|
git rebase -i --onto master HEAD~2 &&
|
2007-06-25 00:11:14 +00:00
|
|
|
test B = $(cat file7) &&
|
|
|
|
test $(git rev-parse HEAD^) = $(git rev-parse master)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'retain authorship when squashing' '
|
2007-09-29 23:34:23 +00:00
|
|
|
git show HEAD | grep "^Author: Twerp Snog"
|
2007-06-25 00:11:14 +00:00
|
|
|
'
|
|
|
|
|
2007-12-17 21:01:25 +00:00
|
|
|
test_expect_success '-p handles "no changes" gracefully' '
|
|
|
|
HEAD=$(git rev-parse HEAD) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-12-17 21:01:25 +00:00
|
|
|
git rebase -i -p HEAD^ &&
|
2008-08-13 21:41:23 +00:00
|
|
|
git update-index --refresh &&
|
|
|
|
git diff-files --quiet &&
|
|
|
|
git diff-index --quiet --cached HEAD -- &&
|
2007-12-17 21:01:25 +00:00
|
|
|
test $HEAD = $(git rev-parse HEAD)
|
|
|
|
'
|
|
|
|
|
2010-06-01 01:43:35 +00:00
|
|
|
test_expect_failure 'exchange two commits with -p' '
|
2012-05-19 13:14:16 +00:00
|
|
|
git checkout H &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-06-01 01:43:35 +00:00
|
|
|
FAKE_LINES="2 1" git rebase -i -p HEAD~2 &&
|
|
|
|
test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
|
|
|
|
test G = $(git cat-file commit HEAD | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2007-06-25 17:59:43 +00:00
|
|
|
test_expect_success 'preserve merges with -p' '
|
|
|
|
git checkout -b to-be-preserved master^ &&
|
|
|
|
: > unrelated-file &&
|
|
|
|
git add unrelated-file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "unrelated" &&
|
2008-07-12 15:47:31 +00:00
|
|
|
git checkout -b another-branch master &&
|
2007-06-25 17:59:43 +00:00
|
|
|
echo B > file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m J file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git merge to-be-preserved &&
|
|
|
|
echo C > file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m K file1 &&
|
2008-07-12 15:47:31 +00:00
|
|
|
echo D > file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m L1 file1 &&
|
|
|
|
git checkout HEAD^ &&
|
|
|
|
echo 1 > unrelated-file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m L2 unrelated-file &&
|
|
|
|
test_tick &&
|
|
|
|
git merge another-branch &&
|
|
|
|
echo E > file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m M file1 &&
|
|
|
|
git checkout -b to-be-rebased &&
|
2007-07-08 02:01:29 +00:00
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-06-25 17:59:43 +00:00
|
|
|
git rebase -i -p --onto branch1 master &&
|
2008-08-13 21:41:23 +00:00
|
|
|
git update-index --refresh &&
|
|
|
|
git diff-files --quiet &&
|
|
|
|
git diff-index --quiet --cached HEAD -- &&
|
2008-07-12 15:47:31 +00:00
|
|
|
test $(git rev-parse HEAD~6) = $(git rev-parse branch1) &&
|
|
|
|
test $(git rev-parse HEAD~4^2) = $(git rev-parse to-be-preserved) &&
|
|
|
|
test $(git rev-parse HEAD^^2^) = $(git rev-parse HEAD^^^) &&
|
|
|
|
test $(git show HEAD~5:file1) = B &&
|
|
|
|
test $(git show HEAD~3:file1) = C &&
|
|
|
|
test $(git show HEAD:file1) = E &&
|
|
|
|
test $(git show HEAD:unrelated-file) = 1
|
2007-06-25 17:59:43 +00:00
|
|
|
'
|
|
|
|
|
2008-08-13 21:41:24 +00:00
|
|
|
test_expect_success 'edit ancestor with -p' '
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
rebase -i -p: include non-first-parent commits in todo list
Consider this graph:
D---E (topic, HEAD)
/ /
A---B---C (master)
\
F (topic2)
and the following three commands:
1. git rebase -i -p A
2. git rebase -i -p --onto F A
3. git rebase -i -p B
Currently, (1) and (2) will pick B, D, C, and E onto A and F,
respectively. However, (3) will only pick D and E onto B, but not C,
which is inconsistent with (1) and (2). As a result, we cannot modify C
during the interactive-rebase.
The current behavior also creates a bug if we do:
4. git rebase -i -p C
In (4), E is never picked. And since interactive-rebase resets "HEAD"
to "onto" before picking any commits, D and E are lost after the
interactive-rebase.
This patch fixes the inconsistency and bug by ensuring that all children
of upstream are always picked. This essentially reverts the commit:
d80d6bc146232d81f1bb4bc58e5d89263fd228d4
When compiling the todo list, commits reachable from "upstream" should
never be skipped under any conditions. Otherwise, we lose the ability
to modify them like (3), and create a bug like (4).
Two of the tests contain a scenario like (3). Since the new behavior
added more commits for picking, these tests need to be updated to
account for the additional pick lines. A new test has also been added
for (4).
Signed-off-by: Andrew Wong <andrew.kw.w@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-18 22:12:01 +00:00
|
|
|
FAKE_LINES="1 2 edit 3 4" git rebase -i -p HEAD~3 &&
|
2008-08-13 21:41:24 +00:00
|
|
|
echo 2 > unrelated-file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m L2-modified --amend unrelated-file &&
|
|
|
|
git rebase --continue &&
|
|
|
|
git update-index --refresh &&
|
|
|
|
git diff-files --quiet &&
|
|
|
|
git diff-index --quiet --cached HEAD -- &&
|
|
|
|
test $(git show HEAD:unrelated-file) = 2
|
|
|
|
'
|
|
|
|
|
2007-07-08 02:01:29 +00:00
|
|
|
test_expect_success '--continue tries to commit' '
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase -i --onto new-branch1 HEAD^ &&
|
2007-07-08 02:01:29 +00:00
|
|
|
echo resolved > file1 &&
|
|
|
|
git add file1 &&
|
|
|
|
FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
|
|
|
|
test $(git rev-parse HEAD^) = $(git rev-parse new-branch1) &&
|
|
|
|
git show HEAD | grep chouette
|
|
|
|
'
|
|
|
|
|
2007-07-08 02:02:47 +00:00
|
|
|
test_expect_success 'verbose flag is heeded, even after --continue' '
|
2011-05-27 20:16:14 +00:00
|
|
|
git reset --hard master@{1} &&
|
2007-07-08 02:02:47 +00:00
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase -v -i --onto new-branch1 HEAD^ &&
|
2007-07-08 02:02:47 +00:00
|
|
|
echo resolved > file1 &&
|
|
|
|
git add file1 &&
|
|
|
|
git rebase --continue > output &&
|
2012-04-30 20:38:58 +00:00
|
|
|
grep "^ file1 | 2 +-$" output
|
2007-07-08 02:02:47 +00:00
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'multi-squash only fires up editor once' '
|
2007-07-21 17:09:41 +00:00
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-07-21 17:09:41 +00:00
|
|
|
FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 squash 2 squash 3 squash 4" \
|
2010-01-14 05:54:48 +00:00
|
|
|
EXPECT_HEADER_COUNT=4 \
|
2007-07-21 17:09:41 +00:00
|
|
|
git rebase -i $base &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
|
|
|
test 1 = $(git show | grep ONCE | wc -l)
|
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'multi-fixup does not fire up editor' '
|
2009-12-07 09:20:59 +00:00
|
|
|
git checkout -b multi-fixup E &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-01-14 05:54:55 +00:00
|
|
|
FAKE_COMMIT_AMEND="NEVER" FAKE_LINES="1 fixup 2 fixup 3 fixup 4" \
|
2009-12-07 09:20:59 +00:00
|
|
|
git rebase -i $base &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
2010-01-14 05:54:55 +00:00
|
|
|
test 0 = $(git show | grep NEVER | wc -l) &&
|
2009-12-07 09:20:59 +00:00
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D multi-fixup
|
|
|
|
'
|
|
|
|
|
2010-01-14 05:54:57 +00:00
|
|
|
test_expect_success 'commit message used after conflict' '
|
|
|
|
git checkout -b conflict-fixup conflict-branch &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="1 fixup 3 fixup 4" git rebase -i $base &&
|
2010-01-14 05:54:57 +00:00
|
|
|
echo three > conflict &&
|
|
|
|
git add conflict &&
|
|
|
|
FAKE_COMMIT_AMEND="ONCE" EXPECT_HEADER_COUNT=2 \
|
|
|
|
git rebase --continue &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
|
|
|
test 1 = $(git show | grep ONCE | wc -l) &&
|
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D conflict-fixup
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'commit message retained after conflict' '
|
|
|
|
git checkout -b conflict-squash conflict-branch &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="1 fixup 3 squash 4" git rebase -i $base &&
|
2010-01-14 05:54:57 +00:00
|
|
|
echo three > conflict &&
|
|
|
|
git add conflict &&
|
|
|
|
FAKE_COMMIT_AMEND="TWICE" EXPECT_HEADER_COUNT=2 \
|
|
|
|
git rebase --continue &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
|
|
|
test 2 = $(git show | grep TWICE | wc -l) &&
|
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D conflict-squash
|
|
|
|
'
|
|
|
|
|
2009-12-07 09:20:59 +00:00
|
|
|
cat > expect-squash-fixup << EOF
|
|
|
|
B
|
|
|
|
|
|
|
|
D
|
|
|
|
|
|
|
|
ONCE
|
|
|
|
EOF
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'squash and fixup generate correct log messages' '
|
2009-12-07 09:20:59 +00:00
|
|
|
git checkout -b squash-fixup E &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-12-07 09:20:59 +00:00
|
|
|
FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 fixup 2 squash 3 fixup 4" \
|
2010-01-14 05:54:48 +00:00
|
|
|
EXPECT_HEADER_COUNT=4 \
|
2009-12-07 09:20:59 +00:00
|
|
|
git rebase -i $base &&
|
|
|
|
git cat-file commit HEAD | sed -e 1,/^\$/d > actual-squash-fixup &&
|
|
|
|
test_cmp expect-squash-fixup actual-squash-fixup &&
|
2017-11-10 11:09:41 +00:00
|
|
|
git cat-file commit HEAD@{2} |
|
|
|
|
grep "^# This is a combination of 3 commits\." &&
|
|
|
|
git cat-file commit HEAD@{3} |
|
|
|
|
grep "^# This is a combination of 2 commits\." &&
|
2009-12-07 09:20:59 +00:00
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D squash-fixup
|
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'squash ignores comments' '
|
2010-01-12 15:38:36 +00:00
|
|
|
git checkout -b skip-comments E &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-01-12 15:38:36 +00:00
|
|
|
FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="# 1 # squash 2 # squash 3 # squash 4 #" \
|
|
|
|
EXPECT_HEADER_COUNT=4 \
|
|
|
|
git rebase -i $base &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
|
|
|
test 1 = $(git show | grep ONCE | wc -l) &&
|
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D skip-comments
|
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'squash ignores blank lines' '
|
2010-01-12 15:38:36 +00:00
|
|
|
git checkout -b skip-blank-lines E &&
|
|
|
|
base=$(git rev-parse HEAD~4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-01-12 15:38:36 +00:00
|
|
|
FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="> 1 > squash 2 > squash 3 > squash 4 >" \
|
|
|
|
EXPECT_HEADER_COUNT=4 \
|
|
|
|
git rebase -i $base &&
|
|
|
|
test $base = $(git rev-parse HEAD^) &&
|
|
|
|
test 1 = $(git show | grep ONCE | wc -l) &&
|
|
|
|
git checkout to-be-rebased &&
|
|
|
|
git branch -D skip-blank-lines
|
|
|
|
'
|
|
|
|
|
2007-07-24 20:43:09 +00:00
|
|
|
test_expect_success 'squash works as expected' '
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout -b squash-works no-conflict-branch &&
|
2007-07-24 20:43:09 +00:00
|
|
|
one=$(git rev-parse HEAD~3) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-01-14 05:54:49 +00:00
|
|
|
FAKE_LINES="1 squash 3 2" EXPECT_HEADER_COUNT=2 \
|
2010-01-14 05:54:48 +00:00
|
|
|
git rebase -i HEAD~3 &&
|
2007-07-24 20:43:09 +00:00
|
|
|
test $one = $(git rev-parse HEAD~2)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'interrupted squash works as expected' '
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout -b interrupted-squash conflict-branch &&
|
2007-07-24 20:43:09 +00:00
|
|
|
one=$(git rev-parse HEAD~3) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="1 squash 3 2" git rebase -i HEAD~3 &&
|
2018-07-02 00:23:42 +00:00
|
|
|
test_write_lines one two four > conflict &&
|
2007-07-24 20:43:09 +00:00
|
|
|
git add conflict &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase --continue &&
|
2007-07-24 20:43:09 +00:00
|
|
|
echo resolved > conflict &&
|
|
|
|
git add conflict &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $one = $(git rev-parse HEAD~2)
|
|
|
|
'
|
|
|
|
|
2007-08-23 08:55:41 +00:00
|
|
|
test_expect_success 'interrupted squash works as expected (case 2)' '
|
2010-01-14 05:54:56 +00:00
|
|
|
git checkout -b interrupted-squash2 conflict-branch &&
|
2007-08-23 08:55:41 +00:00
|
|
|
one=$(git rev-parse HEAD~3) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="3 squash 1 2" git rebase -i HEAD~3 &&
|
2018-07-02 00:23:42 +00:00
|
|
|
test_write_lines one four > conflict &&
|
2007-08-23 08:55:41 +00:00
|
|
|
git add conflict &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase --continue &&
|
2018-07-02 00:23:42 +00:00
|
|
|
test_write_lines one two four > conflict &&
|
2007-08-23 08:55:41 +00:00
|
|
|
git add conflict &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git rebase --continue &&
|
2007-08-23 08:55:41 +00:00
|
|
|
echo resolved > conflict &&
|
|
|
|
git add conflict &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $one = $(git rev-parse HEAD~2)
|
|
|
|
'
|
|
|
|
|
2013-06-07 06:11:41 +00:00
|
|
|
test_expect_success '--continue tries to commit, even for "edit"' '
|
2007-08-01 14:59:35 +00:00
|
|
|
echo unrelated > file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "unrelated change" &&
|
2007-09-25 15:42:36 +00:00
|
|
|
parent=$(git rev-parse HEAD^) &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-09-25 15:42:36 +00:00
|
|
|
FAKE_LINES="edit 1" git rebase -i HEAD^ &&
|
|
|
|
echo edited > file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
|
|
|
|
test edited = $(git show HEAD:file7) &&
|
|
|
|
git show HEAD | grep chouette &&
|
|
|
|
test $parent = $(git rev-parse HEAD^)
|
|
|
|
'
|
|
|
|
|
2009-01-15 12:56:15 +00:00
|
|
|
test_expect_success 'aborted --continue does not squash commits after "edit"' '
|
|
|
|
old=$(git rev-parse HEAD) &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-01-15 12:56:15 +00:00
|
|
|
FAKE_LINES="edit 1" git rebase -i HEAD^ &&
|
|
|
|
echo "edited again" > file7 &&
|
|
|
|
git add file7 &&
|
sequencer: fix --allow-empty-message behavior, make it smarter
In commit b00bf1c9a8dd ("git-rebase: make --allow-empty-message the
default", 2018-06-27), several arguments were given for transplanting
empty commits without halting and asking the user for confirmation on
each commit. These arguments were incomplete because the logic clearly
assumed the only cases under consideration were transplanting of commits
with empty messages (see the comment about "There are two sources for
commits with empty messages). It didn't discuss or even consider
rewords, squashes, etc. where the user is explicitly asked for a new
commit message and provides an empty one. (My bad, I totally should
have thought about that at the time, but just didn't.)
Rewords and squashes are significantly different, though, as described
by SZEDER:
Let's suppose you start an interactive rebase, choose a commit to
squash, save the instruction sheet, rebase fires up your editor, and
then you notice that you mistakenly chose the wrong commit to
squash. What do you do, how do you abort?
Before [that commit] you could clear the commit message, exit the
editor, and then rebase would say "Aborting commit due to empty
commit message.", and you get to run 'git rebase --abort', and start
over.
But [since that commit, ...] saving the commit message as is would
let rebase continue and create a bunch of unnecessary objects, and
then you would have to use the reflog to return to the pre-rebase
state.
Also, he states:
The instructions in the commit message template, which is shown for
'reword' and 'squash', too, still say...
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
These are sound arguments that when editing commit messages during a
sequencer operation, that if the commit message is empty then the
operation should halt and ask the user to correct. The arguments in
commit b00bf1c9a8dd (referenced above) still apply when transplanting
previously created commits with empty commit messages, so the sequencer
should not halt for those.
Furthermore, all rationale so far applies equally for cherry-pick as for
rebase. Therefore, make the code default to --allow-empty-message when
transplanting an existing commit, and to default to halting when the
user is asked to edit a commit message and provides an empty one -- for
both rebase and cherry-pick.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-09-12 21:18:48 +00:00
|
|
|
test_must_fail env FAKE_COMMIT_MESSAGE=" " git rebase --continue &&
|
|
|
|
test $old = $(git rev-parse HEAD) &&
|
|
|
|
git rebase --abort
|
2009-01-15 12:56:15 +00:00
|
|
|
'
|
|
|
|
|
2009-01-15 12:56:16 +00:00
|
|
|
test_expect_success 'auto-amend only edited commits after "edit"' '
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-01-15 12:56:16 +00:00
|
|
|
FAKE_LINES="edit 1" git rebase -i HEAD^ &&
|
|
|
|
echo "edited again" > file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
FAKE_COMMIT_MESSAGE="edited file7 again" git commit &&
|
|
|
|
echo "and again" > file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
test_tick &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_COMMIT_MESSAGE="and again" git rebase --continue &&
|
2009-01-15 12:56:16 +00:00
|
|
|
git rebase --abort
|
|
|
|
'
|
|
|
|
|
2011-08-24 14:01:48 +00:00
|
|
|
test_expect_success 'clean error after failed "exec"' '
|
|
|
|
test_tick &&
|
|
|
|
test_when_finished "git rebase --abort || :" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env FAKE_LINES="1 exec_false" git rebase -i HEAD^ &&
|
2011-08-24 14:01:48 +00:00
|
|
|
echo "edited again" > file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
test_must_fail git rebase --continue 2>error &&
|
2017-02-09 22:23:11 +00:00
|
|
|
test_i18ngrep "you have staged changes in your working tree" error
|
2011-08-24 14:01:48 +00:00
|
|
|
'
|
|
|
|
|
2007-09-25 15:43:15 +00:00
|
|
|
test_expect_success 'rebase a detached HEAD' '
|
|
|
|
grandparent=$(git rev-parse HEAD~2) &&
|
|
|
|
git checkout $(git rev-parse HEAD) &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2007-09-25 15:43:15 +00:00
|
|
|
FAKE_LINES="2 1" git rebase -i HEAD~2 &&
|
|
|
|
test $grandparent = $(git rev-parse HEAD~2)
|
|
|
|
'
|
|
|
|
|
2008-01-28 16:33:28 +00:00
|
|
|
test_expect_success 'rebase a commit violating pre-commit' '
|
|
|
|
|
|
|
|
mkdir -p .git/hooks &&
|
2016-04-12 16:59:59 +00:00
|
|
|
write_script .git/hooks/pre-commit <<-\EOF &&
|
|
|
|
test -z "$(git diff --cached --check)"
|
|
|
|
EOF
|
2008-01-28 16:33:28 +00:00
|
|
|
echo "monde! " >> file1 &&
|
|
|
|
test_tick &&
|
2008-06-21 23:55:50 +00:00
|
|
|
test_must_fail git commit -m doesnt-verify file1 &&
|
2008-01-28 16:33:28 +00:00
|
|
|
git commit -m doesnt-verify --no-verify file1 &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-01-28 16:33:28 +00:00
|
|
|
FAKE_LINES=2 git rebase -i HEAD~2
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2008-02-13 21:13:21 +00:00
|
|
|
test_expect_success 'rebase with a file named HEAD in worktree' '
|
|
|
|
|
|
|
|
rm -fr .git/hooks &&
|
|
|
|
git reset --hard &&
|
|
|
|
git checkout -b branch3 A &&
|
|
|
|
|
|
|
|
(
|
|
|
|
GIT_AUTHOR_NAME="Squashed Away" &&
|
|
|
|
export GIT_AUTHOR_NAME &&
|
|
|
|
>HEAD &&
|
|
|
|
git add HEAD &&
|
|
|
|
git commit -m "Add head" &&
|
|
|
|
>BODY &&
|
|
|
|
git add BODY &&
|
|
|
|
git commit -m "Add body"
|
|
|
|
) &&
|
|
|
|
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-02-13 21:13:21 +00:00
|
|
|
FAKE_LINES="1 squash 2" git rebase -i to-be-rebased &&
|
|
|
|
test "$(git show -s --pretty=format:%an)" = "Squashed Away"
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2008-10-10 11:42:12 +00:00
|
|
|
test_expect_success 'do "noop" when there is nothing to cherry-pick' '
|
|
|
|
|
|
|
|
git checkout -b branch4 HEAD &&
|
|
|
|
GIT_EDITOR=: git commit --amend \
|
2010-10-31 07:30:58 +00:00
|
|
|
--author="Somebody else <somebody@else.com>" &&
|
2008-10-10 11:42:12 +00:00
|
|
|
test $(git rev-parse branch3) != $(git rev-parse branch4) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2008-10-10 11:42:12 +00:00
|
|
|
git rebase -i branch3 &&
|
|
|
|
test $(git rev-parse branch3) = $(git rev-parse branch4)
|
|
|
|
|
|
|
|
'
|
|
|
|
|
2009-01-27 09:07:31 +00:00
|
|
|
test_expect_success 'submodule rebase setup' '
|
|
|
|
git checkout A &&
|
|
|
|
mkdir sub &&
|
|
|
|
(
|
|
|
|
cd sub && git init && >elif &&
|
|
|
|
git add elif && git commit -m "submodule initial"
|
|
|
|
) &&
|
|
|
|
echo 1 >file1 &&
|
2010-10-31 07:30:58 +00:00
|
|
|
git add file1 sub &&
|
2009-01-27 09:07:31 +00:00
|
|
|
test_tick &&
|
|
|
|
git commit -m "One" &&
|
|
|
|
echo 2 >file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "Two" &&
|
|
|
|
(
|
|
|
|
cd sub && echo 3 >elif &&
|
|
|
|
git commit -a -m "submodule second"
|
|
|
|
) &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-01-27 09:07:31 +00:00
|
|
|
git commit -a -m "Three changes submodule"
|
|
|
|
'
|
|
|
|
|
2009-01-27 11:42:31 +00:00
|
|
|
test_expect_success 'submodule rebase -i' '
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-01-27 09:07:31 +00:00
|
|
|
FAKE_LINES="1 squash 2 3" git rebase -i A
|
|
|
|
'
|
|
|
|
|
2012-04-07 10:20:53 +00:00
|
|
|
test_expect_success 'submodule conflict setup' '
|
|
|
|
git tag submodule-base &&
|
|
|
|
git checkout HEAD^ &&
|
|
|
|
(
|
|
|
|
cd sub && git checkout HEAD^ && echo 4 >elif &&
|
|
|
|
git add elif && git commit -m "submodule conflict"
|
|
|
|
) &&
|
|
|
|
git add sub &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m "Conflict in submodule" &&
|
|
|
|
git tag submodule-topic
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i continue with only submodule staged' '
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-04-07 10:20:53 +00:00
|
|
|
test_must_fail git rebase -i submodule-base &&
|
|
|
|
git add sub &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git rev-parse submodule-base) != $(git rev-parse HEAD)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i continue with unstaged submodule' '
|
|
|
|
git checkout submodule-topic &&
|
|
|
|
git reset --hard &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-04-07 10:20:53 +00:00
|
|
|
test_must_fail git rebase -i submodule-base &&
|
|
|
|
git reset &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git rev-parse submodule-base) = $(git rev-parse HEAD)
|
|
|
|
'
|
|
|
|
|
2009-03-03 09:55:31 +00:00
|
|
|
test_expect_success 'avoid unnecessary reset' '
|
|
|
|
git checkout master &&
|
2012-04-07 10:20:53 +00:00
|
|
|
git reset --hard &&
|
2018-03-24 07:44:31 +00:00
|
|
|
test-tool chmtime =123456789 file3 &&
|
2009-03-03 09:55:31 +00:00
|
|
|
git update-index --refresh &&
|
|
|
|
HEAD=$(git rev-parse HEAD) &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-03-03 09:55:31 +00:00
|
|
|
git rebase -i HEAD~4 &&
|
|
|
|
test $HEAD = $(git rev-parse HEAD) &&
|
2018-04-25 04:29:00 +00:00
|
|
|
MTIME=$(test-tool chmtime --get file3) &&
|
2009-03-03 09:55:31 +00:00
|
|
|
test 123456789 = $MTIME
|
|
|
|
'
|
|
|
|
|
2009-10-07 06:13:23 +00:00
|
|
|
test_expect_success 'reword' '
|
|
|
|
git checkout -b reword-branch master &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2009-10-07 06:13:23 +00:00
|
|
|
FAKE_LINES="1 2 3 reword 4" FAKE_COMMIT_MESSAGE="E changed" git rebase -i A &&
|
|
|
|
git show HEAD | grep "E changed" &&
|
|
|
|
test $(git rev-parse master) != $(git rev-parse HEAD) &&
|
|
|
|
test $(git rev-parse master^) = $(git rev-parse HEAD^) &&
|
|
|
|
FAKE_LINES="1 2 reword 3 4" FAKE_COMMIT_MESSAGE="D changed" git rebase -i A &&
|
|
|
|
git show HEAD^ | grep "D changed" &&
|
|
|
|
FAKE_LINES="reword 1 2 3 4" FAKE_COMMIT_MESSAGE="B changed" git rebase -i A &&
|
|
|
|
git show HEAD~3 | grep "B changed" &&
|
|
|
|
FAKE_LINES="1 reword 2 3 4" FAKE_COMMIT_MESSAGE="C changed" git rebase -i A &&
|
|
|
|
git show HEAD~2 | grep "C changed"
|
|
|
|
'
|
|
|
|
|
2010-03-12 17:04:33 +00:00
|
|
|
test_expect_success 'rebase -i can copy notes' '
|
|
|
|
git config notes.rewrite.rebase true &&
|
|
|
|
git config notes.rewriteRef "refs/notes/*" &&
|
|
|
|
test_commit n1 &&
|
|
|
|
test_commit n2 &&
|
|
|
|
test_commit n3 &&
|
|
|
|
git notes add -m"a note" n3 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2013-05-28 12:54:31 +00:00
|
|
|
git rebase -i --onto n1 n2 &&
|
2010-03-12 17:04:33 +00:00
|
|
|
test "a note" = "$(git notes show HEAD)"
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expect <<EOF
|
|
|
|
an earlier note
|
2010-11-09 21:49:44 +00:00
|
|
|
|
2010-03-12 17:04:33 +00:00
|
|
|
a note
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i can copy notes over a fixup' '
|
|
|
|
git reset --hard n3 &&
|
|
|
|
git notes add -m"an earlier note" n2 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-03-12 17:04:33 +00:00
|
|
|
GIT_NOTES_REWRITE_MODE=concatenate FAKE_LINES="1 fixup 2" git rebase -i n1 &&
|
|
|
|
git notes show > output &&
|
|
|
|
test_cmp expect output
|
|
|
|
'
|
|
|
|
|
2010-03-15 04:48:22 +00:00
|
|
|
test_expect_success 'rebase while detaching HEAD' '
|
|
|
|
git symbolic-ref HEAD &&
|
|
|
|
grandparent=$(git rev-parse HEAD~2) &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-03-15 04:48:22 +00:00
|
|
|
FAKE_LINES="2 1" git rebase -i HEAD~2 HEAD^0 &&
|
|
|
|
test $grandparent = $(git rev-parse HEAD~2) &&
|
|
|
|
test_must_fail git symbolic-ref HEAD
|
|
|
|
'
|
|
|
|
|
2010-03-24 20:34:04 +00:00
|
|
|
test_tick # Ensure that the rebased commits get a different timestamp.
|
|
|
|
test_expect_success 'always cherry-pick with --no-ff' '
|
|
|
|
git checkout no-ff-branch &&
|
|
|
|
git tag original-no-ff-branch &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-03-24 20:34:04 +00:00
|
|
|
git rebase -i --no-ff A &&
|
|
|
|
for p in 0 1 2
|
|
|
|
do
|
|
|
|
test ! $(git rev-parse HEAD~$p) = $(git rev-parse original-no-ff-branch~$p) &&
|
|
|
|
git diff HEAD~$p original-no-ff-branch~$p > out &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty out
|
2010-03-24 20:34:04 +00:00
|
|
|
done &&
|
|
|
|
test $(git rev-parse HEAD~3) = $(git rev-parse original-no-ff-branch~3) &&
|
|
|
|
git diff HEAD~3 original-no-ff-branch~3 > out &&
|
tests: use 'test_must_be_empty' instead of 'test_cmp <empty> <out>'
Using 'test_must_be_empty' is shorter and more idiomatic than
>empty &&
test_cmp empty out
as it saves the creation of an empty file. Furthermore, sometimes the
expected empty file doesn't have such a descriptive name like 'empty',
and its creation is far away from the place where it's finally used
for comparison (e.g. in 't7600-merge.sh', where two expected empty
files are created in the 'setup' test, but are used only about 500
lines later).
These cases were found by instrumenting 'test_cmp' to error out the
test script when it's used to compare empty files, and then converted
manually.
Note that even after this patch there still remain a lot of cases
where we use 'test_cmp' to check empty files:
- Sometimes the expected output is not hard-coded in the test, but
'test_cmp' is used to ensure that two similar git commands produce
the same output, and that output happens to be empty, e.g. the
test 'submodule update --merge - ignores --merge for new
submodules' in 't7406-submodule-update.sh'.
- Repetitive common tasks, including preparing the expected results
and running 'test_cmp', are often extracted into a helper
function, and some of this helper's callsites expect no output.
- For the same reason as above, the whole 'test_expect_success'
block is within a helper function, e.g. in 't3070-wildmatch.sh'.
- Or 'test_cmp' is invoked in a loop, e.g. the test 'cvs update
(-p)' in 't9400-git-cvsserver-server.sh'.
Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-19 21:57:25 +00:00
|
|
|
test_must_be_empty out
|
2010-03-24 20:34:04 +00:00
|
|
|
'
|
|
|
|
|
2010-07-06 06:08:36 +00:00
|
|
|
test_expect_success 'set up commits with funny messages' '
|
|
|
|
git checkout -b funny A &&
|
|
|
|
echo >>file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "end with slash\\" &&
|
|
|
|
echo >>file1 &&
|
|
|
|
test_tick &&
|
2010-07-22 19:15:11 +00:00
|
|
|
git commit -a -m "something (\000) that looks like octal" &&
|
|
|
|
echo >>file1 &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -a -m "something (\n) that looks like a newline" &&
|
|
|
|
echo >>file1 &&
|
|
|
|
test_tick &&
|
2010-07-06 06:08:36 +00:00
|
|
|
git commit -a -m "another commit"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase-i history with funny messages' '
|
|
|
|
git rev-list A..funny >expect &&
|
|
|
|
test_tick &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2010-07-22 19:15:11 +00:00
|
|
|
FAKE_LINES="1 2 3 4" git rebase -i A &&
|
2010-07-06 06:08:36 +00:00
|
|
|
git rev-list A.. >actual &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2012-06-12 08:05:12 +00:00
|
|
|
test_expect_success 'prepare for rebase -i --exec' '
|
|
|
|
git checkout master &&
|
|
|
|
git checkout -b execute &&
|
|
|
|
test_commit one_exec main.txt one_exec &&
|
|
|
|
test_commit two_exec main.txt two_exec &&
|
|
|
|
test_commit three_exec main.txt three_exec
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'running "git rebase -i --exec git show HEAD"' '
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git rebase -i --exec "git show HEAD" HEAD~2 >actual &&
|
|
|
|
(
|
|
|
|
FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~2 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,9d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'running "git rebase --exec git show HEAD -i"' '
|
|
|
|
git reset --hard execute &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git rebase --exec "git show HEAD" -i HEAD~2 >actual &&
|
|
|
|
(
|
|
|
|
FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~2 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,9d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'running "git rebase -ix git show HEAD"' '
|
|
|
|
git reset --hard execute &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git rebase -ix "git show HEAD" HEAD~2 >actual &&
|
|
|
|
(
|
|
|
|
FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~2 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,9d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
|
|
|
|
test_expect_success 'rebase -ix with several <CMD>' '
|
|
|
|
git reset --hard execute &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git rebase -ix "git show HEAD; pwd" HEAD~2 >actual &&
|
|
|
|
(
|
|
|
|
FAKE_LINES="1 exec_git_show_HEAD;_pwd 2 exec_git_show_HEAD;_pwd" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~2 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,9d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -ix with several instances of --exec' '
|
|
|
|
git reset --hard execute &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git rebase -i --exec "git show HEAD" --exec "pwd" HEAD~2 >actual &&
|
|
|
|
(
|
|
|
|
FAKE_LINES="1 exec_git_show_HEAD exec_pwd 2
|
|
|
|
exec_git_show_HEAD exec_pwd" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~2 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,11d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'rebase -ix with --autosquash' '
|
2012-06-12 08:05:12 +00:00
|
|
|
git reset --hard execute &&
|
|
|
|
git checkout -b autosquash &&
|
|
|
|
echo second >second.txt &&
|
|
|
|
git add second.txt &&
|
|
|
|
git commit -m "fixup! two_exec" &&
|
|
|
|
echo bis >bis.txt &&
|
|
|
|
git add bis.txt &&
|
|
|
|
git commit -m "fixup! two_exec" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-12 08:05:12 +00:00
|
|
|
(
|
|
|
|
git checkout -b autosquash_actual &&
|
|
|
|
git rebase -i --exec "git show HEAD" --autosquash HEAD~4 >actual
|
|
|
|
) &&
|
|
|
|
git checkout autosquash &&
|
|
|
|
(
|
|
|
|
git checkout -b autosquash_expected &&
|
|
|
|
FAKE_LINES="1 fixup 3 fixup 4 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
|
|
|
|
export FAKE_LINES &&
|
|
|
|
git rebase -i HEAD~4 >expect
|
|
|
|
) &&
|
|
|
|
sed -e "1,13d" expect >expected &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2016-03-18 21:26:17 +00:00
|
|
|
test_expect_success 'rebase --exec works without -i ' '
|
2012-06-12 08:05:12 +00:00
|
|
|
git reset --hard execute &&
|
2016-03-18 21:26:17 +00:00
|
|
|
rm -rf exec_output &&
|
|
|
|
EDITOR="echo >invoked_editor" git rebase --exec "echo a line >>exec_output" HEAD~2 2>actual &&
|
|
|
|
test_i18ngrep "Successfully rebased and updated" actual &&
|
|
|
|
test_line_count = 2 exec_output &&
|
|
|
|
test_path_is_missing invoked_editor
|
2012-06-12 08:05:12 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i --exec without <CMD>' '
|
|
|
|
git reset --hard execute &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2018-03-22 18:43:51 +00:00
|
|
|
test_must_fail git rebase -i --exec 2>actual &&
|
|
|
|
test_i18ngrep "requires a value" actual &&
|
2012-06-12 08:05:12 +00:00
|
|
|
git checkout master
|
|
|
|
'
|
|
|
|
|
2012-06-26 21:55:24 +00:00
|
|
|
test_expect_success 'rebase -i --root re-order and drop commits' '
|
|
|
|
git checkout E &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-26 21:55:24 +00:00
|
|
|
FAKE_LINES="3 1 2 5" git rebase -i --root &&
|
|
|
|
test E = $(git cat-file commit HEAD | sed -ne \$p) &&
|
|
|
|
test B = $(git cat-file commit HEAD^ | sed -ne \$p) &&
|
|
|
|
test A = $(git cat-file commit HEAD^^ | sed -ne \$p) &&
|
|
|
|
test C = $(git cat-file commit HEAD^^^ | sed -ne \$p) &&
|
|
|
|
test 0 = $(git cat-file commit HEAD^^^ | grep -c ^parent\ )
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i --root retain root commit author and message' '
|
|
|
|
git checkout A &&
|
|
|
|
echo B >file7 &&
|
|
|
|
git add file7 &&
|
|
|
|
GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-06-26 21:55:24 +00:00
|
|
|
FAKE_LINES="2" git rebase -i --root &&
|
|
|
|
git cat-file commit HEAD | grep -q "^author Twerp Snog" &&
|
|
|
|
git cat-file commit HEAD | grep -q "^different author$"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i --root temporary sentinel commit' '
|
|
|
|
git checkout B &&
|
2014-03-18 18:54:05 +00:00
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="2" git rebase -i --root &&
|
2012-06-26 21:55:24 +00:00
|
|
|
git cat-file commit HEAD | grep "^tree 4b825dc642cb" &&
|
|
|
|
git rebase --abort
|
|
|
|
'
|
|
|
|
|
2012-07-24 12:17:03 +00:00
|
|
|
test_expect_success 'rebase -i --root fixup root commit' '
|
|
|
|
git checkout B &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-07-24 12:17:03 +00:00
|
|
|
FAKE_LINES="1 fixup 2" git rebase -i --root &&
|
|
|
|
test A = $(git cat-file commit HEAD | sed -ne \$p) &&
|
|
|
|
test B = $(git show HEAD:file1) &&
|
|
|
|
test 0 = $(git cat-file commit HEAD | grep -c ^parent\ )
|
|
|
|
'
|
|
|
|
|
2018-06-16 19:00:38 +00:00
|
|
|
test_expect_success 'rebase -i --root reword root commit' '
|
2018-06-15 04:31:11 +00:00
|
|
|
test_when_finished "test_might_fail git rebase --abort" &&
|
|
|
|
git checkout -b reword-root-branch master &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="reword 1 2" FAKE_COMMIT_MESSAGE="A changed" \
|
|
|
|
git rebase -i --root &&
|
2018-06-18 22:19:42 +00:00
|
|
|
git show HEAD^ | grep "A changed" &&
|
|
|
|
test -z "$(git show -s --format=%p HEAD^)"
|
2018-06-15 04:31:11 +00:00
|
|
|
'
|
|
|
|
|
sequencer: do not squash 'reword' commits when we hit conflicts
Ever since commit 18633e1a22 ("rebase -i: use the rebase--helper builtin",
2017-02-09), when a commit marked as 'reword' in an interactive rebase
has conflicts and fails to apply, when the rebase is resumed that commit
will be squashed into its parent with its commit message taken.
The issue can be understood better by looking at commit 56dc3ab04b
("sequencer (rebase -i): implement the 'edit' command", 2017-01-02), which
introduced error_with_patch() for the edit command. For the edit command,
it needs to stop the rebase whether or not the patch applies cleanly. If
the patch does apply cleanly, then when it resumes it knows it needs to
amend all changes into the previous commit. If it does not apply cleanly,
then the changes should not be amended. Thus, it passes !res (success of
applying the 'edit' commit) to error_with_patch() for the to_amend flag.
The problematic line of code actually came from commit 04efc8b57c
("sequencer (rebase -i): implement the 'reword' command", 2017-01-02).
Note that to get to this point in the code:
* !!res (i.e. patch application failed)
* item->command < TODO_SQUASH
* item->command != TODO_EDIT
* !is_fixup(item->command) [i.e. not squash or fixup]
So that means this can only be a failed patch application that is either a
pick, revert, or reword. We only need to amend HEAD when rewording the
root commit or a commit that has been fast-forwarded, for any of the other
cases we want a new commit, so we should not set the to_amend flag.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Original-patch-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-19 12:46:51 +00:00
|
|
|
test_expect_success 'rebase -i --root when root has untracked file confilct' '
|
|
|
|
test_when_finished "reset_rebase" &&
|
|
|
|
git checkout -b failing-root-pick A &&
|
|
|
|
echo x >file2 &&
|
|
|
|
git rm file1 &&
|
|
|
|
git commit -m "remove file 1 add file 2" &&
|
|
|
|
echo z >file1 &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="1 2" git rebase -i --root &&
|
|
|
|
rm file1 &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test "$(git log -1 --format=%B)" = "remove file 1 add file 2" &&
|
|
|
|
test "$(git rev-list --count HEAD)" = 2
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i --root reword root when root has untracked file conflict' '
|
|
|
|
test_when_finished "reset_rebase" &&
|
|
|
|
echo z>file1 &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="reword 1 2" \
|
|
|
|
FAKE_COMMIT_MESSAGE="Modified A" git rebase -i --root &&
|
|
|
|
rm file1 &&
|
|
|
|
FAKE_COMMIT_MESSAGE="Reworded A" git rebase --continue &&
|
|
|
|
test "$(git log -1 --format=%B HEAD^)" = "Reworded A" &&
|
|
|
|
test "$(git rev-list --count HEAD)" = 2
|
|
|
|
'
|
|
|
|
|
2017-05-05 18:19:32 +00:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'rebase --edit-todo does not work on non-interactive rebase' '
|
sequencer: do not squash 'reword' commits when we hit conflicts
Ever since commit 18633e1a22 ("rebase -i: use the rebase--helper builtin",
2017-02-09), when a commit marked as 'reword' in an interactive rebase
has conflicts and fails to apply, when the rebase is resumed that commit
will be squashed into its parent with its commit message taken.
The issue can be understood better by looking at commit 56dc3ab04b
("sequencer (rebase -i): implement the 'edit' command", 2017-01-02), which
introduced error_with_patch() for the edit command. For the edit command,
it needs to stop the rebase whether or not the patch applies cleanly. If
the patch does apply cleanly, then when it resumes it knows it needs to
amend all changes into the previous commit. If it does not apply cleanly,
then the changes should not be amended. Thus, it passes !res (success of
applying the 'edit' commit) to error_with_patch() for the to_amend flag.
The problematic line of code actually came from commit 04efc8b57c
("sequencer (rebase -i): implement the 'reword' command", 2017-01-02).
Note that to get to this point in the code:
* !!res (i.e. patch application failed)
* item->command < TODO_SQUASH
* item->command != TODO_EDIT
* !is_fixup(item->command) [i.e. not squash or fixup]
So that means this can only be a failed patch application that is either a
pick, revert, or reword. We only need to amend HEAD when rewording the
root commit or a commit that has been fast-forwarded, for any of the other
cases we want a new commit, so we should not set the to_amend flag.
Helped-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Original-patch-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Phillip Wood <phillip.wood@dunelm.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-19 12:46:51 +00:00
|
|
|
git checkout reword-root-branch &&
|
2012-09-18 01:28:10 +00:00
|
|
|
git reset --hard &&
|
|
|
|
git checkout conflict-branch &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-09-18 01:28:10 +00:00
|
|
|
test_must_fail git rebase --onto HEAD~2 HEAD~ &&
|
|
|
|
test_must_fail git rebase --edit-todo &&
|
|
|
|
git rebase --abort
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase --edit-todo can be used to modify todo' '
|
|
|
|
git reset --hard &&
|
|
|
|
git checkout no-conflict-branch^0 &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2012-09-18 01:28:10 +00:00
|
|
|
FAKE_LINES="edit 1 2 3" git rebase -i HEAD~3 &&
|
|
|
|
FAKE_LINES="2 1" git rebase --edit-todo &&
|
2015-03-20 10:06:44 +00:00
|
|
|
git rebase --continue &&
|
2012-09-18 01:28:10 +00:00
|
|
|
test M = $(git cat-file commit HEAD^ | sed -ne \$p) &&
|
|
|
|
test L = $(git cat-file commit HEAD | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2013-06-16 08:45:13 +00:00
|
|
|
test_expect_success 'rebase -i produces readable reflog' '
|
|
|
|
git reset --hard &&
|
|
|
|
git branch -f branch-reflog-test H &&
|
2013-08-24 00:10:40 +00:00
|
|
|
set_fake_editor &&
|
2013-06-16 08:45:13 +00:00
|
|
|
git rebase -i --onto I F branch-reflog-test &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
rebase -i (finish): returning to refs/heads/branch-reflog-test
|
2015-07-27 22:57:08 +00:00
|
|
|
rebase -i (pick): H
|
|
|
|
rebase -i (pick): G
|
|
|
|
rebase -i (start): checkout I
|
2013-06-16 08:45:13 +00:00
|
|
|
EOF
|
2015-07-27 22:57:08 +00:00
|
|
|
git reflog -n4 HEAD |
|
|
|
|
sed "s/[^:]*: //" >actual &&
|
2013-06-16 08:45:13 +00:00
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2013-02-11 23:08:04 +00:00
|
|
|
test_expect_success 'rebase -i respects core.commentchar' '
|
|
|
|
git reset --hard &&
|
|
|
|
git checkout E^0 &&
|
2013-03-24 21:06:04 +00:00
|
|
|
test_config core.commentchar "\\" &&
|
2013-02-11 23:08:04 +00:00
|
|
|
write_script remove-all-but-first.sh <<-\EOF &&
|
|
|
|
sed -e "2,\$s/^/\\\\/" "$1" >"$1.tmp" &&
|
|
|
|
mv "$1.tmp" "$1"
|
|
|
|
EOF
|
|
|
|
test_set_editor "$(pwd)/remove-all-but-first.sh" &&
|
|
|
|
git rebase -i B &&
|
|
|
|
test B = $(git cat-file commit HEAD^ | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2016-11-21 14:18:29 +00:00
|
|
|
test_expect_success 'rebase -i respects core.commentchar=auto' '
|
2016-11-21 14:18:05 +00:00
|
|
|
test_config core.commentchar auto &&
|
|
|
|
write_script copy-edit-script.sh <<-\EOF &&
|
|
|
|
cp "$1" edit-script
|
|
|
|
EOF
|
|
|
|
test_set_editor "$(pwd)/copy-edit-script.sh" &&
|
|
|
|
test_when_finished "git rebase --abort || :" &&
|
|
|
|
git rebase -i HEAD^ &&
|
|
|
|
test -z "$(grep -ve "^#" -e "^\$" -e "^pick" edit-script)"
|
|
|
|
'
|
|
|
|
|
2013-06-14 13:17:52 +00:00
|
|
|
test_expect_success 'rebase -i, with <onto> and <upstream> specified as :/quuxery' '
|
2013-06-14 13:17:50 +00:00
|
|
|
test_when_finished "git branch -D torebase" &&
|
|
|
|
git checkout -b torebase branch1 &&
|
|
|
|
upstream=$(git rev-parse ":/J") &&
|
|
|
|
onto=$(git rev-parse ":/A") &&
|
|
|
|
git rebase --onto $onto $upstream &&
|
|
|
|
git reset --hard branch1 &&
|
|
|
|
git rebase --onto ":/A" ":/J" &&
|
|
|
|
git checkout branch1
|
|
|
|
'
|
|
|
|
|
2013-07-02 08:05:48 +00:00
|
|
|
test_expect_success 'rebase -i with --strategy and -X' '
|
|
|
|
git checkout -b conflict-merge-use-theirs conflict-branch &&
|
|
|
|
git reset --hard HEAD^ &&
|
|
|
|
echo five >conflict &&
|
|
|
|
echo Z >file1 &&
|
|
|
|
git commit -a -m "one file conflict" &&
|
|
|
|
EDITOR=true git rebase -i --strategy=recursive -Xours conflict-branch &&
|
|
|
|
test $(git show conflict-branch:conflict) = $(cat conflict) &&
|
|
|
|
test $(cat file1) = Z
|
|
|
|
'
|
|
|
|
|
rebase -i: remember merge options beyond continue actions
If the user explicitly specified a merge strategy or strategy
options, continue to use that strategy/option after
"rebase --continue". Add a test of the corrected behavior.
If --merge is specified or implied by -s or -X, then "strategy and
"strategy_opts" are set to values from which "strategy_args" can be
derived; otherwise they are set to empty strings. Either way,
their values are propagated from one step of an interactive rebase
to the next via state files.
"do_merge", on the other hand, is *not* propagated to later steps of
an interactive rebase. Therefore, making the initialization of
"strategy_args" conditional on "do_merge" being set prevents later
steps of an interactive rebase from setting it correctly.
Luckily, we don't need the "do_merge" guard at all. If the rebase
was started without --merge, then "strategy" and "strategy_opts"
are both the empty string, which results in "strategy_args" also
being set to the empty string, which is just what we want in that
situation. So remove the "do_merge" guard and derive
"strategy_args" from "strategy" and "strategy_opts" every time.
Reported-by: Diogo de Campos <campos@esss.com.br>
Signed-off-by: Fabian Ruch <bafain@gmail.com>
Helped-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Ralf Thielow <ralf.thielow@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-12-11 20:30:36 +00:00
|
|
|
test_expect_success 'interrupted rebase -i with --strategy and -X' '
|
|
|
|
git checkout -b conflict-merge-use-theirs-interrupted conflict-branch &&
|
|
|
|
git reset --hard HEAD^ &&
|
|
|
|
>breakpoint &&
|
|
|
|
git add breakpoint &&
|
|
|
|
git commit -m "breakpoint for interactive mode" &&
|
|
|
|
echo five >conflict &&
|
|
|
|
echo Z >file1 &&
|
|
|
|
git commit -a -m "one file conflict" &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1 2" git rebase -i --strategy=recursive -Xours conflict-branch &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git show conflict-branch:conflict) = $(cat conflict) &&
|
|
|
|
test $(cat file1) = Z
|
|
|
|
'
|
|
|
|
|
2013-08-07 09:26:05 +00:00
|
|
|
test_expect_success 'rebase -i error on commits with \ in message' '
|
2015-03-20 10:07:15 +00:00
|
|
|
current_head=$(git rev-parse HEAD) &&
|
2013-08-07 09:26:05 +00:00
|
|
|
test_when_finished "git rebase --abort; git reset --hard $current_head; rm -f error" &&
|
|
|
|
test_commit TO-REMOVE will-conflict old-content &&
|
|
|
|
test_commit "\temp" will-conflict new-content dummy &&
|
2014-03-18 18:54:05 +00:00
|
|
|
test_must_fail env EDITOR=true git rebase -i HEAD^ --onto HEAD^^ 2>error &&
|
2013-08-07 09:26:05 +00:00
|
|
|
test_expect_code 1 grep " emp" error
|
|
|
|
'
|
|
|
|
|
2013-08-24 00:10:41 +00:00
|
|
|
test_expect_success 'short SHA-1 setup' '
|
|
|
|
test_when_finished "git checkout master" &&
|
|
|
|
git checkout --orphan collide &&
|
|
|
|
git rm -rf . &&
|
|
|
|
(
|
|
|
|
unset test_tick &&
|
|
|
|
test_commit collide1 collide &&
|
|
|
|
test_commit --notick collide2 collide &&
|
|
|
|
test_commit --notick collide3 collide
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2013-08-24 00:10:42 +00:00
|
|
|
test_expect_success 'short SHA-1 collide' '
|
2013-08-24 00:10:41 +00:00
|
|
|
test_when_finished "reset_rebase && git checkout master" &&
|
|
|
|
git checkout collide &&
|
|
|
|
(
|
|
|
|
unset test_tick &&
|
|
|
|
test_tick &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_COMMIT_MESSAGE="collide2 ac4f2ee" \
|
|
|
|
FAKE_LINES="reword 1 2" git rebase -i HEAD~2
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2015-01-22 11:50:15 +00:00
|
|
|
test_expect_success 'respect core.abbrev' '
|
|
|
|
git config core.abbrev 12 &&
|
|
|
|
set_cat_todo_editor &&
|
|
|
|
test_must_fail git rebase -i HEAD~4 >todo-list &&
|
|
|
|
test 4 = $(grep -c "pick [0-9a-f]\{12,\}" todo-list)
|
|
|
|
'
|
|
|
|
|
2015-03-04 07:53:04 +00:00
|
|
|
test_expect_success 'todo count' '
|
|
|
|
write_script dump-raw.sh <<-\EOF &&
|
|
|
|
cat "$1"
|
|
|
|
EOF
|
|
|
|
test_set_editor "$(pwd)/dump-raw.sh" &&
|
|
|
|
git rebase -i HEAD~4 >actual &&
|
2016-06-17 20:21:04 +00:00
|
|
|
test_i18ngrep "^# Rebase ..* onto ..* ([0-9]" actual
|
2015-03-04 07:53:04 +00:00
|
|
|
'
|
|
|
|
|
2015-04-28 22:55:20 +00:00
|
|
|
test_expect_success 'rebase -i commits that overwrite untracked files (pick)' '
|
|
|
|
git checkout --force branch2 &&
|
|
|
|
git clean -f &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1 2" git rebase -i A &&
|
|
|
|
test_cmp_rev HEAD F &&
|
|
|
|
test_path_is_missing file6 &&
|
|
|
|
>file6 &&
|
|
|
|
test_must_fail git rebase --continue &&
|
|
|
|
test_cmp_rev HEAD F &&
|
|
|
|
rm file6 &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test_cmp_rev HEAD I
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i commits that overwrite untracked files (squash)' '
|
|
|
|
git checkout --force branch2 &&
|
|
|
|
git clean -f &&
|
|
|
|
git tag original-branch2 &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1 squash 2" git rebase -i A &&
|
|
|
|
test_cmp_rev HEAD F &&
|
|
|
|
test_path_is_missing file6 &&
|
|
|
|
>file6 &&
|
|
|
|
test_must_fail git rebase --continue &&
|
|
|
|
test_cmp_rev HEAD F &&
|
|
|
|
rm file6 &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git cat-file commit HEAD | sed -ne \$p) = I &&
|
|
|
|
git reset --hard original-branch2
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i commits that overwrite untracked files (no ff)' '
|
|
|
|
git checkout --force branch2 &&
|
|
|
|
git clean -f &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1 2" git rebase -i --no-ff A &&
|
|
|
|
test $(git cat-file commit HEAD | sed -ne \$p) = F &&
|
|
|
|
test_path_is_missing file6 &&
|
|
|
|
>file6 &&
|
|
|
|
test_must_fail git rebase --continue &&
|
|
|
|
test $(git cat-file commit HEAD | sed -ne \$p) = F &&
|
|
|
|
rm file6 &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test $(git cat-file commit HEAD | sed -ne \$p) = I
|
|
|
|
'
|
|
|
|
|
2015-06-18 16:38:53 +00:00
|
|
|
test_expect_success 'rebase --continue removes CHERRY_PICK_HEAD' '
|
2015-06-18 16:38:44 +00:00
|
|
|
git checkout -b commit-to-skip &&
|
|
|
|
for double in X 3 1
|
|
|
|
do
|
|
|
|
test_seq 5 | sed "s/$double/&&/" >seq &&
|
|
|
|
git add seq &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m seq-$double
|
|
|
|
done &&
|
|
|
|
git tag seq-onto &&
|
|
|
|
git reset --hard HEAD~2 &&
|
|
|
|
git cherry-pick seq-onto &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES= git rebase -i seq-onto &&
|
|
|
|
test -d .git/rebase-merge &&
|
|
|
|
git rebase --continue &&
|
|
|
|
git diff --exit-code seq-onto &&
|
|
|
|
test ! -d .git/rebase-merge &&
|
|
|
|
test ! -f .git/CHERRY_PICK_HEAD
|
|
|
|
'
|
|
|
|
|
2015-06-29 20:20:30 +00:00
|
|
|
rebase_setup_and_clean () {
|
|
|
|
test_when_finished "
|
|
|
|
git checkout master &&
|
|
|
|
test_might_fail git branch -D $1 &&
|
|
|
|
test_might_fail git rebase --abort
|
|
|
|
" &&
|
2018-07-31 07:33:28 +00:00
|
|
|
git checkout -b $1 ${2:-master}
|
2015-06-29 20:20:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'drop' '
|
|
|
|
rebase_setup_and_clean drop-test &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="1 drop 2 3 drop 4 5" git rebase -i --root &&
|
|
|
|
test E = $(git cat-file commit HEAD | sed -ne \$p) &&
|
|
|
|
test C = $(git cat-file commit HEAD^ | sed -ne \$p) &&
|
|
|
|
test A = $(git cat-file commit HEAD^^ | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2015-06-29 20:20:31 +00:00
|
|
|
test_expect_success 'rebase -i respects rebase.missingCommitsCheck = ignore' '
|
|
|
|
test_config rebase.missingCommitsCheck ignore &&
|
|
|
|
rebase_setup_and_clean missing-commit &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="1 2 3 4" \
|
|
|
|
git rebase -i --root 2>actual &&
|
|
|
|
test D = $(git cat-file commit HEAD | sed -ne \$p) &&
|
rebase -i --root: let the sequencer handle even the initial part
In this developer's earlier attempt to accelerate interactive rebases by
converting large parts from Unix shell script into portable, performant
C, the --root handling was specifically excluded (to simplify the task a
little bit; it still took over a year to get that reduced set of patches
into Git proper).
This patch ties up that loose end: now only --preserve-merges uses the
slow Unix shell script implementation to perform the interactive rebase.
As the rebase--helper reports progress to stderr (unlike the scripted
interactive rebase, which reports it to stdout, of all places), we have
to adjust a couple of tests that did not expect that for `git rebase -i
--root`.
This patch fixes -- at long last! -- the really old bug reported in
6a6bc5bdc4d (add tests for rebasing root, 2013-06-06) that rebasing with
--root *always* rewrote the root commit, even if there were no changes.
The bug still persists in --preserve-merges mode, of course, but that
mode will be deprecated as soon as the new --rebase-merges mode
stabilizes, anyway.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-03 23:01:18 +00:00
|
|
|
test_i18ngrep \
|
|
|
|
"Successfully rebased and updated refs/heads/missing-commit" \
|
|
|
|
actual
|
2015-06-29 20:20:31 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
cat >expect <<EOF
|
|
|
|
Warning: some commits may have been dropped accidentally.
|
|
|
|
Dropped commits (newer to older):
|
|
|
|
- $(git rev-list --pretty=oneline --abbrev-commit -1 master)
|
|
|
|
To avoid this message, use "drop" to explicitly remove a commit.
|
|
|
|
|
|
|
|
Use 'git config rebase.missingCommitsCheck' to change the level of warnings.
|
|
|
|
The possible behaviours are: ignore, warn, error.
|
|
|
|
|
rebase -i --root: let the sequencer handle even the initial part
In this developer's earlier attempt to accelerate interactive rebases by
converting large parts from Unix shell script into portable, performant
C, the --root handling was specifically excluded (to simplify the task a
little bit; it still took over a year to get that reduced set of patches
into Git proper).
This patch ties up that loose end: now only --preserve-merges uses the
slow Unix shell script implementation to perform the interactive rebase.
As the rebase--helper reports progress to stderr (unlike the scripted
interactive rebase, which reports it to stdout, of all places), we have
to adjust a couple of tests that did not expect that for `git rebase -i
--root`.
This patch fixes -- at long last! -- the really old bug reported in
6a6bc5bdc4d (add tests for rebasing root, 2013-06-06) that rebasing with
--root *always* rewrote the root commit, even if there were no changes.
The bug still persists in --preserve-merges mode, of course, but that
mode will be deprecated as soon as the new --rebase-merges mode
stabilizes, anyway.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-03 23:01:18 +00:00
|
|
|
Rebasing (1/4)
|
|
|
|
Rebasing (2/4)
|
|
|
|
Rebasing (3/4)
|
|
|
|
Rebasing (4/4)
|
2015-06-29 20:20:31 +00:00
|
|
|
Successfully rebased and updated refs/heads/missing-commit.
|
|
|
|
EOF
|
|
|
|
|
rebase -i --root: let the sequencer handle even the initial part
In this developer's earlier attempt to accelerate interactive rebases by
converting large parts from Unix shell script into portable, performant
C, the --root handling was specifically excluded (to simplify the task a
little bit; it still took over a year to get that reduced set of patches
into Git proper).
This patch ties up that loose end: now only --preserve-merges uses the
slow Unix shell script implementation to perform the interactive rebase.
As the rebase--helper reports progress to stderr (unlike the scripted
interactive rebase, which reports it to stdout, of all places), we have
to adjust a couple of tests that did not expect that for `git rebase -i
--root`.
This patch fixes -- at long last! -- the really old bug reported in
6a6bc5bdc4d (add tests for rebasing root, 2013-06-06) that rebasing with
--root *always* rewrote the root commit, even if there were no changes.
The bug still persists in --preserve-merges mode, of course, but that
mode will be deprecated as soon as the new --rebase-merges mode
stabilizes, anyway.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-03 23:01:18 +00:00
|
|
|
cr_to_nl () {
|
|
|
|
tr '\015' '\012'
|
|
|
|
}
|
|
|
|
|
2015-06-29 20:20:31 +00:00
|
|
|
test_expect_success 'rebase -i respects rebase.missingCommitsCheck = warn' '
|
|
|
|
test_config rebase.missingCommitsCheck warn &&
|
|
|
|
rebase_setup_and_clean missing-commit &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="1 2 3 4" \
|
rebase -i --root: let the sequencer handle even the initial part
In this developer's earlier attempt to accelerate interactive rebases by
converting large parts from Unix shell script into portable, performant
C, the --root handling was specifically excluded (to simplify the task a
little bit; it still took over a year to get that reduced set of patches
into Git proper).
This patch ties up that loose end: now only --preserve-merges uses the
slow Unix shell script implementation to perform the interactive rebase.
As the rebase--helper reports progress to stderr (unlike the scripted
interactive rebase, which reports it to stdout, of all places), we have
to adjust a couple of tests that did not expect that for `git rebase -i
--root`.
This patch fixes -- at long last! -- the really old bug reported in
6a6bc5bdc4d (add tests for rebasing root, 2013-06-06) that rebasing with
--root *always* rewrote the root commit, even if there were no changes.
The bug still persists in --preserve-merges mode, of course, but that
mode will be deprecated as soon as the new --rebase-merges mode
stabilizes, anyway.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-05-03 23:01:18 +00:00
|
|
|
git rebase -i --root 2>actual.2 &&
|
|
|
|
cr_to_nl <actual.2 >actual &&
|
2016-06-17 20:21:04 +00:00
|
|
|
test_i18ncmp expect actual &&
|
2015-06-29 20:20:31 +00:00
|
|
|
test D = $(git cat-file commit HEAD | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >expect <<EOF
|
|
|
|
Warning: some commits may have been dropped accidentally.
|
|
|
|
Dropped commits (newer to older):
|
|
|
|
- $(git rev-list --pretty=oneline --abbrev-commit -1 master)
|
|
|
|
- $(git rev-list --pretty=oneline --abbrev-commit -1 master~2)
|
|
|
|
To avoid this message, use "drop" to explicitly remove a commit.
|
|
|
|
|
|
|
|
Use 'git config rebase.missingCommitsCheck' to change the level of warnings.
|
|
|
|
The possible behaviours are: ignore, warn, error.
|
|
|
|
|
2016-09-06 18:59:18 +00:00
|
|
|
You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'.
|
2015-06-29 20:20:31 +00:00
|
|
|
Or you can abort the rebase with 'git rebase --abort'.
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i respects rebase.missingCommitsCheck = error' '
|
|
|
|
test_config rebase.missingCommitsCheck error &&
|
|
|
|
rebase_setup_and_clean missing-commit &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="1 2 4" \
|
|
|
|
git rebase -i --root 2>actual &&
|
2016-06-17 20:21:04 +00:00
|
|
|
test_i18ncmp expect actual &&
|
2015-06-29 20:20:31 +00:00
|
|
|
cp .git/rebase-merge/git-rebase-todo.backup \
|
|
|
|
.git/rebase-merge/git-rebase-todo &&
|
|
|
|
FAKE_LINES="1 2 drop 3 4 drop 5" \
|
|
|
|
git rebase --edit-todo &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test D = $(git cat-file commit HEAD | sed -ne \$p) &&
|
|
|
|
test B = $(git cat-file commit HEAD^ | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2017-12-05 17:52:35 +00:00
|
|
|
test_expect_success 'respects rebase.abbreviateCommands with fixup, squash and exec' '
|
|
|
|
rebase_setup_and_clean abbrevcmd &&
|
|
|
|
test_commit "first" file1.txt "first line" first &&
|
|
|
|
test_commit "second" file1.txt "another line" second &&
|
|
|
|
test_commit "fixup! first" file2.txt "first line again" first_fixup &&
|
|
|
|
test_commit "squash! second" file1.txt "another line here" second_squash &&
|
|
|
|
cat >expected <<-EOF &&
|
|
|
|
p $(git rev-list --abbrev-commit -1 first) first
|
|
|
|
f $(git rev-list --abbrev-commit -1 first_fixup) fixup! first
|
|
|
|
x git show HEAD
|
|
|
|
p $(git rev-list --abbrev-commit -1 second) second
|
|
|
|
s $(git rev-list --abbrev-commit -1 second_squash) squash! second
|
|
|
|
x git show HEAD
|
|
|
|
EOF
|
|
|
|
git checkout abbrevcmd &&
|
|
|
|
set_cat_todo_editor &&
|
|
|
|
test_config rebase.abbreviateCommands true &&
|
|
|
|
test_must_fail git rebase -i --exec "git show HEAD" \
|
|
|
|
--autosquash master >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
2015-06-29 20:20:32 +00:00
|
|
|
test_expect_success 'static check of bad command' '
|
|
|
|
rebase_setup_and_clean bad-cmd &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="1 2 3 bad 4 5" \
|
|
|
|
git rebase -i --root 2>actual &&
|
2017-07-14 14:45:14 +00:00
|
|
|
test_i18ngrep "badcmd $(git rev-list --oneline -1 master~1)" actual &&
|
|
|
|
test_i18ngrep "You can fix this with .git rebase --edit-todo.." actual &&
|
2015-06-29 20:20:32 +00:00
|
|
|
FAKE_LINES="1 2 3 drop 4 5" git rebase --edit-todo &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test E = $(git cat-file commit HEAD | sed -ne \$p) &&
|
|
|
|
test C = $(git cat-file commit HEAD^ | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2015-10-01 08:18:42 +00:00
|
|
|
test_expect_success 'tabs and spaces are accepted in the todolist' '
|
|
|
|
rebase_setup_and_clean indented-comment &&
|
|
|
|
write_script add-indent.sh <<-\EOF &&
|
|
|
|
(
|
|
|
|
# Turn single spaces into space/tab mix
|
|
|
|
sed "1s/ / /g; 2s/ / /g; 3s/ / /g" "$1"
|
|
|
|
printf "\n\t# comment\n #more\n\t # comment\n"
|
2015-12-02 20:50:07 +00:00
|
|
|
) >"$1.new"
|
2015-10-01 08:18:42 +00:00
|
|
|
mv "$1.new" "$1"
|
|
|
|
EOF
|
|
|
|
test_set_editor "$(pwd)/add-indent.sh" &&
|
|
|
|
git rebase -i HEAD^^^ &&
|
|
|
|
test E = $(git cat-file commit HEAD | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2015-06-29 20:20:32 +00:00
|
|
|
test_expect_success 'static check of bad SHA-1' '
|
|
|
|
rebase_setup_and_clean bad-sha &&
|
|
|
|
set_fake_editor &&
|
|
|
|
test_must_fail env FAKE_LINES="1 2 edit fakesha 3 4 5 #" \
|
|
|
|
git rebase -i --root 2>actual &&
|
2017-07-14 14:45:14 +00:00
|
|
|
test_i18ngrep "edit XXXXXXX False commit" actual &&
|
|
|
|
test_i18ngrep "You can fix this with .git rebase --edit-todo.." actual &&
|
2015-06-29 20:20:32 +00:00
|
|
|
FAKE_LINES="1 2 4 5 6" git rebase --edit-todo &&
|
|
|
|
git rebase --continue &&
|
|
|
|
test E = $(git cat-file commit HEAD | sed -ne \$p)
|
|
|
|
'
|
|
|
|
|
2015-10-28 14:54:48 +00:00
|
|
|
test_expect_success 'editor saves as CR/LF' '
|
2015-10-28 14:54:21 +00:00
|
|
|
git checkout -b with-crlf &&
|
|
|
|
write_script add-crs.sh <<-\EOF &&
|
|
|
|
sed -e "s/\$/Q/" <"$1" | tr Q "\\015" >"$1".new &&
|
|
|
|
mv -f "$1".new "$1"
|
|
|
|
EOF
|
|
|
|
(
|
|
|
|
test_set_editor "$(pwd)/add-crs.sh" &&
|
|
|
|
git rebase -i HEAD^
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2016-07-07 15:52:50 +00:00
|
|
|
SQ="'"
|
|
|
|
test_expect_success 'rebase -i --gpg-sign=<key-id>' '
|
2017-12-22 11:50:50 +00:00
|
|
|
test_when_finished "test_might_fail git rebase --abort" &&
|
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1" git rebase -i --gpg-sign="\"S I Gner\"" HEAD^ \
|
|
|
|
>out 2>err &&
|
|
|
|
test_i18ngrep "$SQ-S\"S I Gner\"$SQ" err
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rebase -i --gpg-sign=<key-id> overrides commit.gpgSign' '
|
|
|
|
test_when_finished "test_might_fail git rebase --abort" &&
|
|
|
|
test_config commit.gpgsign true &&
|
2016-07-07 15:52:50 +00:00
|
|
|
set_fake_editor &&
|
|
|
|
FAKE_LINES="edit 1" git rebase -i --gpg-sign="\"S I Gner\"" HEAD^ \
|
|
|
|
>out 2>err &&
|
2016-08-12 11:59:00 +00:00
|
|
|
test_i18ngrep "$SQ-S\"S I Gner\"$SQ" err
|
2016-07-07 15:52:50 +00:00
|
|
|
'
|
|
|
|
|
2018-07-31 07:33:28 +00:00
|
|
|
test_expect_success 'valid author header after --root swap' '
|
|
|
|
rebase_setup_and_clean author-header no-conflict-branch &&
|
|
|
|
set_fake_editor &&
|
2018-08-07 09:34:52 +00:00
|
|
|
git commit --amend --author="Au ${SQ}thor <author@example.com>" --no-edit &&
|
|
|
|
git cat-file commit HEAD | grep ^author >expected &&
|
|
|
|
FAKE_LINES="5 1" git rebase -i --root &&
|
|
|
|
git cat-file commit HEAD^ | grep ^author >actual &&
|
|
|
|
test_cmp expected actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'valid author header when author contains single quote' '
|
|
|
|
rebase_setup_and_clean author-header no-conflict-branch &&
|
|
|
|
set_fake_editor &&
|
|
|
|
git commit --amend --author="Au ${SQ}thor <author@example.com>" --no-edit &&
|
|
|
|
git cat-file commit HEAD | grep ^author >expected &&
|
|
|
|
FAKE_LINES="2" git rebase -i HEAD~2 &&
|
|
|
|
git cat-file commit HEAD | grep ^author >actual &&
|
|
|
|
test_cmp expected actual
|
2018-07-31 07:33:28 +00:00
|
|
|
'
|
|
|
|
|
2007-06-25 00:11:14 +00:00
|
|
|
test_done
|