rebase-i-p: squashing and limiting todo
PATCH 1/1 rebase-i-p: squashing and limiting todo
This is v3, rebased on top of sp/maint with sp/master and sh/maint-rebase3.
So, it should apply cleanly to that. Junio's feedback aside, the only change from v2 is that maint-rebase3's dropped commit check needs to be done before Johannes's recent addition of:
test -s "$TODO" || echo noop >> "$TODO"
Because now the todo may temporarily have picks in it while probing for parents that could later be removed by the dropped/cherry-picked commit check.
Previously todo never had temporary entries, so it didn't matter when the dropped commit check was done.
(Apologies for not seeing Junio's what's cooking first and using his maint/master instead of Shawn's. Let me know if I need to redo this and I will get even more practice at rebasing.)
(Gah, resending with the list cc'd this time. Dammit, sorry about that.)
Thanks,
Stephen
Stephen Haberman (7):
rebase-i-p: test to exclude commits from todo based on its parents
rebase-i-p: use HEAD for updating the ref instead of mapping OLDHEAD
rebase-i-p: delay saving current-commit to REWRITTEN if squashing
rebase-i-p: fix 'no squashing merges' tripping up non-merges
rebase-i-p: only list commits that require rewriting in todo
rebase-i-p: do not include non-first-parent commits touching UPSTREAM
rebase-i-p: if todo was reordered use HEAD as the rewritten parent
git-rebase--interactive.sh | 131 ++++++++++++++++++----------- t/t3411-rebase-preserve-around-merges.sh | 136 ++++++++++++++++++++++++++++++ 2 files changed, 218 insertions(+), 49 deletions(-) create mode 100644 t/t3411-rebase-preserve-around-merges.sh
PATCH 1/1 rebase-i-p: test to exclude commits from todo based on its parents
The first case was based off a script from Avi Kivity <[email protected]>.
The second case includes a merge-of-a-merge to ensure both are included in todo.
--- t/t3411-rebase-preserve-around-merges.sh | 136 ++++++++++++++++++++++++++++++ 1 files changed, 136 insertions(+), 0 deletions(-) create mode 100644 t/t3411-rebase-preserve-around-merges.sh
t/t3411-rebase-preserve-around-merges.sh new file +136 -0
@@ -0,0 +1,136 @@ +#!/bin/sh +# +# Copyright (c) 2008 Stephen Haberman +# + +test_description='git rebase preserve merges + +This test runs git rebase with and tries to squash a commit from after a merge +to before the merge. +' +. ./test-lib.sh + +# Copy/paste from t3404-rebase-interactive.sh +echo "#!$SHELL_PATH" >fake-editor.sh +cat >> fake-editor.sh <<\EOF +case "$1" in +*/COMMIT_EDITMSG) + test -z "$FAKE_COMMIT_MESSAGE" || echo "$FAKE_COMMIT_MESSAGE" > "$1" + test -z "$FAKE_COMMIT_AMEND" || echo "$FAKE_COMMIT_AMEND" >> "$1" + exit + ;; +esac +test -z "$EXPECT_COUNT" || + test "$EXPECT_COUNT" = $(sed -e '/^#/d' -e '/^$/d' < "$1" | wc -l) || + exit +test -z "$FAKE_LINES" && exit +grep -v '^#' < "$1" > "$1".tmp +rm -f "$1" +cat "$1".tmp +action=pick +for line in $FAKE_LINES; do + case $line in + squash|edit) + action="$line";; + *) + echo sed -n "${line}s/^pick/$action/p" + sed -n "${line}p" < "$1".tmp + sed -n "${line}s/^pick/$action/p" < "$1".tmp >> "$1" + action=pick;; + esac +done +EOF + +test_set_editor "$(pwd)/fake-editor.sh" +chmod a+x fake-editor.sh + +# set up two branches like this: +# +# A1 - B1 - D1 - E1 - F1 +# \ / +# -- C1 -- + +test_expect_success 'setup' ' + touch a && + touch b && + git add a && + git commit -m A1 && + git tag A1 + git add b && + git commit -m B1 && + git tag B1 && + git checkout -b branch && + touch c && + git add c && + git commit -m C1 && + git checkout master && + touch d && + git add d && + git commit -m D1 && + git merge branch && + touch f && + git add f && + git commit -m F1 && + git tag F1 +' + +# Should result in: +# +# A1 - B1 - D2 - E2 +# \ / +# -- C1 -- +# +test_expect_failure 'squash F1 into D1' ' + FAKE_LINES="1 squash 3 2" git rebase -i -p B1 && + test "$(git rev-parse HEAD^2)" = "$(git rev-parse branch)" && + test "$(git rev-parse HEAD~2)" = "$(git rev-parse B1)" && + git tag E2 +' + +# Start with: +# +# A1 - B1 - D2 - E2 +# \ +# G1 ---- L1 ---- M1 +# \ / +# H1 -- J1 -- K1 +# \ / +# -- I1 -- +# +# And rebase G1..M1 onto E2 + +test_expect_failure 'rebase two levels of merge' ' + git checkout -b branch2 A1 && + touch g && + git add g && + git commit -m G1 && + git checkout -b branch3 && + touch h + git add h && + git commit -m H1 && + git checkout -b branch4 && + touch i && + git add i && + git commit -m I1 && + git tag I1 && + git checkout branch3 && + touch j && + git add j && + git commit -m J1 && + git merge I1 --no-commit && + git commit -m K1 && + git tag K1 && + git checkout branch2 && + touch l && + git add l && + git commit -m L1 && + git merge K1 --no-commit && + git commit -m M1 && + GIT_EDITOR=: git rebase -i -p E2 && + test "$(git rev-parse HEAD~3)" = "$(git rev-parse E2)" && + test "$(git rev-parse HEAD~2)" = "$(git rev-parse HEAD^2^2~2)" && + test "$(git rev-parse HEAD^2^1^1)" = "$(git rev-parse HEAD^2^2^1)" +' + +test_done +
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: use HEAD for updating the ref instead of mapping OLDHEAD
If OLDHEAD was reordered in the todo, and its mapped NEWHEAD was used to set the ref, commits reordered after OLDHEAD in the todo would should up as un-committed changes.
--- git-rebase--interactive.sh | 15 +-------------- 1 files changed, 1 insertions(+), 14 deletions(-)
git-rebase--interactive.sh +1 -14
@@ -376,20 +376,7 @@ do_next () { HEADNAME=$(cat "$DOTEST"/head-name) && OLDHEAD=$(cat "$DOTEST"/head) && SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) && - if test -d "$REWRITTEN" - then - test -f "$DOTEST"/current-commit && - current_commit=$(cat "$DOTEST"/current-commit) && - git rev-parse HEAD > "$REWRITTEN"/$current_commit - if test -f "$REWRITTEN"/$OLDHEAD - then - NEWHEAD=$(cat "$REWRITTEN"/$OLDHEAD) - else - NEWHEAD=$OLDHEAD - fi - else - NEWHEAD=$(git rev-parse HEAD) - fi && + NEWHEAD=$(git rev-parse HEAD) && case $HEADNAME in refs/*) message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO)" &&
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: delay saving current-commit to REWRITTEN if squashing
If the current-commit was dumped to REWRITTEN, but then we squash the next commit in to it, we have invalidated the HEAD was just written to REWRITTEN. Instead, append the squash hash to current-commit and save both of them the next time around.
--- git-rebase--interactive.sh | 15 ++++++++++----- 1 files changed, 10 insertions(+), 5 deletions(-)
git-rebase--interactive.sh +10 -5
@@ -170,13 +170,18 @@ pick_one_preserving_merges () { if test -f "$DOTEST"/current-commit then - current_commit=$(cat "$DOTEST"/current-commit) && - git rev-parse HEAD > "$REWRITTEN"/$current_commit && - rm "$DOTEST"/current-commit || - die "Cannot write current commit's replacement sha1" + if [ "$fast_forward" == "t" ] + then + cat "$DOTEST"/current-commit | while read current_commit + do + git rev-parse HEAD > "$REWRITTEN"/$current_commit + done + rm "$DOTEST"/current-commit || + die "Cannot write current commit's replacement sha1" + fi fi - echo $sha1 > "$DOTEST"/current-commit + echo $sha1 >> "$DOTEST"/current-commit # rewrite parents; if none were rewritten, we can fast-forward. new_parents=
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: fix 'no squashing merges' tripping up non-merges
Also only check out the first parent if this commit if not a squash--if it is a squash, we want to explicitly ignore the parent and leave the wc as is, as cherry-pick will apply the squash on top of it.
--- git-rebase--interactive.sh | 14 +++++++++----- 1 files changed, 9 insertions(+), 5 deletions(-)
git-rebase--interactive.sh +9 -5
@@ -219,15 +219,19 @@ pick_one_preserving_merges () { die "Cannot fast forward to $sha1" ;; f) - test "a$1" = a-n && die "Refusing to squash a merge: $sha1" - first_parent=$(expr "$new_parents" : ' \([^ ]*\)') - # detach HEAD to current parent - output git checkout $first_parent 2> /dev/null || - die "Cannot move HEAD to $first_parent" + + if [ "$1" != "-n" ] + then + # detach HEAD to current parent + output git checkout $first_parent 2> /dev/null || + die "Cannot move HEAD to $first_parent" + fi case "$new_parents" in ' '*' '*) + test "a$1" = a-n && die "Refusing to squash a merge: $sha1" + # redo merge author_script=$(get_author_ident_from_commit $sha1) eval "$author_script"
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: only list commits that require rewriting in todo
This is heavily based on Stephan Beyer's git sequencer rewrite of rebase-i-p.
Each commit is still found by rev-list UPSTREAM..HEAD, but a commit is only included in todo if at least one its parents has been marked for rewriting.
--- git-rebase--interactive.sh | 77 +++++++++++++++++++++++++++++-------------- 1 files changed, 52 insertions(+), 25 deletions(-)
git-rebase--interactive.sh +52 -25
@@ -579,18 +579,67 @@ first and then run 'git rebase --continue' again." echo $ONTO > "$REWRITTEN"/$c || die "Could not init rewritten commits" done + # No cherry-pick because our first pass is to determine + # parents to rewrite and skipping dropped commits would + # prematurely end our probe MERGES_OPTION= else - MERGES_OPTION=--no-merges + MERGES_OPTION="--no-merges --cherry-pick" fi SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM) SHORTHEAD=$(git rev-parse --short $HEAD) SHORTONTO=$(git rev-parse --short $ONTO) git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \ - --abbrev=7 --reverse --left-right --cherry-pick \ + --abbrev=7 --reverse --left-right --topo-order \ $UPSTREAM...$HEAD | \ - sed -n "s/^>/pick /p" > "$TODO" + sed -n "s/^>//p" | while read shortsha1 rest + do + if test t != "$PRESERVE_MERGES" + then + echo "pick $shortsha1 $rest" >> "$TODO" + else + sha1=$(git rev-parse $shortsha1) + preserve=t + for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -f2-) + do + if test -f "$REWRITTEN"/$p + then + preserve=f + fi + done + if test f = "$preserve" + then + touch "$REWRITTEN"/$sha1 + echo "pick $shortsha1 $rest" >> "$TODO" + fi + fi + done + + # Watch for commits that been dropped by --cherry-pick + if test t = "$PRESERVE_MERGES" + then + mkdir "$DROPPED" + # Save all non-cherry-picked changes + git rev-list $UPSTREAM...$HEAD --left-right --cherry-pick | \ + sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks + # Now all commits and note which ones are missing in + # not-cherry-picks and hence being dropped + git rev-list $UPSTREAM...$HEAD --left-right | \ + sed -n "s/^>//p" | while read rev + do + if test -f "$REWRITTEN"/$rev -a "$(grep "$rev" "$DOTEST"/not-cherry-picks)" = "" + then + # Use -f2 because if rev-list is telling us this commit is + # not worthwhile, we don't want to track its multiple heads, + # just the history of its first-parent for others that will + # be rebasing on top of it + git rev-list --parents -1 $rev | cut -d' ' -f2 > "$DROPPED"/$rev + cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO" + rm "$REWRITTEN"/$rev + fi + done + fi test -s "$TODO" || echo noop >> "$TODO" cat >> "$TODO" << EOF
@@ -606,28 +655,6 @@ first and then run 'git rebase --continue' again." # EOF - # Watch for commits that been dropped by --cherry-pick - if test t = "$PRESERVE_MERGES" - then - mkdir "$DROPPED" - # drop the --cherry-pick parameter this time - git rev-list $MERGES_OPTION --abbrev-commit \ - --abbrev=7 $UPSTREAM...$HEAD --left-right | \ - sed -n "s/^>//p" | while read rev - do - grep --quiet "$rev" "$TODO" - if [ $? -ne 0 ] - then - # Use -f2 because if rev-list is telling this commit is not - # worthwhile, we don't want to track its multiple heads, - # just the history of its first-parent for others that will - # be rebasing on top of us - full=$(git rev-parse $rev) - git rev-list --parents -1 $rev | cut -d' ' -f2 > "$DROPPED"/$full - fi - done - fi - has_action "$TODO" || die_abort "Nothing to do"
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: do not include non-first-parent commits touching UPSTREAM
This covers an odd boundary case found by Avi Kivity's script where a branch coming off of UPSTREAM is merged into HEAD. Initially it show up in UPSTREAM..HEAD, but technically UPSTREAM is not moving, the rest of head is, so we should not need to rewrite the merge.
This adds a check saying we can keep preserve=t if p=UPSTREAM...unless this is the first first-parent commit in our UPSTREAM..HEAD rev-list, which could very well point to UPSTREAM, but we still need to consider it as rewritten so we start pulling in the rest of the UPSTREAM..HEAD commits that point to it.
--- git-rebase--interactive.sh | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)
git-rebase--interactive.sh +2 -1
@@ -583,6 +583,7 @@ first and then run 'git rebase --continue' again." # parents to rewrite and skipping dropped commits would # prematurely end our probe MERGES_OPTION= + first_after_upstream="$(git rev-list --reverse --first-parent $UPSTREAM..$HEAD | head -n 1)" else MERGES_OPTION="--no-merges --cherry-pick" fi
@@ -603,7 +604,7 @@ first and then run 'git rebase --continue' again." preserve=t for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -f2-) do - if test -f "$REWRITTEN"/$p + if test -f "$REWRITTEN"/$p -a \( $p != $UPSTREAM -o $sha1 = $first_after_upstream \) then preserve=f fi
Signature · 1 line
1.6.0.2
PATCH 1/1 rebase-i-p: if todo was reordered use HEAD as the rewritten parent
This seems like the best guess we can make until git sequencer marks are available. That being said, within the context of re-ordering a commit before its parent in todo, I think applying it on top of the current commit seems like a reasonable assumption of what the user intended.
--- git-rebase--interactive.sh | 9 +++++++++ t/t3411-rebase-preserve-around-merges.sh | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-)
git-rebase--interactive.sh +9 -0
@@ -194,6 +194,15 @@ pick_one_preserving_merges () { if test -f "$REWRITTEN"/$p then new_p=$(cat "$REWRITTEN"/$p) + + # If the todo reordered commits, and our parent is marked for + # rewriting, but hasn't been gotten to yet, assume the user meant to + # drop it on top of the current HEAD + if test -z "$new_p" + then + new_p=$(git rev-parse HEAD) + fi + test $p != $new_p && fast_forward=f case "$new_parents" in *$new_p*)
t/t3411-rebase-preserve-around-merges.sh +2 -2
@@ -80,7 +80,7 @@ test_expect_success 'setup' ' # \ / # -- C1 -- # -test_expect_failure 'squash F1 into D1' ' +test_expect_success 'squash F1 into D1' ' FAKE_LINES="1 squash 3 2" git rebase -i -p B1 && test "$(git rev-parse HEAD^2)" = "$(git rev-parse branch)" && test "$(git rev-parse HEAD~2)" = "$(git rev-parse B1)" &&
@@ -99,7 +99,7 @@ test_expect_failure 'squash F1 into D1' ' # # And rebase G1..M1 onto E2 -test_expect_failure 'rebase two levels of merge' ' +test_expect_success 'rebase two levels of merge' ' git checkout -b branch2 A1 && touch g && git add g &&
Signature · 1 line
1.6.0.2
Re: [PATCH] rebase-i-p: only list commits that require rewriting in todo
In reply to Stephen Habermangit-rebase--interactive.sh first and then run 'git rebase --continue' again." · line 638
Quoted 1 line · Stephen Haberman
git-rebase--interactive.sh +1
-0+ cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO"
Substring expansion (like ${rev:0:7}) is not portable. At least it doesn't work on FreeBSD /bin/sh, and "it's not even in POSIX", I believe.
-Peff
Re: [PATCH] rebase-i-p: only list commits that require rewriting in todo
Quoted 7 lines · Jeff King
Review
Quoted 1 line · Stephen Haberman
(quoted diff) +1
-0+ cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO"Substring expansion (like ${rev:0:7}) is not portable. At least it doesn't work on FreeBSD
/bin/sh, and "it's not even in POSIX", I believe.
True.
I do not remember the individual patches in the series, but I have to say that the script at the tip of the topic is, eh, less than ideal.
Here is a small untested patch to fix a few issues I spotted while reading it for two minutes.
* Why filter output from "rev-list --left-right A...B" and look for the ones that begin with ">"? Wouldn't "rev-list A..B" give that?
* The abbreviated SHA-1 are made with "rev-list --abbrev=7" into $TODO in an earlier invocation, and it can be more than 7 letters to avoid ambiguity. Not just that "${r:0:7} is not even in POSIX", but use of it here is actively wrong.
* There is no point in catting a single file and piping it into grep.
git-rebase--interactive.sh | 7 ++++--- 1 files changed, 4 insertions(+), 3 deletions(-)
git-rebase--interactive.sh +4 -3
@@ -635,8 +635,8 @@ first and then run 'git rebase --continue' again." sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks # Now all commits and note which ones are missing in # not-cherry-picks and hence being dropped - git rev-list $UPSTREAM...$HEAD --left-right | \ - sed -n "s/^>//p" | while read rev + git rev-list $UPSTREAM..$HEAD | + while read rev do if test -f "$REWRITTEN"/$rev -a "$(grep "$rev" "$DOTEST"/not-cherry-picks)" = "" then
@@ -645,7 +645,8 @@ first and then run 'git rebase --continue' again." # just the history of its first-parent for others that will # be rebasing on top of it git rev-list --parents -1 $rev | cut -d' ' -f2 > "$DROPPED"/$rev - cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO" + short=$(git rev-list -1 --abbrev-commit --abbrev=7 $rev) + grep -v "^[a-z][a-z]* $short" <"$TODO" > "${TODO}2" ; mv "${TODO}2" "$TODO" rm "$REWRITTEN"/$rev fi done
Re: [PATCH] rebase-i-p: only list commits that require rewriting in todo
Quoted 9 lines · Junio C Hamano
I do not remember the individual patches in the series, but I have to say that the script at the tip of the topic is, eh, less than ideal.
Here is a small untested patch to fix a few issues I spotted while reading it for two minutes.
* Why filter output from "rev-list --left-right A...B" and look for the ones that begin with ">"? Wouldn't "rev-list A..B" give that?
Quoted 6 lines
* The abbreviated SHA-1 are made with "rev-list --abbrev=7" into $TODO in an earlier invocation, and it can be more than 7 letters to avoid ambiguity. Not just that "${r:0:7} is not even in POSIX", but use of it here is actively wrong.
* There is no point in catting a single file and piping it into grep.
All of those look like sane changes to me (I'll admit that before I didn't even look at the script beyond the breakage on my test box).
-Peff
Re: [PATCH] rebase-i-p: only list commits that require rewriting in todo
In reply to Junio C HamanoQuoted 9 lines
Quoted 7 lines
Quoted 3 lines
+ cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO"
Substring expansion (like ${rev:0:7}) is not portable. At least it doesn't work on FreeBSD
/bin/sh, and "it's not even in POSIX", I believe.True.
Thanks--sorry about that. rev:0:7 was a cute/stupid optimization to avoid an extra git rev-parse call.
Quoted 2 lines
I do not remember the individual patches in the series, but I have to say that the script at the tip of the topic is, eh, less than ideal.
Agreed. The previous dropped commits check was nicer, with just one pass, as todo already had all of the non-dropped of the commits in it.
Now that todo has to include all commits initially to do parent probing, the dropped commits check requires two passes, dropping lines from todo, etc., and is a good deal uglier.
Quoted 5 lines
Here is a small untested patch to fix a few issues I spotted while reading it for two minutes.
* Why filter output from "rev-list --left-right A...B" and look for the ones that begin with ">"? Wouldn't "rev-list A..B" give that?
Oh--right. I was being too careful about keeping the existing rev-list call and only changing what I needed that I didn't step back realize that.
Quoted 4 lines
* The abbreviated SHA-1 are made with "rev-list --abbrev=7" into $TODO in an earlier invocation, and it can be more than 7 letters to avoid ambiguity. Not just that "${r:0:7} is not even in POSIX", but use of it here is actively wrong.
Ah, didn't think of that.
Quoted 1 line
* There is no point in catting a single file and piping it into grep.
Right, right, I've been trying to get out of that habit.
Quoted 16 lines
git-rebase--interactive.sh +2
-2@@ -635,8 +635,8 @@ first and then run 'git rebase --continue' again." sed -n "s/^>//p" > "$DOTEST"/not-cherry-picks # Now all commits and note which ones are missing in # not-cherry-picks and hence being dropped - git rev-list $UPSTREAM...$HEAD --left-right | \ - sed -n "s/^>//p" | while read rev + git rev-list $UPSTREAM..$HEAD | + while read rev do if test -f "$REWRITTEN"/$rev -a "$(grep "$rev" "$DOTEST"/not-cherry-picks)" = "" then
git-rebase--interactive.sh first and then run 'git rebase --continue' again." · line 652
Quoted 9 lines
git-rebase--interactive.sh +2
-1@@ -645,7 +645,8 @@ first and then run 'git rebase --continue' again." # just the history of its first-parent for others that will # be rebasing on top of it git rev-list --parents -1 $rev | cut -d' ' -f2 > "$DROPPED"/$rev - cat "$TODO" | grep -v "${rev:0:7}" > "${TODO}2" ; mv "${TODO}2" "$TODO" + short=$(git rev-list -1 --abbrev-commit --abbrev=7 $rev) + grep -v "^[a-z][a-z]* $short" <"$TODO" > "${TODO}2" ; mv "${TODO}2" "$TODO" rm "$REWRITTEN"/$rev fi done
Looks good--I applied this locally and it passes t3404, t3410, and t3411. Do I need to do anything else with this, e.g. resubmit/append on top of the previous series, or do you have it taken care of?
Thanks for reviewing this, and Jeff too. I appreciate the feedback.
I will be bullish about the use cases I'd like to see work (these preserve merges tweaks and the config setting for git pull), but humble about my patches. This one especially is not elegant, it just passes the tests. I've been re-reading it looking for a better way to do it and nothing is jumping out at me. Let me know if you know of a better approach or would like me to try something else.
Thanks,
Stephen
Re: [PATCH] rebase-i-p: only list commits that require rewriting in todo
Quoted 3 lines · Stephen Haberman
Looks good--I applied this locally and it passes t3404, t3410, and t3411. Do I need to do anything else with this, e.g. resubmit/append on top of the previous series, or do you have it taken care of?
I've queued it on top of your series and merged the result in 'next'. Further improvements should be done the same way.
Quoted 4 lines
I will be bullish about the use cases I'd like to see work (these preserve merges tweaks and the config setting for
git pull), but humble about my patches. This one especially is not elegant, it just passes the tests.
That's perfectly fine. We can start from sound ideas (the behaviour we would want to see) and incrementally improve the implementation.
Thanks.
Re: [PATCH] rebase-i-p: delay saving current-commit to REWRITTEN if squashing
In reply to Stephen Habermangit-rebase--interactive.sh pick_one_preserving_merges () { · line 173
Quoted 1 line · Stephen Haberman
git-rebase--interactive.sh +1
-0+ if [ "$fast_forward" == "t" ]
This one even fails on my Linux box. :) "==" is a bash-ism.
-Peff
Re: [PATCH] rebase-i-p: delay saving current-commit to REWRITTEN if squashing
Quoted 5 lines · Jeff King
Review
Quoted 1 line · Stephen Haberman
(quoted diff) +1
-0+ if [ "$fast_forward" == "t" ]This one even fails on my Linux box. :) "==" is a bash-ism.
Thanks.
-- >8 --
Subject: [PATCH] git-rebase--interactive.sh: comparision with == is bashism
--- git-rebase--interactive.sh | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
git-rebase--interactive.sh +1 -1
@@ -170,7 +170,7 @@ pick_one_preserving_merges () { if test -f "$DOTEST"/current-commit then - if [ "$fast_forward" == "t" ] + if test "$fast_forward" = t then cat "$DOTEST"/current-commit | while read current_commit do
Signature · 1 line
1.6.0.3.723.g757e
Re: [PATCH] rebase-i-p: delay saving current-commit to REWRITTEN if squashing
Quoted 4 lines · Junio C Hamano
Quoted 2 lines
Review
Quoted 1 line
(quoted diff) +1
-0+ if [ "$fast_forward" == "t" ]This one even fails on my Linux box. :) "==" is a bash-ism.
Thanks.
You're very welcome, and sorry for not saving you a little time by writing my complaint in patch form in the first place.
-Peff
Re: [PATCH] rebase-i-p: delay saving current-commit to REWRITTEN if squashing
In reply to Jeff KingHi,
Quoted 5 lines · Jeff King
git-rebase--interactive.sh pick_one_preserving_merges () { · line 173
Quoted 1 line · Stephen Haberman
git-rebase--interactive.sh +1
-0+ if [ "$fast_forward" == "t" ]This one even fails on my Linux box. :) "==" is a bash-ism.
Did we not also prefer "test" to "["?
Ciao,
Dscho
Re: [PATCH] rebase-i-p: delay saving current-commit to REWRITTEN if squashing
Quoted 11 lines · Johannes Schindelin
Hi,
Quoted 5 lines · Jeff King
git-rebase--interactive.sh pick_one_preserving_merges () { · line 173
Quoted 1 line · Stephen Haberman
git-rebase--interactive.sh +1
-0+ if [ "$fast_forward" == "t" ]This one even fails on my Linux box. :) "==" is a bash-ism.
Did we not also prefer "test" to "["?
We did.
Documentation/CodingGuidelines, line 51:
- We prefer "test" over "[ ... ]".
Signature · 2 lines
Kind regards, Fredrik Skolmli