kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Rename .git/rebase to .git/rebase-apply 

With git-am, it sounds awkward to have the patches in ".git/rebase/",
but for technical reasons, we have to keep the same directory name
for git-am and git-rebase. ".git/rebase-apply" seems to be a good
compromise.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Johannes Schindelin 17 years ago committed by Junio C Hamano
parent
59eb68aa2b
commit
51ef1daa4a
13 changed files with 58 additions and 54 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      Documentation/SubmittingPatches
  2. 4
      Documentation/git-am.txt
  3. 4
      Documentation/git-rebase.txt
  4. 2
      Documentation/user-manual.txt
  5. 10
      contrib/completion/git-completion.bash
  6. 8
      contrib/emacs/git.el
  7. 2
      git-am.sh
  8. 2
      git-quiltimport.sh
  9. 48
      git-rebase.sh
  10. 2
      t/t3401-rebase-partial.sh
  11. 2
      t/t3407-rebase-abort.sh
  12. 22
      t/t4150-am.sh
  13. 4
      t/t9106-git-svn-commit-diff-clobber.sh

2
Documentation/SubmittingPatches
Unescape View File

@ -301,7 +301,7 @@ If it does not apply correctly, there can be various reasons.
patch appropriately. patch appropriately.


* Your MUA corrupted your patch; "am" would complain that * Your MUA corrupted your patch; "am" would complain that
the patch does not apply. Look at .git/rebase/ subdirectory and the patch does not apply. Look at .git/rebase-apply/ subdirectory and
see what 'patch' file contains and check for the common see what 'patch' file contains and check for the common
corruption patterns mentioned above. corruption patterns mentioned above.



4
Documentation/git-am.txt
Unescape View File

@ -143,9 +143,9 @@ aborts in the middle,. You can recover from this in one of two ways:
the index file to bring it in a state that the patch should the index file to bring it in a state that the patch should
have produced. Then run the command with '--resolved' option. have produced. Then run the command with '--resolved' option.


The command refuses to process new mailboxes while `.git/rebase` The command refuses to process new mailboxes while `.git/rebase-apply`
directory exists, so if you decide to start over from scratch, directory exists, so if you decide to start over from scratch,
run `rm -f -r .git/rebase` before running the command with mailbox run `rm -f -r .git/rebase-apply` before running the command with mailbox
names. names.


Before any patches are applied, ORIG_HEAD is set to the tip of the Before any patches are applied, ORIG_HEAD is set to the tip of the

4
Documentation/git-rebase.txt
Unescape View File

@ -39,8 +39,8 @@ It is possible that a merge failure will prevent this process from being
completely automatic. You will have to resolve any such merge failure completely automatic. You will have to resolve any such merge failure
and run `git rebase --continue`. Another option is to bypass the commit and run `git rebase --continue`. Another option is to bypass the commit
that caused the merge failure with `git rebase --skip`. To restore the that caused the merge failure with `git rebase --skip`. To restore the
original <branch> and remove the .git/rebase working files, use the command original <branch> and remove the .git/rebase-apply working files, use the
`git rebase --abort` instead. command `git rebase --abort` instead.


Assume the following history exists and the current branch is "topic": Assume the following history exists and the current branch is "topic":



2
Documentation/user-manual.txt
Unescape View File

@ -2431,7 +2431,7 @@ $ git rebase origin
------------------------------------------------- -------------------------------------------------


This will remove each of your commits from mywork, temporarily saving This will remove each of your commits from mywork, temporarily saving
them as patches (in a directory named ".git/rebase"), update mywork to them as patches (in a directory named ".git/rebase-apply"), update mywork to
point at the latest version of origin, then apply each of the saved point at the latest version of origin, then apply each of the saved
patches to the new mywork. The result will look like: patches to the new mywork. The result will look like:



10
contrib/completion/git-completion.bash
Unescape View File

@ -73,12 +73,12 @@ __git_ps1 ()
if [ -n "$g" ]; then if [ -n "$g" ]; then
local r local r
local b local b
if [ -d "$g/rebase" ] if [ -d "$g/rebase-apply" ]
then then
if test -f "$g/rebase/rebasing" if test -f "$g/rebase-apply/rebasing"
then then
r="|REBASE" r="|REBASE"
elif test -f "$g/rebase/applying" elif test -f "$g/rebase-apply/applying"
then then
r="|AM" r="|AM"
else else
@ -488,7 +488,7 @@ __git_whitespacelist="nowarn warn error error-all strip"
_git_am () _git_am ()
{ {
local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)" local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
if [ -d "$dir"/rebase ]; then if [ -d "$dir"/rebase-apply ]; then
__gitcomp "--skip --resolved" __gitcomp "--skip --resolved"
return return
fi fi
@ -915,7 +915,7 @@ _git_push ()
_git_rebase () _git_rebase ()
{ {
local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)" local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
if [ -d "$dir"/rebase ] || [ -d "$dir"/rebase-merge ]; then if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
__gitcomp "--continue --skip --abort" __gitcomp "--continue --skip --abort"
return return
fi fi

8
contrib/emacs/git.el
Unescape View File

@ -1252,8 +1252,8 @@ Return the list of files that haven't been handled."
"\n") "\n")
(when subject (insert subject "\n\n")) (when subject (insert subject "\n\n"))
(cond (msg (insert msg "\n")) (cond (msg (insert msg "\n"))
((file-readable-p ".git/rebase/msg") ((file-readable-p ".git/rebase-apply/msg")
(insert-file-contents ".git/rebase/msg")) (insert-file-contents ".git/rebase-apply/msg"))
((file-readable-p ".git/MERGE_MSG") ((file-readable-p ".git/MERGE_MSG")
(insert-file-contents ".git/MERGE_MSG"))) (insert-file-contents ".git/MERGE_MSG")))
; delete empty lines at end ; delete empty lines at end
@ -1272,9 +1272,9 @@ Return the list of files that haven't been handled."
(coding-system (git-get-commits-coding-system)) (coding-system (git-get-commits-coding-system))
author-name author-email subject date) author-name author-email subject date)
(when (eq 0 (buffer-size buffer)) (when (eq 0 (buffer-size buffer))
(when (file-readable-p ".git/rebase/info") (when (file-readable-p ".git/rebase-apply/info")
(with-temp-buffer (with-temp-buffer
(insert-file-contents ".git/rebase/info") (insert-file-contents ".git/rebase-apply/info")
(goto-char (point-min)) (goto-char (point-min))
(when (re-search-forward "^Author: \\(.*\\)\nEmail: \\(.*\\)$" nil t) (when (re-search-forward "^Author: \\(.*\\)\nEmail: \\(.*\\)$" nil t)
(setq author-name (match-string 1)) (setq author-name (match-string 1))

2
git-am.sh
Unescape View File

@ -121,7 +121,7 @@ It does not apply to blobs recorded in its index."
} }


prec=4 prec=4
dotest="$GIT_DIR/rebase" dotest="$GIT_DIR/rebase-apply"
sign= utf8=t keep= skip= interactive= resolved= binary= rebasing= abort= sign= utf8=t keep= skip= interactive= resolved= binary= rebasing= abort=
resolvemsg= resume= resolvemsg= resume=
git_apply_opt= git_apply_opt=

2
git-quiltimport.sh
Unescape View File

@ -53,7 +53,7 @@ if ! [ -d "$QUILT_PATCHES" ] ; then
fi fi


# Temporary directories # Temporary directories
tmp_dir="$GIT_DIR"/rebase tmp_dir="$GIT_DIR"/rebase-apply
tmp_msg="$tmp_dir/msg" tmp_msg="$tmp_dir/msg"
tmp_patch="$tmp_dir/patch" tmp_patch="$tmp_dir/patch"
tmp_info="$tmp_dir/info" tmp_info="$tmp_dir/info"

48
git-rebase.sh
Unescape View File

@ -14,8 +14,8 @@ It is possible that a merge failure will prevent this process from being
completely automatic. You will have to resolve any such merge failure completely automatic. You will have to resolve any such merge failure
and run git rebase --continue. Another option is to bypass the commit and run git rebase --continue. Another option is to bypass the commit
that caused the merge failure with git rebase --skip. To restore the that caused the merge failure with git rebase --skip. To restore the
original <branch> and remove the .git/rebase working files, use the command original <branch> and remove the .git/rebase-apply working files, use the
git rebase --abort instead. command git rebase --abort instead.


Note that if <branch> is not specified on the command line, the Note that if <branch> is not specified on the command line, the
currently checked out branch is used. currently checked out branch is used.
@ -150,7 +150,7 @@ while test $# != 0
do do
case "$1" in case "$1" in
--continue) --continue)
test -d "$dotest" -o -d "$GIT_DIR"/rebase || test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
die "No rebase in progress?" die "No rebase in progress?"


git diff-files --quiet --ignore-submodules || { git diff-files --quiet --ignore-submodules || {
@ -173,15 +173,15 @@ do
finish_rb_merge finish_rb_merge
exit exit
fi fi
head_name=$(cat "$GIT_DIR"/rebase/head-name) && head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
onto=$(cat "$GIT_DIR"/rebase/onto) && onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
orig_head=$(cat "$GIT_DIR"/rebase/orig-head) && orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
git am --resolved --3way --resolvemsg="$RESOLVEMSG" && git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch move_to_original_branch
exit exit
;; ;;
--skip) --skip)
test -d "$dotest" -o -d "$GIT_DIR"/rebase || test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
die "No rebase in progress?" die "No rebase in progress?"


git reset --hard HEAD || exit $? git reset --hard HEAD || exit $?
@ -201,15 +201,15 @@ do
finish_rb_merge finish_rb_merge
exit exit
fi fi
head_name=$(cat "$GIT_DIR"/rebase/head-name) && head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
onto=$(cat "$GIT_DIR"/rebase/onto) && onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
orig_head=$(cat "$GIT_DIR"/rebase/orig-head) && orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
git am -3 --skip --resolvemsg="$RESOLVEMSG" && git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch move_to_original_branch
exit exit
;; ;;
--abort) --abort)
test -d "$dotest" -o -d "$GIT_DIR"/rebase || test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
die "No rebase in progress?" die "No rebase in progress?"


git rerere clear git rerere clear
@ -217,7 +217,7 @@ do
then then
move_to_original_branch move_to_original_branch
else else
dotest="$GIT_DIR"/rebase dotest="$GIT_DIR"/rebase-apply
move_to_original_branch move_to_original_branch
fi fi
git reset --hard $(cat "$dotest/orig-head") git reset --hard $(cat "$dotest/orig-head")
@ -265,18 +265,20 @@ do
shift shift
done done


# Make sure we do not have $GIT_DIR/rebase # Make sure we do not have $GIT_DIR/rebase-apply
if test -z "$do_merge" if test -z "$do_merge"
then then
if mkdir "$GIT_DIR"/rebase if mkdir "$GIT_DIR"/rebase-apply
then then
rmdir "$GIT_DIR"/rebase rmdir "$GIT_DIR"/rebase-apply
else else
echo >&2 ' echo >&2 '
It seems that I cannot create a '"$GIT_DIR"'/rebase directory, and I wonder if you It seems that I cannot create a '"$GIT_DIR"'/rebase-apply directory,
are in the middle of patch application or another rebase. If that is not and I wonder if you are in the middle of patch application or another
the case, please rm -fr '"$GIT_DIR"'/rebase and run me again. I am stopping in case rebase. If that is not the case, please
you still have something valuable there.' rm -fr '"$GIT_DIR"'/rebase-apply
and run me again. I am stopping in case you still have something
valuable there.'
exit 1 exit 1
fi fi
else else
@ -395,10 +397,10 @@ then
git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" && git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" &&
move_to_original_branch move_to_original_branch
ret=$? ret=$?
test 0 != $ret -a -d "$GIT_DIR"/rebase && test 0 != $ret -a -d "$GIT_DIR"/rebase-apply &&
echo $head_name > "$GIT_DIR"/rebase/head-name && echo $head_name > "$GIT_DIR"/rebase-apply/head-name &&
echo $onto > "$GIT_DIR"/rebase/onto && echo $onto > "$GIT_DIR"/rebase-apply/onto &&
echo $orig_head > "$GIT_DIR"/rebase/orig-head echo $orig_head > "$GIT_DIR"/rebase-apply/orig-head
exit $ret exit $ret
fi fi



2
t/t3401-rebase-partial.sh
Unescape View File

@ -50,7 +50,7 @@ test_debug \


test_expect_success \ test_expect_success \
'rebase topic branch against new master and check git-am did not get halted' \ 'rebase topic branch against new master and check git-am did not get halted' \
'git-rebase master && test ! -d .git/rebase' 'git-rebase master && test ! -d .git/rebase-apply'


test_expect_success \ test_expect_success \
'rebase --merge topic branch that was partially merged upstream' \ 'rebase --merge topic branch that was partially merged upstream' \

2
t/t3407-rebase-abort.sh
Unescape View File

@ -74,7 +74,7 @@ testrebase() {
' '
} }


testrebase "" .git/rebase testrebase "" .git/rebase-apply
testrebase " --merge" .git/rebase-merge testrebase " --merge" .git/rebase-merge


test_done test_done

22
t/t4150-am.sh
Unescape View File

@ -102,7 +102,7 @@ test_expect_success 'am applies patch correctly' '
git checkout first && git checkout first &&
test_tick && test_tick &&
git am <patch1 && git am <patch1 &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test -z "$(git diff second)" && test -z "$(git diff second)" &&
test "$(git rev-parse second)" = "$(git rev-parse HEAD)" && test "$(git rev-parse second)" = "$(git rev-parse HEAD)" &&
test "$(git rev-parse second^)" = "$(git rev-parse HEAD^)" test "$(git rev-parse second^)" = "$(git rev-parse HEAD^)"
@ -123,7 +123,7 @@ test_expect_success 'am changes committer and keeps author' '
test_tick && test_tick &&
git checkout first && git checkout first &&
git am patch2 && git am patch2 &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test "$(git rev-parse master^^)" = "$(git rev-parse HEAD^^)" && test "$(git rev-parse master^^)" = "$(git rev-parse HEAD^^)" &&
test -z "$(git diff master..HEAD)" && test -z "$(git diff master..HEAD)" &&
test -z "$(git diff master^..HEAD^)" && test -z "$(git diff master^..HEAD^)" &&
@ -163,7 +163,7 @@ test_expect_success 'am without --keep removes Re: and [PATCH] stuff' '
test_expect_success 'am --keep really keeps the subject' ' test_expect_success 'am --keep really keeps the subject' '
git checkout HEAD^ && git checkout HEAD^ &&
git am --keep patch4 && git am --keep patch4 &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
git-cat-file commit HEAD | git-cat-file commit HEAD |
grep -q -F "Re: Re: Re: [PATCH 1/5 v2] third" grep -q -F "Re: Re: Re: [PATCH 1/5 v2] third"
' '
@ -176,19 +176,19 @@ test_expect_success 'am -3 falls back to 3-way merge' '
test_tick && test_tick &&
git commit -m "copied stuff" && git commit -m "copied stuff" &&
git am -3 lorem-move.patch && git am -3 lorem-move.patch &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test -z "$(git diff lorem)" test -z "$(git diff lorem)"
' '


test_expect_success 'am pauses on conflict' ' test_expect_success 'am pauses on conflict' '
git checkout lorem2^^ && git checkout lorem2^^ &&
test_must_fail git am lorem-move.patch && test_must_fail git am lorem-move.patch &&
test -d .git/rebase test -d .git/rebase-apply
' '


test_expect_success 'am --skip works' ' test_expect_success 'am --skip works' '
git am --skip && git am --skip &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test -z "$(git diff lorem2^^ -- file)" && test -z "$(git diff lorem2^^ -- file)" &&
test goodbye = "$(cat another)" test goodbye = "$(cat another)"
' '
@ -196,31 +196,31 @@ test_expect_success 'am --skip works' '
test_expect_success 'am --resolved works' ' test_expect_success 'am --resolved works' '
git checkout lorem2^^ && git checkout lorem2^^ &&
test_must_fail git am lorem-move.patch && test_must_fail git am lorem-move.patch &&
test -d .git/rebase && test -d .git/rebase-apply &&
echo resolved >>file && echo resolved >>file &&
git add file && git add file &&
git am --resolved && git am --resolved &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test goodbye = "$(cat another)" test goodbye = "$(cat another)"
' '


test_expect_success 'am takes patches from a Pine mailbox' ' test_expect_success 'am takes patches from a Pine mailbox' '
git checkout first && git checkout first &&
cat pine patch1 | git am && cat pine patch1 | git am &&
! test -d .git/rebase && ! test -d .git/rebase-apply &&
test -z "$(git diff master^..HEAD)" test -z "$(git diff master^..HEAD)"
' '


test_expect_success 'am fails on mail without patch' ' test_expect_success 'am fails on mail without patch' '
test_must_fail git am <failmail && test_must_fail git am <failmail &&
rm -r .git/rebase/ rm -r .git/rebase-apply/
' '


test_expect_success 'am fails on empty patch' ' test_expect_success 'am fails on empty patch' '
echo "---" >>failmail && echo "---" >>failmail &&
test_must_fail git am <failmail && test_must_fail git am <failmail &&
git am --skip && git am --skip &&
! test -d .git/rebase ! test -d .git/rebase-apply
' '


test_expect_success 'am works from stdin in subdirectory' ' test_expect_success 'am works from stdin in subdirectory' '

4
t/t9106-git-svn-commit-diff-clobber.sh
Unescape View File

@ -87,7 +87,9 @@ test_expect_success 'multiple dcommit from git-svn will not clobber svn' "
" "




test_expect_success 'check that rebase really failed' 'test -d .git/rebase' test_expect_success 'check that rebase really failed' '
test -d .git/rebase-apply
'


test_expect_success 'resolve, continue the rebase and dcommit' " test_expect_success 'resolve, continue the rebase and dcommit' "
echo clobber and I really mean it > file && echo clobber and I really mean it > file &&

Write Preview
Loading…
Cancel
Save