* [PATCH] rebase [-i --exec | -ix] <CMD>... @ 2012-06-04 13:47 Kong Lucien 2012-06-04 17:42 ` Junio C Hamano ` (2 more replies) 0 siblings, 3 replies; 50+ messages in thread From: Kong Lucien @ 2012-06-04 13:47 UTC (permalink / raw) To: git Cc: Kong Lucien, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy This patch provides a way to automatically add these "exec" lines between each commit applications. For instance, running 'git rebase -i --exec "make test"' lets you check that intermediate commits are compilable. At this point, you can't use --exec without the interactive mode (-i). Tests about this new command are also added in t3404-rebase-interactive.sh. Signed-off-by: Kong Lucien <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- Documentation/git-rebase.txt | 43 ++++++++++++++++++++++- git-rebase--interactive.sh | 13 +++++++ git-rebase.sh | 35 +++++++++++++++++-- t/t3404-rebase-interactive.sh | 74 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 159 insertions(+), 6 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..96dbf26 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,6 +210,17 @@ rebase.autosquash:: OPTIONS ------- +<cmd>:: + Shell command executed between each commit applications. The + --exec option has to be specified. ++ +You may execute several commands between each commit applications. +Therefore, you can use one instance of exec: + git rebase -i --exec "cmd1; cmd2; ...". +You can also insert several instances of exec, if you wish to +only have one command per line for example: + git rebase -i --exec "cmd1" --exec "cmd2" ... + <newbase>:: Starting point at which to create the new commits. If the --onto option is not specified, the starting point is @@ -336,6 +347,13 @@ link:howto/revert-a-faulty-merge.txt[revert-a-faulty-merge How-To] for details). user edit that list before rebasing. This mode can also be used to split commits (see SPLITTING COMMITS below). +-x:: +--exec:: + Automatically add "exec" followed by <cmd> between each commit + applications (see INTERACTIVE MODE below). ++ +This has to be used along with the `--interactive` option explicitly. + -p:: --preserve-merges:: Instead of ignoring merges, try to recreate them. @@ -521,6 +539,27 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + +If the option '-i' is missing, The command will return the usage page +of "git rebase". Same if there is no <cmd> specified behind --exec. + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..7444160 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -876,6 +876,19 @@ cat >> "$todo" << EOF # EOF +if test -n "$cmd" +then + OIFS=$IFS + IFS=',' + for i in $cmd + do + sed "/^pick .*/aexec $i" "$todo" >tmp + cat tmp >"$todo" + done + rm tmp + IFS=$OIFS +fi + if test -z "$keep_empty" then echo "# Note that empty commits are commented out" >>"$todo" diff --git a/git-rebase.sh b/git-rebase.sh index 24a2840..a8b1793 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +unset cmd strategy= strategy_opts= do_merge= @@ -219,6 +222,24 @@ do onto="$2" shift ;; + -x) + exec_flag=true + test 3 -le "$#" || usage + if orig_head=$(git rev-parse -q --verify "$2") || + test `expr substr "$2" 1 1` = - + then + echo "You must specify a command after --exec option\n" + usage + else + if test -n "$cmd" + then + cmd="$2,$cmd" + else + cmd="$2" + fi + fi + shift + ;; -i) interactive_rebase=explicit ;; @@ -304,6 +325,13 @@ do done test $# -gt 2 && usage +if test -n "$exec_flag" && + test -z "$interactive_rebase" +then + echo "--exec option must be used with --interactive option\n" + usage +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" @@ -348,7 +376,6 @@ abort) exit ;; esac - # Make sure no rebase is in progress if test -n "$in_progress" then diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..2976f07 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,78 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +test_expect_success 'running "git rebase -i --exec git show HEAD"' ' + 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 && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase --exec git show HEAD -i"' ' + git rebase --exec "git show HEAD" -i HEAD~2 >actual && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase -ix git show HEAD"' ' + git rebase -ix "git show HEAD" HEAD~2 >actual && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several <CMD>' ' + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several instances of --exec' ' + 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 >expected + ) && + sed '1,11d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase --exec without -i shows error message and usage ' ' + test_must_fail git rebase --exec "git show HEAD" HEAD~2 >actual && + echo "--exec option must be used with --interactive option\n" >expected && + test_must_fail git rebase -h >>expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage ' ' + test_must_fail git rebase -i --exec HEAD~2>actual && + echo "You must specify a command after --exec option\n" >expected && + test_must_fail git rebase -h >>expected && + test_cmp expected actual && + git checkout master +' + test_done -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-04 13:47 [PATCH] rebase [-i --exec | -ix] <CMD> Kong Lucien @ 2012-06-04 17:42 ` Junio C Hamano 2012-06-04 20:30 ` Matthieu Moy 2012-06-05 17:59 ` konglu 2012-06-04 17:48 ` Matthieu Moy 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong 2 siblings, 2 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-04 17:42 UTC (permalink / raw) To: Kong Lucien Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Kong Lucien <Lucien.Kong@ensimag.imag.fr> writes: > diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt > index 147fa1a..96dbf26 100644 > --- a/Documentation/git-rebase.txt > +++ b/Documentation/git-rebase.txt > @@ -210,6 +210,17 @@ rebase.autosquash:: > > OPTIONS > ------- > +<cmd>:: > + Shell command executed between each commit applications. The > + --exec option has to be specified. > ++ > +You may execute several commands between each commit applications. > +Therefore, you can use one instance of exec: > + git rebase -i --exec "cmd1; cmd2; ...". > +You can also insert several instances of exec, if you wish to > +only have one command per line for example: > + git rebase -i --exec "cmd1" --exec "cmd2" ... > + The description of this and exisitng <newbase> look very odd. The usual way to describe an option that take a parameter in the OPTIONS section is to instead do: --onto <newbase>:: Description of what --onto option does and how <newbase> is used in what it does. --exec <cmd>:: Description of what --exec option does, and how <cmd> is used in what it does. > @@ -336,6 +347,13 @@ link:howto/revert-a-faulty-me > user edit that list before rebasing. This mode can also be used to > split commits (see SPLITTING COMMITS below). > > +-x:: > +--exec:: > + Automatically add "exec" followed by <cmd> between each commit > + applications (see INTERACTIVE MODE below). > ++ > +This has to be used along with the `--interactive` option explicitly. > + OK. > @@ -521,6 +539,27 @@ in `$SHELL`, or the default shell if > ... > +If the option '-i' is missing, The command will return the usage page > +of "git rebase". Same if there is no <cmd> specified behind --exec. OK. > diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh > index 0c19b7c..7444160 100644 > --- a/git-rebase--interactive.sh > +++ b/git-rebase--interactive.sh > @@ -876,6 +876,19 @@ cat >> "$todo" << EOF > # > EOF > > +if test -n "$cmd" > +then > + OIFS=$IFS > + IFS=',' > + for i in $cmd > + do > + sed "/^pick .*/aexec $i" "$todo" >tmp > + cat tmp >"$todo" > + done > + rm tmp > + IFS=$OIFS > +fi Where does this "we split at comma", implying "the user is forbidden to have a comma in the executed command and its arguments" come from? A more conventional way that would be less troublesome in the real life is to use LF instead in a case like this (and git-rebase.sh already defines it for exactly a case like this). I am not sure if that "aexec" is portable outside GNUism, though. Traditionally the a(ppend) command is spelled like this: [1addr]a\ text to write one line (cf. http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html#tag_20_116_13_03). Why is "pick" special? Don't you want to run the commands after "edit", "reword", "squash", "fixup"? This should come immediately after autosquash rearranged the insns in the $todo file, before the help text is appended to it. > diff --git a/git-rebase.sh b/git-rebase.sh > index 24a2840..a8b1793 100755 > --- a/git-rebase.sh > +++ b/git-rebase.sh > @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". > To check out the original branch and stop rebasing run \"git rebase --abort\". > " > unset onto > +unset cmd > strategy= > strategy_opts= > do_merge= You copied badness from the existing "unset onto"; I do not think the rest of the code (and especially the new code you add) treats a variable that is not set and set to an empty string any different, and setting it to empty is the right thing to do in such a case. > @@ -219,6 +222,24 @@ do > onto="$2" > shift > ;; > + -x) > + exec_flag=true exec_flag is not cleared at the beginning of the script, so if the command is run without "-x" on the command line, it can have whatever garbage value that was in the environment. You know that $cmd is empty if "-x" was not given, and you can make sure $cmd becomes non-empty when "-x" is given, so remove use of this variable and replace any 'test -n "$exec_flag"' with 'test -n "$cmd"'. > + test 3 -le "$#" || usage Why 3? You only care about the presense of $2 you are about to read, no? > + if orig_head=$(git rev-parse -q --verify "$2") || > + test `expr substr "$2" 1 1` = - > + then > + echo "You must specify a command after --exec option\n" > + usage > + else > + if test -n "$cmd" > + then > + cmd="$2,$cmd" > + else > + cmd="$2" > + fi > + fi > + shift > + ;; Are you telling me that I cannot have a branch named "make"? Drop this nonsense, and just write it in a more straightforward way, e.g. -x) test 2 -le "$#" || usage cmd="${cmd:+"$cmd$LF"} $2" shift ;; > -i) > interactive_rebase=explicit > ;; > @@ -304,6 +325,13 @@ do > done > test $# -gt 2 && usage > > +if test -n "$exec_flag" && > + test -z "$interactive_rebase" > +then I think this should be if test -n "$cmd" && test "$interactive_rebase" != explicit then > @@ -348,7 +376,6 @@ abort) > exit > ;; > esac > - > # Make sure no rebase is in progress > if test -n "$in_progress" > then Why? ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-04 17:42 ` Junio C Hamano @ 2012-06-04 20:30 ` Matthieu Moy 2012-06-04 21:06 ` Junio C Hamano 2012-06-05 17:59 ` konglu 1 sibling, 1 reply; 50+ messages in thread From: Matthieu Moy @ 2012-06-04 20:30 UTC (permalink / raw) To: Junio C Hamano Cc: Kong Lucien, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Junio C Hamano <gitster@pobox.com> writes: > The description of this and exisitng <newbase> look very odd. The > usual way to describe an option that take a parameter in the OPTIONS > section is to instead do: > > --onto <newbase>:: > Description of what --onto option does and how <newbase> > is used in what it does. > > --exec <cmd>:: > Description of what --exec option does, and how <cmd> > is used in what it does. (to the authors: you can add a trivial patch to fix the --onto doc, and base your work on it) > Why is "pick" special? Don't you want to run the commands after > "edit", "reword", "squash", "fixup"? I'd actually say you want to run it after a squash/fixup serie only. If the result of --autosquash is pick foo fixup bar fixup boz pick foobar I think you want to rewrite it as pick foo fixup bar fixup boz exec make pick foobar exec make The command is typically used to check that each new commit is OK, but we can forget about the intermediate states as we are precisely getting rid of them. -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-04 20:30 ` Matthieu Moy @ 2012-06-04 21:06 ` Junio C Hamano 0 siblings, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-04 21:06 UTC (permalink / raw) To: Matthieu Moy Cc: Kong Lucien, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> writes: > I'd actually say you want to run it after a squash/fixup serie only. > > If the result of --autosquash is > > pick foo > fixup bar > fixup boz > pick foobar > > I think you want to rewrite it as > > pick foo > fixup bar > fixup boz > exec make > pick foobar > exec make That makes sense. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-04 17:42 ` Junio C Hamano 2012-06-04 20:30 ` Matthieu Moy @ 2012-06-05 17:59 ` konglu 2012-06-05 18:13 ` Junio C Hamano 1 sibling, 1 reply; 50+ messages in thread From: konglu @ 2012-06-05 17:59 UTC (permalink / raw) To: Junio C Hamano Cc: Kong Lucien, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Junio C Hamano <gitster@pobox.com> a écrit : >> + if orig_head=$(git rev-parse -q --verify "$2") || >> + test `expr substr "$2" 1 1` = - >> + then >> + echo "You must specify a command after --exec option\n" >> + usage >> + else >> + if test -n "$cmd" >> + then >> + cmd="$2,$cmd" >> + else >> + cmd="$2" >> + fi >> + fi >> + shift >> + ;; > > Are you telling me that I cannot have a branch named "make"? Drop > this nonsense, and just write it in a more straightforward way, e.g. > > -x) > test 2 -le "$#" || usage > cmd="${cmd:+"$cmd$LF"} $2" > shift > ;; I agree with the fact that the code must not restrain you in naming branches. But shouldn't we keep the "test `expr substr "$2" 1 1` = -" part so that options can't be right after the "--exec" ? ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-05 17:59 ` konglu @ 2012-06-05 18:13 ` Junio C Hamano 0 siblings, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-05 18:13 UTC (permalink / raw) To: konglu Cc: Kong Lucien, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy konglu@minatec.inpg.fr writes: > But shouldn't we keep the "test `expr substr "$2" 1 1` = -" part so that > options can't be right after the "--exec" ? No. We have no reason to forbid users from giving their commands names that begin with "-", and if it is a typo, "exec" machinery will catch it and tell the user "no such command". I do not see any good reason to be clever in the part of the command parsing loop that handles "--exec <cmd>" option. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCH] rebase [-i --exec | -ix] <CMD>... 2012-06-04 13:47 [PATCH] rebase [-i --exec | -ix] <CMD> Kong Lucien 2012-06-04 17:42 ` Junio C Hamano @ 2012-06-04 17:48 ` Matthieu Moy 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong 2 siblings, 0 replies; 50+ messages in thread From: Matthieu Moy @ 2012-06-04 17:48 UTC (permalink / raw) To: Kong Lucien Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Kong Lucien <Lucien.Kong@ensimag.imag.fr> writes: > --- a/Documentation/git-rebase.txt > +++ b/Documentation/git-rebase.txt > @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head > SYNOPSIS > -------- > [verse] > -'git rebase' [-i | --interactive] [options] [--onto <newbase>] > +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] > [<upstream>] [<branch>] > -'git rebase' [-i | --interactive] [options] --onto <newbase> > +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> > --root [<branch>] > 'git rebase' --continue | --skip | --abort > > @@ -210,6 +210,17 @@ rebase.autosquash:: > > OPTIONS > ------- > +<cmd>:: > + Shell command executed between each commit applications. The > + --exec option has to be specified. [...] > +-x:: > +--exec:: That seems weird to have --exec <cmd> specification split into one for --exec, and another for <cmd> ... > +You may execute several commands between each commit applications. > +Therefore, you can use one instance of exec: > + git rebase -i --exec "cmd1; cmd2; ...". s/Therefore/For this/ ? (Therefore = donc in French) > +if test -n "$cmd" > +then > + OIFS=$IFS > + IFS=',' > + for i in $cmd > + do > + sed "/^pick .*/aexec $i" "$todo" >tmp > + cat tmp >"$todo" > + done > + rm tmp Isn't this executed from the top of the workdir? What if the user already has a file named tmp there? > + if test -n "$cmd" > + then > + cmd="$2,$cmd" > + else > + cmd="$2" > + fi What happens when <cmd> contains a comma (e.g. --exec "rm file,with,commas,in,name.txt") ? If you don't allow this case, then you should error out instead of executing a weird behavior silently. Or you can escape the comma and unescape it later, but that may be overkill. > +if test -n "$exec_flag" && > + test -z "$interactive_rebase" > +then > + echo "--exec option must be used with --interactive option\n" > + usage > +fi I'd even skip the "usage" here, as the error message is clear enough (and is much less visible before a page of "usage" output). Just die-ing would be better I think. -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-04 13:47 [PATCH] rebase [-i --exec | -ix] <CMD> Kong Lucien 2012-06-04 17:42 ` Junio C Hamano 2012-06-04 17:48 ` Matthieu Moy @ 2012-06-06 10:34 ` Lucien Kong 2012-06-06 20:03 ` Matthieu Moy ` (4 more replies) 2 siblings, 5 replies; 50+ messages in thread From: Lucien Kong @ 2012-06-06 10:34 UTC (permalink / raw) To: git Cc: Lucien Kong, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy This patch provides a way to automatically add these "exec" lines between each commit applications. For instance, running 'git rebase -i --exec "make test"' lets you check that intermediate commits are compilable. It is also compatible with the option --autosquash. At this point, you can't use --exec without the interactive mode (-i). Tests about this new command are also added in t3404-rebase-interactive.sh. Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- The part of --onto in the documentation is changed to be consistent with the other options. The exec line, when using the option --autosquash, is now only added after the squash/fixup series. Documentation/git-rebase.txt | 54 +++++++++++++++-- git-rebase--interactive.sh | 19 ++++++ git-rebase.sh | 20 ++++++- t/t3404-rebase-interactive.sh | 124 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 207 insertions(+), 10 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..1dd95c4 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,11 +210,29 @@ rebase.autosquash:: OPTIONS ------- -<newbase>:: - Starting point at which to create the new commits. If the - --onto option is not specified, the starting point is - <upstream>. May be any valid commit, and not just an - existing branch name. +-x <cmd>:: +--exec <cmd>:: + Automatically add "exec" followed by <cmd> between each commit + applications. Using this option along with --autosquash adds + the exec line after the squash/fixeup series only. <cmd> + stands for shell commands. The --exec option has to be + specified. (see INTERACTIVE MODE below) ++ +This has to be used along with the `--interactive` option explicitly. +You may execute several commands between each commit applications. +For this, you can use one instance of exec: + git rebase -i --exec "cmd1; cmd2; ...". +You can also insert several instances of exec, if you wish to +only have one command per line for example: + git rebase -i --exec "cmd1" --exec "cmd2" ... + +--onto <newbase>:: + With this option, git rebase takes all commits from <branch>, + that are not in <upstream>, and transplant them on top of + <newbase>. <newbase> is the starting point at which to create + the new commits. If the --onto option is not specified, the + starting point is <upstream>. May be any valid commit, and + not just an existing branch name. + As a special case, you may use "A\...B" as a shortcut for the merge base of A and B if there is exactly one merge base. You can @@ -521,6 +539,28 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + +If the option '-i' is missing, The command will return a message +error. If there is no <cmd> specified behind --exec, the command will +return a message error and the usage page of 'git rebase'. + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..3539afd 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -684,6 +684,23 @@ rearrange_squash () { rm -f "$1.sq" "$1.rearranged" } +# Add commands after a pick or after a squash/fixup serie +# in the todo list. +add_exec_commands () { + OIFS=$IFS + IFS=$LF + for i in $cmd + do + tmp=$(sed "/^pick .*/i\ + exec $i" "$1") + echo "$tmp" >"$1" + tmp=$(sed '1d' "$1") + echo "$tmp" >"$1" + echo "exec $i" >>"$1" + done + IFS=$OIFS +} + case "$action" in continue) # do we have anything to commit? @@ -857,6 +874,8 @@ fi test -s "$todo" || echo noop >> "$todo" test -n "$autosquash" && rearrange_squash "$todo" +test -n "$cmd" && add_exec_commands "$todo" + cat >> "$todo" << EOF # Rebase $shortrevisions onto $shortonto diff --git a/git-rebase.sh b/git-rebase.sh index 24a2840..19ead1a 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +cmd= strategy= strategy_opts= do_merge= @@ -219,6 +222,11 @@ do onto="$2" shift ;; + -x) + test 2 -le "$#" || usage + cmd="${cmd:+"$cmd$LF"} $2" + shift + ;; -i) interactive_rebase=explicit ;; @@ -304,6 +312,12 @@ do done test $# -gt 2 && usage +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option\n" +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..4fe98d5 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,128 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +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"' ' + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase --exec git show HEAD -i"' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase -ix git show HEAD"' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several <CMD>' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several instances of --exec' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,11d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with --autosquash' ' + 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" && + ( + 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 >expected + ) && + sed '1,13d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase --exec without -i shows error message' ' + git reset --hard execute && + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && + echo "--exec option must be used with --interactive option\n" >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' + git reset --hard execute && + test_must_fail git rebase -i --exec 2>actual && + sed '1d' actual >tmp && + mv tmp actual && + test_must_fail git rebase -h >expected && + test_cmp expected actual && + git checkout master +' + test_done -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong @ 2012-06-06 20:03 ` Matthieu Moy 2012-06-06 22:54 ` Junio C Hamano ` (3 subsequent siblings) 4 siblings, 0 replies; 50+ messages in thread From: Matthieu Moy @ 2012-06-06 20:03 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Lucien Kong <Lucien.Kong@ensimag.imag.fr> writes: > @@ -210,11 +210,29 @@ rebase.autosquash:: > > OPTIONS > ------- > -<newbase>:: > - Starting point at which to create the new commits. If the > - --onto option is not specified, the starting point is > - <upstream>. May be any valid commit, and not just an > - existing branch name. > +-x <cmd>:: > +--exec <cmd>:: > + Automatically add "exec" followed by <cmd> between each commit > + applications. Using this option along with --autosquash adds > + the exec line after the squash/fixeup series only. <cmd> > + stands for shell commands. The --exec option has to be > + specified. (see INTERACTIVE MODE below) It would make sense to split that into two patches, one to fix --onto's documentation, and the next one to add --exec. I won't insist on that though (but maybe others will). > ++ > +This has to be used along with the `--interactive` option explicitly. > +You may execute several commands between each commit applications. > +For this, you can use one instance of exec: > + git rebase -i --exec "cmd1; cmd2; ...". > +You can also insert several instances of exec, if you wish to > +only have one command per line for example: > + git rebase -i --exec "cmd1" --exec "cmd2" ... This formats badly in asciidoc (try "make doc" and see the generated HTML). Try this: This has to be used along with the `--interactive` option explicitly. You may execute several commands between each commit applications. For this, you can use one instance of exec: + git rebase -i --exec "cmd1; cmd2; ...". + You can also insert several instances of exec, if you wish to only have one command per line for example: + git rebase -i --exec "cmd1" --exec "cmd2" ... -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong 2012-06-06 20:03 ` Matthieu Moy @ 2012-06-06 22:54 ` Junio C Hamano 2012-06-07 8:25 ` Zbigniew Jędrzejewski-Szmek ` (2 subsequent siblings) 4 siblings, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-06 22:54 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Lucien Kong <Lucien.Kong@ensimag.imag.fr> writes: > The part of --onto in the documentation is changed to be consistent > with the other options. The exec line, when using the option --autosquash, > is now only added after the squash/fixup series. Thanks. Inserting "exec" before each "pick" and then adjusting the result (i.e. removing the very first one and adding one at the end) is a clever idea. I wonder if that can be done without temporary variable whose value can grow to be a large string, though. Queued, but I've tweaked the log message a bit before queuing. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong 2012-06-06 20:03 ` Matthieu Moy 2012-06-06 22:54 ` Junio C Hamano @ 2012-06-07 8:25 ` Zbigniew Jędrzejewski-Szmek 2012-06-07 8:40 ` Johannes Sixt 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong 4 siblings, 0 replies; 50+ messages in thread From: Zbigniew Jędrzejewski-Szmek @ 2012-06-07 8:25 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 06/06/2012 12:34 PM, Lucien Kong wrote: > This patch provides a way to automatically add these "exec" lines > between each commit applications. For instance, running 'git rebase -i > --exec "make test"' lets you check that intermediate commits are > compilable. It is also compatible with the option --autosquash. At > this point, you can't use --exec without the interactive mode (-i). > > Tests about this new command are also added in > t3404-rebase-interactive.sh. > > Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> > Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> > Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> > Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> > Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> > Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> > --- > The part of --onto in the documentation is changed to be consistent > with the other options. The exec line, when using the option --autosquash, > is now only added after the squash/fixup series. > > Documentation/git-rebase.txt | 54 +++++++++++++++-- > git-rebase--interactive.sh | 19 ++++++ > git-rebase.sh | 20 ++++++- > t/t3404-rebase-interactive.sh | 124 +++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 207 insertions(+), 10 deletions(-) > > diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt > index 147fa1a..1dd95c4 100644 > --- a/Documentation/git-rebase.txt > +++ b/Documentation/git-rebase.txt > @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head > SYNOPSIS > -------- > [verse] > -'git rebase' [-i | --interactive] [options] [--onto <newbase>] > +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] > [<upstream>] [<branch>] > -'git rebase' [-i | --interactive] [options] --onto <newbase> > +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> > --root [<branch>] > 'git rebase' --continue | --skip | --abort > > @@ -210,11 +210,29 @@ rebase.autosquash:: > > OPTIONS > ------- > -<newbase>:: > - Starting point at which to create the new commits. If the > - --onto option is not specified, the starting point is > - <upstream>. May be any valid commit, and not just an > - existing branch name. > +-x <cmd>:: > +--exec <cmd>:: > + Automatically add "exec" followed by <cmd> between each commit > + applications. Using this option along with --autosquash adds > + the exec line after the squash/fixeup series only. <cmd> > + stands for shell commands. The --exec option has to be > + specified. (see INTERACTIVE MODE below) Hi, this still doesn't seem right: - "exec" is added *after* other lines, not *between* - --exec is not mandatory Maybe something along these lines: -x <cmd>:: --exec <cmd>:: Append "exec <cmd>" after each commit application line. <cmd> will be interpreted as one or more shell commands. + If --autosquash is used, the "exec" lines will not be appended for the intermediate commits, and will only appear at the end of each squash/fixup series. > ++ > +This has to be used along with the `--interactive` option explicitly. This sentence is very unclear. (E.g. is 'this'?) > +You may execute several commands between each commit applications. > +For this, you can use one instance of exec: > + git rebase -i --exec "cmd1; cmd2; ...". > +You can also insert several instances of exec, if you wish to > +only have one command per line for example: > + git rebase -i --exec "cmd1" --exec "cmd2" ... s/per line for example/per line. For example/ ? > + > +--onto <newbase>:: > + With this option, git rebase takes all commits from <branch>, > + that are not in <upstream>, and transplant them on top of > + <newbase>. <newbase> is the starting point at which to create > + the new commits. If the --onto option is not specified, the > + starting point is <upstream>. May be any valid commit, and > + not just an existing branch name. Shouldn't this chunk be a separate patch? s/transplant/transplants/ -- Zbyszek ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong ` (2 preceding siblings ...) 2012-06-07 8:25 ` Zbigniew Jędrzejewski-Szmek @ 2012-06-07 8:40 ` Johannes Sixt 2012-06-07 12:04 ` konglu 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong 4 siblings, 1 reply; 50+ messages in thread From: Johannes Sixt @ 2012-06-07 8:40 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Am 06.06.2012 12:34, schrieb Lucien Kong: > This patch provides a way to automatically add these "exec" lines > between each commit applications. For instance, running 'git rebase -i > --exec "make test"' lets you check that intermediate commits are > compilable. While I won't be a heavy user of this feature, I think it has some merit as a porcelain feature, particularly because it is rather cumbersome to achieve the same effect as in the given example without plumbing commands. > +-x <cmd>:: > +--exec <cmd>:: ... > ++ > +This has to be used along with the `--interactive` option explicitly. ... > + > +If the option '-i' is missing, The command will return a message > +error. If there is no <cmd> specified behind --exec, the command will > +return a message error and the usage page of 'git rebase'. The important part (that -x needs -i) of this paragraph are already spelled out above, and the exact error behavior does not need a description in the manual. Drop this paragraph. BTW, I don't think it is a good idea to dump the usage if -x was used without -i. > +# Add commands after a pick or after a squash/fixup serie > +# in the todo list. > +add_exec_commands () { > + OIFS=$IFS > + IFS=$LF > + for i in $cmd > + do > + tmp=$(sed "/^pick .*/i\ > + exec $i" "$1") Does this white-space before 'exec' not end up in the todo list? I think it is wise to use introduce sed expressions by using -e. This applies to all 'sed' invocations that this patch introduces (also in the test-suite). > + echo "$tmp" >"$1" Some 'echo' implementations expand escape sequences in the supplied texts. To avoid it (this is user-supplied text!), do this: printf "%s\n" "$tmp" >"$1" > + tmp=$(sed '1d' "$1") > + echo "$tmp" >"$1" > + echo "exec $i" >>"$1" Ditto. > + done > + IFS=$OIFS > +} > + -x) > + test 2 -le "$#" || usage > + cmd="${cmd:+"$cmd$LF"} $2" The quoting here is *very* odd. The outer dquotes do extend their effect into the replacement word after the :+ operator. I am surprised that so many shells grok it. ash does not, by the way. Also, you don't need the space anymore. Therefore: cmd="${cmd:+$cmd$LF}$2" > + shift > + ;; > +test_expect_success 'running "git rebase -i --exec git show HEAD"' ' > + 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 >expected > + ) && > + sed '1,9d' expected >expect && Here and everywhere else: Single quotes do not nest :-) use dquotes (and -e). > + mv expect expected && Why not ( ... git rebase ... >expect ) && sed -e ... expect >expected && without the mv? You could even line up the commands in a pipeline, but since the first one contains a git command, it is better not to do that because breakage of the git command would not be detected if it is not the last command in the pipeline. > +test_expect_success 'rebase --exec without -i shows error message' ' > + git reset --hard execute && > + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && > + echo "--exec option must be used with --interactive option\n" >expected && > + test_cmp expected actual Sooner or later this text will be translated. Therefore: test_i18ncmp ... -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-07 8:40 ` Johannes Sixt @ 2012-06-07 12:04 ` konglu 2012-06-07 13:43 ` Matthieu Moy 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-07 12:04 UTC (permalink / raw) To: Johannes Sixt Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Johannes Sixt <j6t@kdbg.org> a écrit : > BTW, I don't think it is a good idea to dump the usage if -x was used > without -i. In fact, that would be the next step, so that the "--exec" option could be used without the interactive mode. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv2] rebase [-i --exec | -ix] <CMD>... 2012-06-07 12:04 ` konglu @ 2012-06-07 13:43 ` Matthieu Moy 0 siblings, 0 replies; 50+ messages in thread From: Matthieu Moy @ 2012-06-07 13:43 UTC (permalink / raw) To: konglu Cc: Johannes Sixt, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen konglu@minatec.inpg.fr writes: > Johannes Sixt <j6t@kdbg.org> a écrit : > >> BTW, I don't think it is a good idea to dump the usage if -x was used >> without -i. > > In fact, that would be the next step, so that the "--exec" option could > be used without the interactive mode. I think Jeff meant that a short error message would be better than showing the complete usage instruction, which indeed is already the case: +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option\n" +fi -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong ` (3 preceding siblings ...) 2012-06-07 8:40 ` Johannes Sixt @ 2012-06-08 14:53 ` Lucien Kong 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong ` (2 more replies) 4 siblings, 3 replies; 50+ messages in thread From: Lucien Kong @ 2012-06-08 14:53 UTC (permalink / raw) To: git Cc: Lucien Kong, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy The description of the option "--onto" is changed to be consistent with the format of the other options. Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- Documentation/git-rebase.txt | 12 +++++++----- 1 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..d2a510c 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -210,11 +210,13 @@ rebase.autosquash:: OPTIONS ------- -<newbase>:: - Starting point at which to create the new commits. If the - --onto option is not specified, the starting point is - <upstream>. May be any valid commit, and not just an - existing branch name. +--onto <newbase>:: + With this option, git rebase takes all commits from <branch>, + that are not in <upstream>, and transplants them on top of + <newbase>. <newbase is the starting point at which to create + the new commits. If the --onto option is not specified, the + starting point is <upstream>. May be any valid commit, and + not just an existing branch name. + As a special case, you may use "A\...B" as a shortcut for the merge base of A and B if there is exactly one merge base. You can -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong @ 2012-06-08 14:53 ` Lucien Kong 2012-06-08 17:02 ` Johannes Sixt ` (2 more replies) 2012-06-08 15:00 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Matthieu Moy 2012-06-08 17:07 ` Junio C Hamano 2 siblings, 3 replies; 50+ messages in thread From: Lucien Kong @ 2012-06-08 14:53 UTC (permalink / raw) To: git Cc: Lucien Kong, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy This patch provides a way to automatically add these "exec" lines between each commit applications. For instance, running 'git rebase -i --exec "make test"' lets you check that intermediate commits are compilable. It is also compatible with the option --autosquash. At this point, you can't use --exec without the interactive mode (-i). Tests about this new command are also added in t3404-rebase-interactive.sh. Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- Should now work on MacOS. Documentation/git-rebase.txt | 43 ++++++++++++++- git-rebase--interactive.sh | 18 ++++++ git-rebase.sh | 20 ++++++- t/t3404-rebase-interactive.sh | 118 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 194 insertions(+), 5 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index d2a510c..866b451 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,6 +210,27 @@ rebase.autosquash:: OPTIONS ------- +-x <cmd>:: +--exec <cmd>:: + Append "exec <cmd>" after each commit application line. <cmd> + will be interpreted as one or more shell commands (see + INTERACTIVE MODE below). ++ +This option has to be used along with the `--interactive` option +explicitly. You may execute several commands between each commit +applications. For this, you can use one instance of exec: ++ + git rebase -i --exec "cmd1; cmd2; ...". ++ +You can also insert several instances of exec, if you wish to only +have one command per line. For example: ++ + git rebase -i --exec "cmd1" --exec "cmd2" ... ++ +If --autosquash is used, the "exec" lines will not be appended for the +intermediate commits, and will only appear at the end of each +squash/fixup series. + --onto <newbase>:: With this option, git rebase takes all commits from <branch>, that are not in <upstream>, and transplants them on top of @@ -523,6 +544,24 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..7bbef4b 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -684,6 +684,22 @@ rearrange_squash () { rm -f "$1.sq" "$1.rearranged" } +# Add commands after a pick or after a squash/fixup serie +# in the todo list. +add_exec_commands () { + OIFS=$IFS + IFS=$LF + for i in $cmd + do + sed -e "/^pick .*/i\\ +exec $i" "$1" >"$1.exec" + sed -e '1d' "$1.exec" >"$1" + printf "%s\n" "exec $i" >>"$1" + done + IFS=$OIFS + rm -f "$1.exec" +} + case "$action" in continue) # do we have anything to commit? @@ -857,6 +873,8 @@ fi test -s "$todo" || echo noop >> "$todo" test -n "$autosquash" && rearrange_squash "$todo" +test -n "$cmd" && add_exec_commands "$todo" + cat >> "$todo" << EOF # Rebase $shortrevisions onto $shortonto diff --git a/git-rebase.sh b/git-rebase.sh index 24a2840..04dbf74 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +cmd= strategy= strategy_opts= do_merge= @@ -219,6 +222,11 @@ do onto="$2" shift ;; + -x) + test 2 -le "$#" || usage + cmd="${cmd:+$cmd$LF}$2" + shift + ;; -i) interactive_rebase=explicit ;; @@ -304,6 +312,12 @@ do done test $# -gt 2 && usage +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option\n" +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..ba953ab 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,122 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +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"' ' + 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 && + 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 '1,9d' expect >expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase -ix git show HEAD"' ' + git reset --hard execute && + 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 '1,9d' expect >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several <CMD>' ' + git reset --hard execute && + 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 '1,9d' expect >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several instances of --exec' ' + git reset --hard execute && + 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 '1,11d' expect >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with --autosquash' ' + 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" && + ( + 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 '1,13d' expect >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase --exec without -i shows error message' ' + git reset --hard execute && + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && + echo "--exec option must be used with --interactive option\n" >expected && + test_i18ncmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' + git reset --hard execute && + test_must_fail git rebase -i --exec 2>actual && + sed '1d' actual >tmp && + mv tmp actual && + test_must_fail git rebase -h >expected && + test_cmp expected actual && + git checkout master +' + test_done -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong @ 2012-06-08 17:02 ` Johannes Sixt 2012-06-08 18:56 ` Torsten Bögershausen 2012-06-10 10:44 ` [PATCHv4] " Lucien Kong 2 siblings, 0 replies; 50+ messages in thread From: Johannes Sixt @ 2012-06-08 17:02 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Am 08.06.2012 16:53, schrieb Lucien Kong: > +if test -n "$cmd" && > + test "$interactive_rebase" != explicit > +then > + die "--exec option must be used with --interactive option\n" > +fi Is the \n really necessary? > + sed -e "1,9d" expect >expected && Good. But I said "Here and everywhere else". So I wonder about these lines ;) > + sed '1,9d' expect >expected && > + sed '1,9d' expect >expected && > + sed '1,9d' expect >expected && > + sed '1,11d' expect >expected && > + sed '1,13d' expect >expected && > + sed '1d' actual >tmp && -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong 2012-06-08 17:02 ` Johannes Sixt @ 2012-06-08 18:56 ` Torsten Bögershausen 2012-06-08 19:15 ` konglu 2012-06-10 10:44 ` [PATCHv4] " Lucien Kong 2 siblings, 1 reply; 50+ messages in thread From: Torsten Bögershausen @ 2012-06-08 18:56 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 08.06.12 16:53, Lucien Kong wrote: > This patch provides a way to automatically add these "exec" lines > between each commit applications. For instance, running 'git rebase -i > --exec "make test"' lets you check that intermediate commits are > compilable. It is also compatible with the option --autosquash. At > this point, you can't use --exec without the interactive mode (-i). > > Tests about this new command are also added in > t3404-rebase-interactive.sh. > Should now work on MacOS. Hej, I'm not sure on which commit to apply the patch. (may be we shoud improve git format-patch to tell us the original commit ID), but if I remove the non applying part, it looks like this: ================= ok 54 - rebase-i history with funny messages expecting success: 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 Switched to branch 'master' Switched to a new branch 'execute' [execute 925b01e] one_exec Author: A U Thor <author@example.com> 1 file changed, 1 insertion(+) create mode 100644 main.txt [execute 7f87cbe] two_exec Author: A U Thor <author@example.com> 1 file changed, 1 insertion(+), 1 deletion(-) [execute f0f177e] three_exec Author: A U Thor <author@example.com> 1 file changed, 1 insertion(+), 1 deletion(-) ok 55 - prepare for rebase -i --exec expecting success: 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 >expected ) && sed 1,9d expected >expect && mv expect expected && test_cmp expected actual error: unknown option `exec' usage: git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] or: git rebase [-i] [options] --onto <newbase> --root [<branch>] or: git-rebase [-i] --continue | --abort | --skip Available options are -v, --verbose display a diffstat of what changed upstream -q, --quiet be quiet. implies --no-stat --onto ... rebase onto given branch instead of upstream -p, --preserve-merges try to recreate merges instead of ignoring them -s, --strategy ... use the given merge strategy --no-ff cherry-pick all commits, even if unchanged -m, --merge use merging strategies to rebase -i, --interactive let the user edit the list of commits to rebase -k, --keep-empty preserve empty commits during rebase -f, --force-rebase force rebase even if branch is up to date -X, --strategy-option ... pass the argument through to the merge strategy --stat display a diffstat of what changed upstream -n, --no-stat do not show diffstat of what changed upstream --verify allow pre-rebase hook to run --rerere-autoupdate allow rerere to update index with resolved conflicts --root rebase all reachable commits up to the root(s) --autosquash move commits that begin with squash!/fixup! under -i --committer-date-is-author-date passed to 'git am' --ignore-date passed to 'git am' --whitespace ... passed to 'git apply' --ignore-whitespace passed to 'git apply' -C ... passed to 'git apply' Actions: --continue continue --abort abort and check out the original branch --skip skip current patch and continue not ok - 56 running "git rebase -i --exec git show HEAD" # # 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 >expected # ) && # sed 1,9d expected >expect && # mv expect expected && # test_cmp expected actual # expecting success: git reset --hard execute && 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 >expected ) && sed 1,9d expected >expect && mv expect expected && test_cmp expected actual HEAD is now at f0f177e three_exec error: unknown option `exec' usage: git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] or: git rebase [-i] [options] --onto <newbase> --root [<branch>] or: git-rebase [-i] --continue | --abort | --skip Available options are -v, --verbose display a diffstat of what changed upstream -q, --quiet be quiet. implies --no-stat --onto ... rebase onto given branch instead of upstream -p, --preserve-merges try to recreate merges instead of ignoring them -s, --strategy ... use the given merge strategy --no-ff cherry-pick all commits, even if unchanged -m, --merge use merging strategies to rebase -i, --interactive let the user edit the list of commits to rebase -k, --keep-empty preserve empty commits during rebase -f, --force-rebase force rebase even if branch is up to date -X, --strategy-option ... pass the argument through to the merge strategy --stat display a diffstat of what changed upstream -n, --no-stat do not show diffstat of what changed upstream --verify allow pre-rebase hook to run --rerere-autoupdate allow rerere to update index with resolved conflicts --root rebase all reachable commits up to the root(s) --autosquash move commits that begin with squash!/fixup! under -i --committer-date-is-author-date passed to 'git am' --ignore-date passed to 'git am' --whitespace ... passed to 'git apply' --ignore-whitespace passed to 'git apply' -C ... passed to 'git apply' Actions: --continue continue --abort abort and check out the original branch --skip skip current patch and continue not ok - 57 running "git rebase --exec git show HEAD -i" ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 18:56 ` Torsten Bögershausen @ 2012-06-08 19:15 ` konglu 2012-06-08 19:55 ` Torsten Bögershausen 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-08 19:15 UTC (permalink / raw) To: Torsten Bögershausen Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Torsten Bögershausen <tboegi@web.de> a écrit : > On 08.06.12 16:53, Lucien Kong wrote: >> This patch provides a way to automatically add these "exec" lines >> between each commit applications. For instance, running 'git rebase -i >> --exec "make test"' lets you check that intermediate commits are >> compilable. It is also compatible with the option --autosquash. At >> this point, you can't use --exec without the interactive mode (-i). >> >> Tests about this new command are also added in >> t3404-rebase-interactive.sh. > >> Should now work on MacOS. > > Hej, > I'm not sure on which commit to apply the patch. > (may be we shoud improve git format-patch to tell us the original commit ID), > but if I remove the non applying part, it looks like this: Which part does not apply ? If you skip the part that's implementing the exec option, of course Git will not recognize it. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 19:15 ` konglu @ 2012-06-08 19:55 ` Torsten Bögershausen 2012-06-08 20:07 ` konglu 0 siblings, 1 reply; 50+ messages in thread From: Torsten Bögershausen @ 2012-06-08 19:55 UTC (permalink / raw) To: konglu Cc: Torsten Bögershausen, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 08.06.12 21:15, konglu@minatec.inpg.fr wrote: > > Torsten Bögershausen <tboegi@web.de> a écrit : > Which part does not apply ? If you skip the part that's implementing the > exec option, of course Git will not recognize it. Hej, 2 questions: a) Where should it apply ? I tried to apply it on commit f623ca1cae600e97cb0b38131fdd33e4fb669cf8 b) Does the line from my log "error: unknown option `exec'" tell us anything? /Torsten ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 19:55 ` Torsten Bögershausen @ 2012-06-08 20:07 ` konglu 2012-06-08 20:51 ` Torsten Bögershausen 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-08 20:07 UTC (permalink / raw) To: Torsten Bögershausen Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Torsten Bögershausen <tboegi@web.de> a écrit : > On 08.06.12 21:15, konglu@minatec.inpg.fr wrote: >> >> Torsten Bögershausen <tboegi@web.de> a écrit : > >> Which part does not apply ? If you skip the part that's implementing the >> exec option, of course Git will not recognize it. > > > Hej, > 2 questions: > a) Where should it apply ? > I tried to apply it on commit f623ca1cae600e97cb0b38131fdd33e4fb669cf8 I just tried to apply it on that commit and it works for me. What's the error message ? > b) Does the line from my log > "error: unknown option `exec'" > tell us anything? Yes, that the patch was not applied ^^'. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 20:07 ` konglu @ 2012-06-08 20:51 ` Torsten Bögershausen 2012-06-08 21:03 ` konglu 0 siblings, 1 reply; 50+ messages in thread From: Torsten Bögershausen @ 2012-06-08 20:51 UTC (permalink / raw) To: konglu Cc: Torsten Bögershausen, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 08.06.12 22:07, konglu@minatec.inpg.fr wrote: > > Torsten Bögershausen <tboegi@web.de> a écrit : > >> On 08.06.12 21:15, konglu@minatec.inpg.fr wrote: >>> >>> Torsten Bögershausen <tboegi@web.de> a écrit : >> >>> Which part does not apply ? If you skip the part that's implementing the >>> exec option, of course Git will not recognize it. >> >> >> Hej, >> 2 questions: >> a) Where should it apply ? >> I tried to apply it on commit f623ca1cae600e97cb0b38131fdd33e4fb669cf8 > > I just tried to apply it on that commit and it works for me. What's the > error message ? > >> b) Does the line from my log >> "error: unknown option `exec'" >> tell us anything? > > Yes, that the patch was not applied ^^'. ------------------------------------------------ That's the outcome, if I try to re-apply it: Applying: Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... error: patch failed: Documentation/git-rebase.txt:210 error: Documentation/git-rebase.txt: patch does not apply Patch failed at 0001 Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... When you have resolved this problem run "git am --resolved". If you would prefer to skip this patch, instead run "git am --skip". To restore the original branch and stop patching run "git am --abort". ===================== And after my fumbling, the diff looks like this (see below). It seems that something changed, because the error line is different- Sorry if I messed something up here, it looks as if the functionality implementing the "exec" is missing in my code base. For me it looks as if I only picked up the test cases, and I'm missing something. In this case it would be helpful if you just re-send the patch to my email, and I can try to re-do the patch based on f623ca1cae600e97cb0b38, or whatever you specify. Does that makes sense? /Torsten ------------------------ git diff f623ca1cae600e97cb0b38..63884a991c9d8 ================================================= diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..1dd95c4 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,11 +210,29 @@ rebase.autosquash:: OPTIONS ------- -<newbase>:: - Starting point at which to create the new commits. If the - --onto option is not specified, the starting point is - <upstream>. May be any valid commit, and not just an - existing branch name. +-x <cmd>:: +--exec <cmd>:: + Automatically add "exec" followed by <cmd> between each commit + applications. Using this option along with --autosquash adds + the exec line after the squash/fixeup series only. <cmd> + stands for shell commands. The --exec option has to be + specified. (see INTERACTIVE MODE below) ++ +This has to be used along with the `--interactive` option explicitly. +You may execute several commands between each commit applications. +For this, you can use one instance of exec: + git rebase -i --exec "cmd1; cmd2; ...". +You can also insert several instances of exec, if you wish to +only have one command per line for example: + git rebase -i --exec "cmd1" --exec "cmd2" ... + +--onto <newbase>:: + With this option, git rebase takes all commits from <branch>, + that are not in <upstream>, and transplant them on top of + <newbase>. <newbase> is the starting point at which to create + the new commits. If the --onto option is not specified, the + starting point is <upstream>. May be any valid commit, and + not just an existing branch name. + As a special case, you may use "A\...B" as a shortcut for the merge base of A and B if there is exactly one merge base. You can @@ -521,6 +539,28 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + +If the option '-i' is missing, The command will return a message +error. If there is no <cmd> specified behind --exec, the command will +return a message error and the usage page of 'git rebase'. + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..dc9e7e9 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -684,6 +684,22 @@ rearrange_squash () { rm -f "$1.sq" "$1.rearranged" } +# Add commands after a pick or after a squash/fixup serie +# in the todo list. +add_exec_commands () { + OIFS=$IFS + IFS=$LF + for i in $cmd + do + tmp=$(sed "/^pick .*/i\exec $i" "$1") + echo "$tmp" >"$1" + tmp=$(sed '1d' "$1") + echo "$tmp" >"$1" + echo "exec $i" >>"$1" + done + IFS=$OIFS +} + case "$action" in continue) # do we have anything to commit? @@ -857,6 +873,8 @@ fi test -s "$todo" || echo noop >> "$todo" test -n "$autosquash" && rearrange_squash "$todo" +test -n "$cmd" && add_exec_commands "$todo" + cat >> "$todo" << EOF # Rebase $shortrevisions onto $shortonto diff --git a/git-rebase.sh b/git-rebase.sh index e616737..87b21e3 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +cmd= strategy= strategy_opts= do_merge= @@ -220,6 +223,11 @@ do onto="$2" shift ;; + -x) + test 2 -le "$#" || usage + cmd="${cmd:+"$cmd$LF"} $2" + shift + ;; -i) interactive_rebase=explicit ;; @@ -305,6 +313,12 @@ do done test $# -gt 2 && usage +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option\n" +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..4fe98d5 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,128 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +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"' ' + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase --exec git show HEAD -i"' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'running "git rebase -ix git show HEAD"' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several <CMD>' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,9d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with several instances of --exec' ' + git reset --hard execute && + 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 >expected + ) && + sed '1,11d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -ix with --autosquash' ' + 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" && + ( + 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 >expected + ) && + sed '1,13d' expected >expect && + mv expect expected && + test_cmp expected actual +' + + +test_expect_success 'rebase --exec without -i shows error message' ' + git reset --hard execute && + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && + echo "--exec option must be used with --interactive option\n" >expected && + test_cmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' + git reset --hard execute && + test_must_fail git rebase -i --exec 2>actual && + sed '1d' actual >tmp && + mv tmp actual && + test_must_fail git rebase -h >expected && + test_cmp expected actual && + git checkout master +' + test_done ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 20:51 ` Torsten Bögershausen @ 2012-06-08 21:03 ` konglu 2012-06-09 6:14 ` Torsten Bögershausen 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-08 21:03 UTC (permalink / raw) To: Torsten Bögershausen Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Torsten Bögershausen <tboegi@web.de> a écrit : > On 08.06.12 22:07, konglu@minatec.inpg.fr wrote: >> >> Torsten Bögershausen <tboegi@web.de> a écrit : >> >>> On 08.06.12 21:15, konglu@minatec.inpg.fr wrote: >>>> >>>> Torsten Bögershausen <tboegi@web.de> a écrit : >>> >>>> Which part does not apply ? If you skip the part that's implementing the >>>> exec option, of course Git will not recognize it. >>> >>> >>> Hej, >>> 2 questions: >>> a) Where should it apply ? >>> I tried to apply it on commit f623ca1cae600e97cb0b38131fdd33e4fb669cf8 >> >> I just tried to apply it on that commit and it works for me. What's the >> error message ? >> >>> b) Does the line from my log >>> "error: unknown option `exec'" >>> tell us anything? >> >> Yes, that the patch was not applied ^^'. > ------------------------------------------------ > That's the outcome, if I try to re-apply it: > Applying: Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... > error: patch failed: Documentation/git-rebase.txt:210 > error: Documentation/git-rebase.txt: patch does not apply > Patch failed at 0001 Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... > When you have resolved this problem run "git am --resolved". > If you would prefer to skip this patch, instead run "git am --skip". > To restore the original branch and stop patching run "git am --abort". Did you first apply the first part [PATCHv3 1/2] of the patch ? Lucien Kong. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-08 21:03 ` konglu @ 2012-06-09 6:14 ` Torsten Bögershausen 2012-06-09 6:47 ` konglu 0 siblings, 1 reply; 50+ messages in thread From: Torsten Bögershausen @ 2012-06-09 6:14 UTC (permalink / raw) To: konglu Cc: Torsten Bögershausen, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 08.06.12 23:03, konglu@minatec.inpg.fr wrote: > > Torsten Bögershausen <tboegi@web.de> a écrit : > >> On 08.06.12 22:07, konglu@minatec.inpg.fr wrote: >>> >>> Torsten Bögershausen <tboegi@web.de> a écrit : >>> >>>> On 08.06.12 21:15, konglu@minatec.inpg.fr wrote: >>>>> >>>>> Torsten Bögershausen <tboegi@web.de> a écrit : >>>> >>>>> Which part does not apply ? If you skip the part that's implementing the >>>>> exec option, of course Git will not recognize it. >>>> >>>> >>>> Hej, >>>> 2 questions: >>>> a) Where should it apply ? >>>> I tried to apply it on commit f623ca1cae600e97cb0b38131fdd33e4fb669cf8 >>> >>> I just tried to apply it on that commit and it works for me. What's the >>> error message ? >>> >>>> b) Does the line from my log >>>> "error: unknown option `exec'" >>>> tell us anything? >>> >>> Yes, that the patch was not applied ^^'. >> ------------------------------------------------ >> That's the outcome, if I try to re-apply it: >> Applying: Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... >> error: patch failed: Documentation/git-rebase.txt:210 >> error: Documentation/git-rebase.txt: patch does not apply >> Patch failed at 0001 Fwd: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... >> When you have resolved this problem run "git am --resolved". >> If you would prefer to skip this patch, instead run "git am --skip". >> To restore the original branch and stop patching run "git am --abort". > > Did you first apply the first part [PATCHv3 1/2] of the patch ? > > Lucien Kong. Hej, I have 2 patches with the headline "[PATCHv3 1/2" in my in box. None of them is dealing in any kind with upgrading a command to understand "exec". To be able to test under Mac OS it could be helpful if you just re-send one patch to my email. Then I can try to re-do the patch based on f623ca1cae600e97cb0b38 and test it under Mac OS. Does that makes sense? /Torsten ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD>... 2012-06-09 6:14 ` Torsten Bögershausen @ 2012-06-09 6:47 ` konglu 0 siblings, 0 replies; 50+ messages in thread From: konglu @ 2012-06-09 6:47 UTC (permalink / raw) To: Torsten Bögershausen Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Torsten Bögershausen <tboegi@web.de> a écrit : > Hej, > I have 2 patches with the headline "[PATCHv3 1/2" in my in box. > None of them is dealing in any kind with upgrading a command to > understand "exec". Here you can see the thread of the discussion: http://thread.gmane.org/gmane.comp.version-control.git/199497 > To be able to test under Mac OS it could be helpful if you just re-send > one patch to my email. > Then I can try to re-do the patch based on f623ca1cae600e97cb0b38 and > test it under Mac OS. Alright, gonna send you the patch in one part so that it can be applied alone :). Lucien Kong ^ permalink raw reply [flat|nested] 50+ messages in thread
* [PATCHv4] rebase [-i --exec | -ix] <CMD>... 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong 2012-06-08 17:02 ` Johannes Sixt 2012-06-08 18:56 ` Torsten Bögershausen @ 2012-06-10 10:44 ` Lucien Kong 2012-06-10 11:56 ` Johannes Sixt 2012-06-12 8:05 ` [PATCHv5] " Lucien Kong 2 siblings, 2 replies; 50+ messages in thread From: Lucien Kong @ 2012-06-10 10:44 UTC (permalink / raw) To: git Cc: tboegi, Lucien Kong, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy This patch provides a way to automatically add these "exec" lines between each commit applications. For instance, running 'git rebase -i --exec "make test"' lets you check that intermediate commits are compilable. It is also compatible with the option --autosquash. At this point, you can't use --exec without the interactive mode (-i). Tests about this new command are also added in t3404-rebase-interactive.sh. Helped-by: Johannes Sixt <j6t@kdbg.org> Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- The change in git-rebase.txt about the option --onto was done in another patch. This patch can be applied independently. Documentation/git-rebase.txt | 43 ++++++++++++++- git-rebase--interactive.sh | 23 ++++++++ git-rebase.sh | 20 ++++++- t/t3404-rebase-interactive.sh | 118 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 199 insertions(+), 5 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..a2f1514 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,6 +210,27 @@ rebase.autosquash:: OPTIONS ------- +-x <cmd>:: +--exec <cmd>:: + Append "exec <cmd>" after each commit application line. <cmd> + will be interpreted as one or more shell commands (see + INTERACTIVE MODE below). ++ +This option has to be used along with the `--interactive` option +explicitly. You may execute several commands between each commit +applications. For this, you can use one instance of exec: ++ + git rebase -i --exec "cmd1; cmd2; ...". ++ +You can also insert several instances of exec, if you wish to only +have one command per line. For example: ++ + git rebase -i --exec "cmd1" --exec "cmd2" ... ++ +If --autosquash is used, the "exec" lines will not be appended for the +intermediate commits, and will only appear at the end of each +squash/fixup series. + <newbase>:: Starting point at which to create the new commits. If the --onto option is not specified, the starting point is @@ -521,6 +542,24 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..5f56672 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -684,6 +684,27 @@ rearrange_squash () { rm -f "$1.sq" "$1.rearranged" } +# Add commands after a pick or after a squash/fixup serie +# in the todo list. +add_exec_commands () { + { + first=t + while read -r insn rest + do + case $insn in + pick) + test -n "$first" || + printf "%s" "$cmd" + ;; + esac + printf "%s %s\n" "$insn" "$rest" + first= + done + printf "%s" "$cmd" + } <"$1" >"$1.new" && + mv "$1.new" "$1" +} + case "$action" in continue) # do we have anything to commit? @@ -857,6 +878,8 @@ fi test -s "$todo" || echo noop >> "$todo" test -n "$autosquash" && rearrange_squash "$todo" +test -n "$cmd" && add_exec_commands "$todo" + cat >> "$todo" << EOF # Rebase $shortrevisions onto $shortonto diff --git a/git-rebase.sh b/git-rebase.sh index 24a2840..2952bc0 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +cmd= strategy= strategy_opts= do_merge= @@ -219,6 +222,11 @@ do onto="$2" shift ;; + -x) + test 2 -le "$#" || usage + cmd="${cmd}exec $2${LF}" + shift + ;; -i) interactive_rebase=explicit ;; @@ -304,6 +312,12 @@ do done test $# -gt 2 && usage +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option" +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..600519c 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,122 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +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"' ' + 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 && + 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 && + 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 && + 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 && + 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 +' + + +test_expect_success 'rebase -ix with --autosquash' ' + 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" && + ( + 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 +' + + +test_expect_success 'rebase --exec without -i shows error message' ' + git reset --hard execute && + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && + echo "--exec option must be used with --interactive option" >expected && + test_i18ncmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' + git reset --hard execute && + test_must_fail git rebase -i --exec 2>actual && + sed '1d' actual >tmp && + mv tmp actual && + test_must_fail git rebase -h >expected && + test_cmp expected actual && + git checkout master +' + test_done -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv4] rebase [-i --exec | -ix] <CMD>... 2012-06-10 10:44 ` [PATCHv4] " Lucien Kong @ 2012-06-10 11:56 ` Johannes Sixt 2012-06-11 15:14 ` Junio C Hamano 2012-06-12 8:05 ` [PATCHv5] " Lucien Kong 1 sibling, 1 reply; 50+ messages in thread From: Johannes Sixt @ 2012-06-10 11:56 UTC (permalink / raw) To: Lucien Kong Cc: git, tboegi, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Am 10.06.2012 12:44, schrieb Lucien Kong: > +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' > + git reset --hard execute && > + test_must_fail git rebase -i --exec 2>actual && > + sed '1d' actual >tmp && > + mv tmp actual && > + test_must_fail git rebase -h >expected && > + test_cmp expected actual && > + git checkout master > +' IMO, it is more important to check that the error message is present rather than whether the usage blurb is correct. But since the error is generated by the option parsing machinery, it is probably sufficient to check *only* for failure, and don't verify the output at all. Then change the headline of the text to the neutral test_expect_success 'rebase -i --exec without <CMD>' ' And, BTW, next time I point out that sed 'xy'... should be changed to sed -e "xy"... you review *ALL* sed commands you introduce, not just those that I point out, OK? And, BTW, when I point out that ...>expected && sed <expected >expect && mv expect expected should be ...>expect && sed <expect >expected, you extrapolate *yourself* that the same pattern applies even if the files are named "tmp" and "actual", OK? That's expected from thoughtful contributors. -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv4] rebase [-i --exec | -ix] <CMD>... 2012-06-10 11:56 ` Johannes Sixt @ 2012-06-11 15:14 ` Junio C Hamano 2012-06-12 18:55 ` Johannes Sixt 0 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-11 15:14 UTC (permalink / raw) To: Johannes Sixt Cc: Lucien Kong, git, tboegi, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Johannes Sixt <j6t@kdbg.org> writes: > Am 10.06.2012 12:44, schrieb Lucien Kong: >> +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' >> + git reset --hard execute && >> + test_must_fail git rebase -i --exec 2>actual && >> + sed '1d' actual >tmp && >> + mv tmp actual && >> + test_must_fail git rebase -h >expected && >> + test_cmp expected actual && >> + git checkout master >> +' > > IMO, it is more important to check that the error message is present > rather than whether the usage blurb is correct. But since the error is > generated by the option parsing machinery, it is probably sufficient to > check *only* for failure, and don't verify the output at all. > > Then change the headline of the text to the neutral > > test_expect_success 'rebase -i --exec without <CMD>' ' Makes sense; thanks for a thoughtful suggestion. > And, BTW, next time I point out that sed 'xy'... should be changed to > sed -e "xy"... you review *ALL* sed commands you introduce, not just > those that I point out, OK? > > And, BTW, when I point out that ...>expected && sed <expected >expect && > mv expect expected should be ...>expect && sed <expect >expected, you > extrapolate *yourself* that the same pattern applies even if the files > are named "tmp" and "actual", OK? > > That's expected from thoughtful contributors. > > -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv4] rebase [-i --exec | -ix] <CMD>... 2012-06-11 15:14 ` Junio C Hamano @ 2012-06-12 18:55 ` Johannes Sixt 2012-06-12 20:29 ` Junio C Hamano 0 siblings, 1 reply; 50+ messages in thread From: Johannes Sixt @ 2012-06-12 18:55 UTC (permalink / raw) To: Junio C Hamano Cc: Lucien Kong, git, tboegi, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Am 11.06.2012 17:14, schrieb Junio C Hamano: > Johannes Sixt <j6t@kdbg.org> writes: > >> Am 10.06.2012 12:44, schrieb Lucien Kong: >>> +test_expect_success 'rebase -i --exec without <CMD> shows error message and usage' ' >>> + git reset --hard execute && >>> + test_must_fail git rebase -i --exec 2>actual && >>> + sed '1d' actual >tmp && >>> + mv tmp actual && >>> + test_must_fail git rebase -h >expected && >>> + test_cmp expected actual && >>> + git checkout master >>> +' >> >> IMO, it is more important to check that the error message is present >> rather than whether the usage blurb is correct. But since the error is >> generated by the option parsing machinery, it is probably sufficient to >> check *only* for failure, and don't verify the output at all. I changed my mind. If option parsing regresses in such a way that --exec suddenly works without command, then the 'test_must_fail git rebase ...' could pass because there is a failure much later in the rebase process, which we would not detect if we do not check the output. It is therefore good to check whether the expected failure happens during option parsing. Checking the usage blurb rather than the error message even has advantages: it is immune to changes of the error messages and to i18n poisoning. In this light, the version you have queued is fine. -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv4] rebase [-i --exec | -ix] <CMD>... 2012-06-12 18:55 ` Johannes Sixt @ 2012-06-12 20:29 ` Junio C Hamano 0 siblings, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-12 20:29 UTC (permalink / raw) To: Johannes Sixt Cc: Lucien Kong, git, tboegi, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Johannes Sixt <j6t@kdbg.org> writes: > Checking the usage blurb rather than the error message even has > advantages: it is immune to changes of the error messages and to i18n > poisoning. Yes, to a degree. There is no guarantee that the error message stays on a single line in a particular l10n ;-). > In this light, the version you have queued is fine. ^ permalink raw reply [flat|nested] 50+ messages in thread
* [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-10 10:44 ` [PATCHv4] " Lucien Kong 2012-06-10 11:56 ` Johannes Sixt @ 2012-06-12 8:05 ` Lucien Kong 2012-06-12 9:23 ` Zbigniew Jędrzejewski-Szmek 1 sibling, 1 reply; 50+ messages in thread From: Lucien Kong @ 2012-06-12 8:05 UTC (permalink / raw) To: git Cc: Lucien Kong, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy This patch provides a way to automatically add these "exec" lines between each commit applications. For instance, running 'git rebase -i --exec "make test"' lets you check that intermediate commits are compilable. It is also compatible with the option --autosquash. At this point, you can't use --exec without the interactive mode (-i). Tests about this new command are also added in t3404-rebase-interactive.sh. Helped-by: Johannes Sixt <j6t@kdbg.org> Signed-off-by: Lucien Kong <Lucien.Kong@ensimag.imag.fr> Signed-off-by: Valentin Duperray <Valentin.Duperray@ensimag.imag.fr> Signed-off-by: Franck Jonas <Franck.Jonas@ensimag.imag.fr> Signed-off-by: Thomas Nguy <Thomas.Nguy@ensimag.imag.fr> Signed-off-by: Huynh Khoi Nguyen Nguyen <Huynh-Khoi-Nguyen.Nguyen@ensimag.imag.fr> Signed-off-by: Matthieu Moy <Matthieu.Moy@grenoble-inp.fr> --- The last test is changed to be consistent with the other (thanks Johannes for reviewing the code). Documentation/git-rebase.txt | 43 ++++++++++++++- git-rebase--interactive.sh | 23 ++++++++ git-rebase.sh | 20 ++++++- t/t3404-rebase-interactive.sh | 117 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 198 insertions(+), 5 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 147fa1a..a2f1514 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -8,9 +8,9 @@ git-rebase - Forward-port local commits to the updated upstream head SYNOPSIS -------- [verse] -'git rebase' [-i | --interactive] [options] [--onto <newbase>] +'git rebase' [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] -'git rebase' [-i | --interactive] [options] --onto <newbase> +'git rebase' [-i | --interactive] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] 'git rebase' --continue | --skip | --abort @@ -210,6 +210,27 @@ rebase.autosquash:: OPTIONS ------- +-x <cmd>:: +--exec <cmd>:: + Append "exec <cmd>" after each commit application line. <cmd> + will be interpreted as one or more shell commands (see + INTERACTIVE MODE below). ++ +This option has to be used along with the `--interactive` option +explicitly. You may execute several commands between each commit +applications. For this, you can use one instance of exec: ++ + git rebase -i --exec "cmd1; cmd2; ...". ++ +You can also insert several instances of exec, if you wish to only +have one command per line. For example: ++ + git rebase -i --exec "cmd1" --exec "cmd2" ... ++ +If --autosquash is used, the "exec" lines will not be appended for the +intermediate commits, and will only appear at the end of each +squash/fixup series. + <newbase>:: Starting point at which to create the new commits. If the --onto option is not specified, the starting point is @@ -521,6 +542,24 @@ in `$SHELL`, or the default shell if `$SHELL` is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree. +---------------------------------- +$ git rebase -i --exec "make test" +---------------------------------- + +This command lets you check that intermediate commits are compilable. +The todo list becomes like that: + +-------------------- +pick 5928aea one +exec make test +pick 04d0fda two +exec make test +pick ba46169 three +exec make test +pick f4593f9 four +exec make test +-------------------- + SPLITTING COMMITS ----------------- diff --git a/git-rebase--interactive.sh b/git-rebase--interactive.sh index 0c19b7c..5f56672 100644 --- a/git-rebase--interactive.sh +++ b/git-rebase--interactive.sh @@ -684,6 +684,27 @@ rearrange_squash () { rm -f "$1.sq" "$1.rearranged" } +# Add commands after a pick or after a squash/fixup serie +# in the todo list. +add_exec_commands () { + { + first=t + while read -r insn rest + do + case $insn in + pick) + test -n "$first" || + printf "%s" "$cmd" + ;; + esac + printf "%s %s\n" "$insn" "$rest" + first= + done + printf "%s" "$cmd" + } <"$1" >"$1.new" && + mv "$1.new" "$1" +} + case "$action" in continue) # do we have anything to commit? @@ -857,6 +878,8 @@ fi test -s "$todo" || echo noop >> "$todo" test -n "$autosquash" && rearrange_squash "$todo" +test -n "$cmd" && add_exec_commands "$todo" + cat >> "$todo" << EOF # Rebase $shortrevisions onto $shortonto diff --git a/git-rebase.sh b/git-rebase.sh index 24a2840..2952bc0 100755 --- a/git-rebase.sh +++ b/git-rebase.sh @@ -3,7 +3,8 @@ # Copyright (c) 2005 Junio C Hamano. # -USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' +USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f] + [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]' LONG_USAGE='git-rebase replaces <branch> with a new branch of the same name. When the --onto option is provided the new branch starts out with a HEAD equal to <newbase>, otherwise it is equal to <upstream> @@ -30,8 +31,8 @@ Example: git-rebase master~1 topic SUBDIRECTORY_OK=Yes OPTIONS_KEEPDASHDASH= OPTIONS_SPEC="\ -git rebase [-i] [options] [--onto <newbase>] [<upstream>] [<branch>] -git rebase [-i] [options] --onto <newbase> --root [<branch>] +git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] +git rebase [-i] [options] [--exec <cmd>] --onto <newbase> --root [<branch>] git-rebase [-i] --continue | --abort | --skip -- Available options are @@ -43,6 +44,7 @@ s,strategy=! use the given merge strategy no-ff! cherry-pick all commits, even if unchanged m,merge! use merging strategies to rebase i,interactive! let the user edit the list of commits to rebase +x,exec=! add exec lines after each commit of the editable list k,keep-empty preserve empty commits during rebase f,force-rebase! force rebase even if branch is up to date X,strategy-option=! pass the argument through to the merge strategy @@ -76,6 +78,7 @@ If you would prefer to skip this patch, instead run \"git rebase --skip\". To check out the original branch and stop rebasing run \"git rebase --abort\". " unset onto +cmd= strategy= strategy_opts= do_merge= @@ -219,6 +222,11 @@ do onto="$2" shift ;; + -x) + test 2 -le "$#" || usage + cmd="${cmd}exec $2${LF}" + shift + ;; -i) interactive_rebase=explicit ;; @@ -304,6 +312,12 @@ do done test $# -gt 2 && usage +if test -n "$cmd" && + test "$interactive_rebase" != explicit +then + die "--exec option must be used with --interactive option" +fi + if test -n "$action" then test -z "$in_progress" && die "No rebase in progress?" diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh index 025c1c6..68d6148 100755 --- a/t/t3404-rebase-interactive.sh +++ b/t/t3404-rebase-interactive.sh @@ -755,4 +755,121 @@ test_expect_success 'rebase-i history with funny messages' ' test_cmp expect actual ' + +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"' ' + 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 && + 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 && + 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 && + 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 && + 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 +' + + +test_expect_success 'rebase -ix with --autosquash' ' + 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" && + ( + 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 +' + + +test_expect_success 'rebase --exec without -i shows error message' ' + git reset --hard execute && + test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual && + echo "--exec option must be used with --interactive option" >expected && + test_i18ncmp expected actual +' + + +test_expect_success 'rebase -i --exec without <CMD>' ' + git reset --hard execute && + test_must_fail git rebase -i --exec 2>tmp && + sed -e "1d" tmp >actual && + test_must_fail git rebase -h >expected && + test_cmp expected actual && + git checkout master +' + test_done -- 1.7.8 ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-12 8:05 ` [PATCHv5] " Lucien Kong @ 2012-06-12 9:23 ` Zbigniew Jędrzejewski-Szmek 2012-06-12 14:46 ` Junio C Hamano 0 siblings, 1 reply; 50+ messages in thread From: Zbigniew Jędrzejewski-Szmek @ 2012-06-12 9:23 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 06/12/2012 10:05 AM, Lucien Kong wrote: > +-x <cmd>:: > +--exec <cmd>:: > + Append "exec <cmd>" after each commit application line. <cmd> > + will be interpreted as one or more shell commands (see > + INTERACTIVE MODE below). > ++ > +This option has to be used along with the `--interactive` option > +explicitly. You may execute several commands between each commit > +applications. For this, you can use one instance of exec: Hi, this is still grammatically fishy, and has "between each commit applications", which was corrected above, but not here. > + git rebase -i --exec "cmd1; cmd2; ...". > ++ > +You can also insert several instances of exec, if you wish to only > +have one command per line. For example: s/instances of exec/instances of --exec/ > + git rebase -i --exec "cmd1" --exec "cmd2" ... > ++ > +If --autosquash is used, the "exec" lines will not be appended for the > +intermediate commits, and will only appear at the end of each > +squash/fixup series. > + Zbyszek ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-12 9:23 ` Zbigniew Jędrzejewski-Szmek @ 2012-06-12 14:46 ` Junio C Hamano 2012-06-13 14:04 ` Zbigniew Jędrzejewski-Szmek 0 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-12 14:46 UTC (permalink / raw) To: Zbigniew Jędrzejewski-Szmek Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> writes: > On 06/12/2012 10:05 AM, Lucien Kong wrote: >> +-x <cmd>:: >> +--exec <cmd>:: >> + Append "exec <cmd>" after each commit application line. <cmd> >> + will be interpreted as one or more shell commands (see >> + INTERACTIVE MODE below). >> ++ >> +This option has to be used along with the `--interactive` option >> +explicitly. You may execute several commands between each commit >> +applications. For this, you can use one instance of exec: > Hi, > > this is still grammatically fishy, and has "between each commit > applications", which was corrected above, but not here. Not just grammo, but "between" is not correct, as there will be the final test after the last "pick". >> + git rebase -i --exec "cmd1; cmd2; ...". >> ++ >> +You can also insert several instances of exec, if you wish to only >> +have one command per line. For example: > s/instances of exec/instances of --exec/ Not just that, in the explanation part, we tend to spell `--exec` to make the part that needs to be literally typed stand out (also we want to see dash-dash, not em-dash, in the formatted output). >> + git rebase -i --exec "cmd1" --exec "cmd2" ... >> ++ >> +If --autosquash is used, the "exec" lines will not be appended for the >> +intermediate commits, and will only appear at the end of each >> +squash/fixup series. >> + Same for `--autosquash`. I do not think it is worth another round of resend at this point, so please eyeball the version I fixed up and queued in 'pu' when it is pushed out. I also moved the '-x <cmd>::' option description to where it belongs (iow, not at the very beginning). ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-12 14:46 ` Junio C Hamano @ 2012-06-13 14:04 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 17:32 ` Junio C Hamano 2012-06-13 18:05 ` konglu 0 siblings, 2 replies; 50+ messages in thread From: Zbigniew Jędrzejewski-Szmek @ 2012-06-13 14:04 UTC (permalink / raw) To: Junio C Hamano Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 06/12/2012 04:46 PM, Junio C Hamano wrote: > I do not think it is worth another round of resend at this point, so > please eyeball the version I fixed up and queued in 'pu' when it is > pushed out. I also moved the '-x <cmd>::' option description to > where it belongs (iow, not at the very beginning). Hi, I think some small changes are still in order. Please consider squashing this in: -----8<------ Subject: [PATCH] squash! rebase -i: teach "--exec <cmd>" In the commit message: s/each runs/each run/ Fixup to the documentation part: - Use the phrase "after each commit in the final history" from Junio's commit message to replace "each commit application". The latter is awkward and not really true. - Reorder paragraphs and reword the one about --interactive. Make the part about two forms of exec less verbose. - Replace ';' with '&&' in the example. This (a) makes the two examples equivalent, and (b) encourages good practice that we try to follow in git tests to never fail silently. People are likely to copy the example verbatim. --- Documentation/git-rebase.txt | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 048da64..179ab77 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -346,22 +346,23 @@ idea unless you know what you are doing (see BUGS below). -x <cmd>:: --exec <cmd>:: - Append "exec <cmd>" after each commit application line. <cmd> - will be interpreted as one or more shell commands (see - INTERACTIVE MODE below). + Append "exec <cmd>" after each line creating a commit in the + final history. <cmd> will be interpreted as one or more shell + commands. + -This option has to be used along with the `--interactive` option -explicitly. You may execute several commands after each commit -application. For this, you can use one instance of `--exec`: +This option can only be used with the `--interactive` option +(see INTERACTIVE MODE below). + - git rebase -i --exec "cmd1; cmd2; ...". +You may execute several commands by either using one instance of `--exec` +with several commands: + -You can also insert several instances of `--exec`, if you wish to only -have one command per line. For example: + git rebase -i --exec "cmd1 && cmd2 && ..." + - git rebase -i --exec "cmd1" --exec "cmd2" ... +or equivalently by giving more than one `--exec`: + -If `--autosquash` is used, the "exec" lines will not be appended for + git rebase -i --exec "cmd1" --exec "cmd2" --exec ... ++ +If `--autosquash` is used, "exec" lines will not be appended for the intermediate commits, and will only appear at the end of each squash/fixup series. -- 1.7.11.rc3.129.ga90bc7a.dirty -----8<------ Zbyszek ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 14:04 ` Zbigniew Jędrzejewski-Szmek @ 2012-06-13 17:32 ` Junio C Hamano 2012-06-13 18:05 ` konglu 1 sibling, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-13 17:32 UTC (permalink / raw) To: Zbigniew Jędrzejewski-Szmek Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> writes: > On 06/12/2012 04:46 PM, Junio C Hamano wrote: >> I do not think it is worth another round of resend at this point, so >> please eyeball the version I fixed up and queued in 'pu' when it is >> pushed out. I also moved the '-x <cmd>::' option description to >> where it belongs (iow, not at the very beginning). > > Hi, > I think some small changes are still in order. Please consider > squashing this in: > > -----8<------ > Subject: [PATCH] squash! rebase -i: teach "--exec <cmd>" > > In the commit message: s/each runs/each run/ > > Fixup to the documentation part: > - Use the phrase "after each commit in the final history" from Junio's > commit message to replace "each commit application". The latter is > awkward and not really true. > - Reorder paragraphs and reword the one about --interactive. > Make the part about two forms of exec less verbose. > - Replace ';' with '&&' in the example. This (a) makes the two > examples equivalent, and (b) encourages good practice that we try > to follow in git tests to never fail silently. People are likely > to copy the example verbatim. Looks sensible; Lucien, opinions? > Documentation/git-rebase.txt | 23 ++++++++++++----------- > 1 file changed, 12 insertions(+), 11 deletions(-) > > diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt > index 048da64..179ab77 100644 > --- a/Documentation/git-rebase.txt > +++ b/Documentation/git-rebase.txt > @@ -346,22 +346,23 @@ idea unless you know what you are doing (see BUGS > below). > > -x <cmd>:: > --exec <cmd>:: > - Append "exec <cmd>" after each commit application line. <cmd> > - will be interpreted as one or more shell commands (see > - INTERACTIVE MODE below). > + Append "exec <cmd>" after each line creating a commit in the > + final history. <cmd> will be interpreted as one or more shell > + commands. > + > -This option has to be used along with the `--interactive` option > -explicitly. You may execute several commands after each commit > -application. For this, you can use one instance of `--exec`: > +This option can only be used with the `--interactive` option > +(see INTERACTIVE MODE below). > + > - git rebase -i --exec "cmd1; cmd2; ...". > +You may execute several commands by either using one instance of `--exec` > +with several commands: > + > -You can also insert several instances of `--exec`, if you wish to only > -have one command per line. For example: > + git rebase -i --exec "cmd1 && cmd2 && ..." > + > - git rebase -i --exec "cmd1" --exec "cmd2" ... > +or equivalently by giving more than one `--exec`: > + > -If `--autosquash` is used, the "exec" lines will not be appended for > + git rebase -i --exec "cmd1" --exec "cmd2" --exec ... > ++ > +If `--autosquash` is used, "exec" lines will not be appended for > the intermediate commits, and will only appear at the end of each > squash/fixup series. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 14:04 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 17:32 ` Junio C Hamano @ 2012-06-13 18:05 ` konglu 2012-06-13 18:22 ` Junio C Hamano 1 sibling, 1 reply; 50+ messages in thread From: konglu @ 2012-06-13 18:05 UTC (permalink / raw) To: Zbigniew Jędrzejewski-Szmek Cc: Junio C Hamano, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> a écrit : > On 06/12/2012 04:46 PM, Junio C Hamano wrote: >> I do not think it is worth another round of resend at this point, so >> please eyeball the version I fixed up and queued in 'pu' when it is >> pushed out. I also moved the '-x <cmd>::' option description to >> where it belongs (iow, not at the very beginning). > > Hi, > I think some small changes are still in order. Please consider > squashing this in: > > -----8<------ > Subject: [PATCH] squash! rebase -i: teach "--exec <cmd>" > > In the commit message: s/each runs/each run/ > > Fixup to the documentation part: > - Use the phrase "after each commit in the final history" from Junio's > commit message to replace "each commit application". The latter is > awkward and not really true. After reading again the sentence, I find that the new expression is more appropriate when it comes to the "--autosquash" case (here, "in the final history" is clearer than "application"). Thus, the new formulation seems good to me. > - Reorder paragraphs and reword the one about --interactive. > Make the part about two forms of exec less verbose. Less verbose and avoid some repetitions. But... > +You may execute several commands by either using one instance of `--exec` > +with several commands: > + > -You can also insert several instances of `--exec`, if you wish to only > -have one command per line. For example: > + git rebase -i --exec "cmd1 && cmd2 && ..." > + > - git rebase -i --exec "cmd1" --exec "cmd2" ... > +or equivalently by giving more than one `--exec`: ...I'm against using "equivalently" as in the first case, all the commands are on one line, and in the second case, each commands have its line, thus easier for the user to manipulate them independently. > - Replace ';' with '&&' in the example. This (a) makes the two > examples equivalent, and (b) encourages good practice that we try > to follow in git tests to never fail silently. People are likely > to copy the example verbatim. Why not. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 18:05 ` konglu @ 2012-06-13 18:22 ` Junio C Hamano 2012-06-13 19:38 ` konglu 0 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-13 18:22 UTC (permalink / raw) To: konglu Cc: Zbigniew Jędrzejewski-Szmek, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy konglu@minatec.inpg.fr writes: >> +You may execute several commands by either using one instance of `--exec` >> +with several commands: >> + >> -You can also insert several instances of `--exec`, if you wish to only >> -have one command per line. For example: >> + git rebase -i --exec "cmd1 && cmd2 && ..." >> + >> - git rebase -i --exec "cmd1" --exec "cmd2" ... >> +or equivalently by giving more than one `--exec`: > > ...I'm against using "equivalently" as in the first case, all the commands > are on one line, and in the second case, each commands have its line, thus > easier for the user to manipulate them independently. It looks that editing pick foo pick foo exec cmd1 exec cmd1 && cmd2 exec cmd2 pick bar pick bar exec cmd1 exec cmd1 && cmd2 exec cmd2 to pick foo pick foo exec cmd2 exec cmd2 pick bar pick bar exec cmd1 exec cmd1 would take exactly the same effort, at least to me. And more importantly, without editing don't they do *exactly* the same thing? If cmd1 fails, the sequencing stops at that step without running cmd2. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 18:22 ` Junio C Hamano @ 2012-06-13 19:38 ` konglu 2012-06-13 20:59 ` Johannes Sixt 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-13 19:38 UTC (permalink / raw) To: Junio C Hamano Cc: Zbigniew J?drzejewski-Szmek, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Junio C Hamano <gitster@pobox.com> a écrit : > It looks that editing > > pick foo pick foo > exec cmd1 exec cmd1 && cmd2 > exec cmd2 > pick bar pick bar > exec cmd1 exec cmd1 && cmd2 > exec cmd2 > > to > > pick foo pick foo > exec cmd2 > exec cmd2 > pick bar pick bar > exec cmd1 exec cmd1 > > would take exactly the same effort, at least to me. And more > importantly, without editing don't they do *exactly* the same thing? > If cmd1 fails, the sequencing stops at that step without running cmd2. True. I was thinking under the fact that the user would edit the commands by himself but the purpose of the "--exec" option is to avoid that (or at least that the user won't have to type all by himself). Forget what I said then :). ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 19:38 ` konglu @ 2012-06-13 20:59 ` Johannes Sixt 2012-06-13 21:07 ` Zbigniew Jędrzejewski-Szmek ` (2 more replies) 0 siblings, 3 replies; 50+ messages in thread From: Johannes Sixt @ 2012-06-13 20:59 UTC (permalink / raw) To: konglu Cc: Junio C Hamano, Zbigniew J?drzejewski-Szmek, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Am 13.06.2012 21:38, schrieb konglu@minatec.inpg.fr: > > Junio C Hamano <gitster@pobox.com> a écrit : > >> It looks that editing >> >> pick foo pick foo >> exec cmd1 exec cmd1 && cmd2 >> exec cmd2 >> pick bar pick bar >> exec cmd1 exec cmd1 && cmd2 >> exec cmd2 >> >> to >> >> pick foo pick foo >> exec cmd2 >> exec cmd2 >> pick bar pick bar >> exec cmd1 exec cmd1 >> >> would take exactly the same effort, at least to me. And more >> importantly, without editing don't they do *exactly* the same thing? >> If cmd1 fails, the sequencing stops at that step without running cmd2. > > True. I was thinking under the fact that the user would edit the commands > by himself but the purpose of the "--exec" option is to avoid that (or at > least that the user won't have to type all by himself). Forget what I said > then :). Not so fast. exec cmd1 && cmd2 and exec cmd1 exec cmd2 are far from equivalent: If cmd1 fails, the first version never runs cmd2, but the second version runs cmd2 upon rebase --continue. The updated documentation should not say that the two are "equivalent". -- Hannes ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 20:59 ` Johannes Sixt @ 2012-06-13 21:07 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 22:25 ` Junio C Hamano 2012-06-13 22:35 ` Junio C Hamano 2 siblings, 0 replies; 50+ messages in thread From: Zbigniew Jędrzejewski-Szmek @ 2012-06-13 21:07 UTC (permalink / raw) To: Johannes Sixt Cc: konglu, Junio C Hamano, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 06/13/2012 10:59 PM, Johannes Sixt wrote: > Am 13.06.2012 21:38, schrieb konglu@minatec.inpg.fr: >> >> Junio C Hamano <gitster@pobox.com> a écrit : >> >>> It looks that editing >>> >>> pick foo pick foo >>> exec cmd1 exec cmd1 && cmd2 >>> exec cmd2 >>> pick bar pick bar >>> exec cmd1 exec cmd1 && cmd2 >>> exec cmd2 >>> >>> to >>> >>> pick foo pick foo >>> exec cmd2 >>> exec cmd2 >>> pick bar pick bar >>> exec cmd1 exec cmd1 >>> >>> would take exactly the same effort, at least to me. And more >>> importantly, without editing don't they do *exactly* the same thing? >>> If cmd1 fails, the sequencing stops at that step without running cmd2. >> >> True. I was thinking under the fact that the user would edit the commands >> by himself but the purpose of the "--exec" option is to avoid that (or at >> least that the user won't have to type all by himself). Forget what I said >> then :). > > Not so fast. > > exec cmd1 && cmd2 > and > exec cmd1 > exec cmd2 > > are far from equivalent: If cmd1 fails, the first version never runs > cmd2, but the second version runs cmd2 upon rebase --continue. > > The updated documentation should not say that the two are "equivalent". Good catch. Word "equivalently" is inappropriate here. I think that just removing that one word is best. Zbyszek ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 20:59 ` Johannes Sixt 2012-06-13 21:07 ` Zbigniew Jędrzejewski-Szmek @ 2012-06-13 22:25 ` Junio C Hamano 2012-06-13 22:35 ` Junio C Hamano 2 siblings, 0 replies; 50+ messages in thread From: Junio C Hamano @ 2012-06-13 22:25 UTC (permalink / raw) To: Johannes Sixt Cc: konglu, Zbigniew J?drzejewski-Szmek, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Johannes Sixt <j6t@kdbg.org> writes: > Not so fast. > > exec cmd1 && cmd2 > and > exec cmd1 > exec cmd2 > > are far from equivalent: If cmd1 fails, the first version never runs > cmd2, but the second version runs cmd2 upon rebase --continue. > > The updated documentation should not say that the two are "equivalent". Fair'nuf. Thansk. diff --git a/Documentation/git-rebase.txt b/Documentation/git-rebase.txt index 179ab77..2d71e4b 100644 --- a/Documentation/git-rebase.txt +++ b/Documentation/git-rebase.txt @@ -358,7 +358,7 @@ with several commands: + git rebase -i --exec "cmd1 && cmd2 && ..." + -or equivalently by giving more than one `--exec`: +or by giving more than one `--exec`: + git rebase -i --exec "cmd1" --exec "cmd2" --exec ... + ^ permalink raw reply related [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 20:59 ` Johannes Sixt 2012-06-13 21:07 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 22:25 ` Junio C Hamano @ 2012-06-13 22:35 ` Junio C Hamano 2012-06-13 22:43 ` Zbigniew Jędrzejewski-Szmek 2 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-13 22:35 UTC (permalink / raw) To: Johannes Sixt Cc: konglu, Zbigniew J?drzejewski-Szmek, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Johannes Sixt <j6t@kdbg.org> writes: > Not so fast. > > exec cmd1 && cmd2 > and > exec cmd1 > exec cmd2 > > are far from equivalent: If cmd1 fails, the first version never runs > cmd2, but the second version runs cmd2 upon rebase --continue. This reminds me of one thing. For "exec" insns that are meant to validate each commit in the resulting history, what should happen (I am not asking what the current implementation of "rebase -i" does) after "exec cmd1" fails? Ideally, the user will at that point fix the problem in the code, run "commit --amend" to record the fix, and then want to make sure it really fixed it by re-running "exec cmd1", no? Shouldn't "rebase --continue" after such a "commit --amend" resume execution from "exec cmd1", which failed in the initial run? I said in the beginning 'For "exec" insns that are meant to validate', as "exec" is not necessarily about validation, and other use cases of it may want it run only once in the sequence, whether it succeeds or fails. So perhaps we would need two kinds of "exec", one that just runs once and is not re-run even if the initial round fails, and another (perhaps spell it "test") that runs upon "--continue" until it passes. The latter of course can be skipped by the user with "rebase --skip". ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 22:35 ` Junio C Hamano @ 2012-06-13 22:43 ` Zbigniew Jędrzejewski-Szmek 2012-06-14 6:57 ` Matthieu Moy 0 siblings, 1 reply; 50+ messages in thread From: Zbigniew Jędrzejewski-Szmek @ 2012-06-13 22:43 UTC (permalink / raw) To: Junio C Hamano Cc: Johannes Sixt, konglu, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy On 06/14/2012 12:35 AM, Junio C Hamano wrote: > Johannes Sixt <j6t@kdbg.org> writes: > >> Not so fast. >> >> exec cmd1 && cmd2 >> and >> exec cmd1 >> exec cmd2 >> >> are far from equivalent: If cmd1 fails, the first version never runs >> cmd2, but the second version runs cmd2 upon rebase --continue. > > This reminds me of one thing. > > For "exec" insns that are meant to validate each commit in the > resulting history, what should happen (I am not asking what the > current implementation of "rebase -i" does) after "exec cmd1" fails? > > Ideally, the user will at that point fix the problem in the code, > run "commit --amend" to record the fix, and then want to make sure > it really fixed it by re-running "exec cmd1", no? > > Shouldn't "rebase --continue" after such a "commit --amend" resume > execution from "exec cmd1", which failed in the initial run? > > I said in the beginning 'For "exec" insns that are meant to validate', > as "exec" is not necessarily about validation, and other use cases > of it may want it run only once in the sequence, whether it succeeds > or fails. So perhaps we would need two kinds of "exec", one that > just runs once and is not re-run even if the initial round fails, > and another (perhaps spell it "test") that runs upon "--continue" > until it passes. The latter of course can be skipped by the user > with "rebase --skip". A different proposal would be to add a 'rebase --retry' which would inoke the last command again. And then the advice after 'exec' could say "Use --retry to rerun this command, and --continue to proceed with the next one". --retry could make sense for 'apply' commands too: if a commit fails to apply, one could do git reset --hard HEAD^ hack hack adjusting the preimage git commit git rebase --retry Using --retry to rerun tests would have the advantage that one normally doesn't think that the tests will fail, so could get into the habit of using 'exec', not 'test', for the verification commands. Just thinking aloud. Zbyszek ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-13 22:43 ` Zbigniew Jędrzejewski-Szmek @ 2012-06-14 6:57 ` Matthieu Moy 2012-06-14 14:08 ` Marc Branchaud 0 siblings, 1 reply; 50+ messages in thread From: Matthieu Moy @ 2012-06-14 6:57 UTC (permalink / raw) To: Zbigniew Jędrzejewski-Szmek Cc: Junio C Hamano, Johannes Sixt, konglu, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> writes: >> Shouldn't "rebase --continue" after such a "commit --amend" resume >> execution from "exec cmd1", which failed in the initial run? There are use-cases where this would be useful, but that would also be a real pain if the command itself is broken (e.g. does "echo OK; exit 1", that the user can interpret as correct but that "git rebase" will consider as a failure). It this case, the user would have no simple way to get out of the situation (either --abort or --skip). The current behavior is not that bad: "git rebase --continue" does not re-check the current commit, but the user did have an opportunity to check the commit manually before running it. The problem with rebase (that --exec solves), is that it creates new commits without giving the user this opportunity. I'm not sure adding one more type of command is worth the extra-complexity. > A different proposal would be to add a 'rebase --retry' which would > inoke the last command again. And then the advice after 'exec' could say > "Use --retry to rerun this command, and --continue to proceed with the > next one". > > --retry could make sense for 'apply' commands too: if a commit fails to > apply, one could do [...] That makes sense to me. -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv5] rebase [-i --exec | -ix] <CMD>... 2012-06-14 6:57 ` Matthieu Moy @ 2012-06-14 14:08 ` Marc Branchaud 0 siblings, 0 replies; 50+ messages in thread From: Marc Branchaud @ 2012-06-14 14:08 UTC (permalink / raw) To: Matthieu Moy Cc: Zbigniew Jędrzejewski-Szmek, Junio C Hamano, Johannes Sixt, konglu, Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen On 12-06-14 02:57 AM, Matthieu Moy wrote: > Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl> writes: > >>> Shouldn't "rebase --continue" after such a "commit --amend" resume >>> execution from "exec cmd1", which failed in the initial run? +1 for Junio's proposal. Currently the only time --continue moves on to the next insn is in the "edit" case, when everything up to that point (including applying the "edit" commit) is fine. But if the rebase halted due to a problem, --continue ensures the problem is fixed before moving on to the next insn (e.g. it makes sure a merge conflict is resolved). I think it makes the most sense for --continue after an exec-failure to try to re-run the exec. Furthermore, --skip after an exec failure should just skip the exec. To me that makes --continue's (and --skip's) behaviour consistent with what it does when any other insn operation fails. In other words, if the rebase hits an exec failure, the user is going to want to fix it before continuing (just like any other failure during a rebase). If the user decides to not fix the failing exec, they can --skip it. M. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong @ 2012-06-08 15:00 ` Matthieu Moy 2012-06-08 17:07 ` Junio C Hamano 2 siblings, 0 replies; 50+ messages in thread From: Matthieu Moy @ 2012-06-08 15:00 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen Lucien Kong <Lucien.Kong@ensimag.imag.fr> writes: > + <newbase>. <newbase is the starting point at which to create Missing > after <newbase. -- Matthieu Moy http://www-verimag.imag.fr/~moy/ ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong 2012-06-08 15:00 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Matthieu Moy @ 2012-06-08 17:07 ` Junio C Hamano 2012-06-08 19:06 ` konglu 2 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-08 17:07 UTC (permalink / raw) To: Lucien Kong Cc: git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Lucien Kong <Lucien.Kong@ensimag.imag.fr> writes: > The description of the option "--onto" is changed to be consistent > with the format of the other options. > ... > OPTIONS > ------- > -<newbase>:: > - Starting point at which to create the new commits. If the > - --onto option is not specified, the starting point is > - <upstream>. May be any valid commit, and not just an > - existing branch name. > +--onto <newbase>:: > + With this option, git rebase takes all commits from <branch>, > + that are not in <upstream>, and transplants them on top of > + <newbase>. <newbase is the starting point at which to create > + the new commits. If the --onto option is not specified, the > + starting point is <upstream>. May be any valid commit, and > + not just an existing branch name. > + > As a special case, you may use "A\...B" as a shortcut for the > merge base of A and B if there is exactly one merge base. You can This is doing two unrelated things in a single patch, isn't it? I would imagine that a patch that is about "to be consistent with the format" would be a one-liner -<newbase>:: +--onto <newbase>:: without anything else. The change this patch makes to the explanation is much larger, but that is not justified in the proposed commit log message. Besides, I find the new explanatory text much harder to understand than the original one. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-08 17:07 ` Junio C Hamano @ 2012-06-08 19:06 ` konglu 2012-06-08 19:52 ` Junio C Hamano 0 siblings, 1 reply; 50+ messages in thread From: konglu @ 2012-06-08 19:06 UTC (permalink / raw) To: Junio C Hamano Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Junio C Hamano <gitster@pobox.com> a écrit : > Lucien Kong <Lucien.Kong@ensimag.imag.fr> writes: > >> The description of the option "--onto" is changed to be consistent >> with the format of the other options. >> ... >> OPTIONS >> ------- >> -<newbase>:: >> - Starting point at which to create the new commits. If the >> - --onto option is not specified, the starting point is >> - <upstream>. May be any valid commit, and not just an >> - existing branch name. >> +--onto <newbase>:: >> + With this option, git rebase takes all commits from <branch>, >> + that are not in <upstream>, and transplants them on top of >> + <newbase>. <newbase is the starting point at which to create >> + the new commits. If the --onto option is not specified, the >> + starting point is <upstream>. May be any valid commit, and >> + not just an existing branch name. >> + >> As a special case, you may use "A\...B" as a shortcut for the >> merge base of A and B if there is exactly one merge base. You can > > This is doing two unrelated things in a single patch, isn't it? > > I would imagine that a patch that is about "to be consistent with > the format" would be a one-liner > > -<newbase>:: > +--onto <newbase>:: > > without anything else. The change this patch makes to the > explanation is much larger, but that is not justified in the > proposed commit log message. That's what I thought, but it appeared to me that the description --onto <newbase>:: Starting point at which to create the new commits. If the --onto option is not specified, the starting point is <upstream>. May be any valid commit, and not just an existing branch name. only focus on the parameter <newbase>. It does not really explain first what the option is doing. With the second sentence, it's more like a description of "what happens when we run git rebase without --onto" than "what happens when we run git rebase with --onto". Junio C Hamano <gitster@pobox.com> a écrit : > --onto <newbase>:: > Description of what --onto option does and how <newbase> > is used in what it does. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-08 19:06 ` konglu @ 2012-06-08 19:52 ` Junio C Hamano 2012-06-08 20:08 ` konglu 0 siblings, 1 reply; 50+ messages in thread From: Junio C Hamano @ 2012-06-08 19:52 UTC (permalink / raw) To: konglu Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy konglu@minatec.inpg.fr writes: > That's what I thought, but it appeared to me that the description > > --onto <newbase>:: > Starting point at which to create the new commits. > If the --onto option is not specified, the starting > point is <upstream>. May be any valid commit, and > not just an existing branch name. > > only focus on the parameter <newbase>. Talking about <newbase> is equivalent to talking about --onto isn't it? What the command does is described far above upfront in the manual page; the description of options is the place to explain what details are affected by giving (or not giving) the option in the behaviour that was explained earlier. ^ permalink raw reply [flat|nested] 50+ messages in thread
* Re: [PATCHv3 1/2] git-rebase.txt: "--onto" option updated 2012-06-08 19:52 ` Junio C Hamano @ 2012-06-08 20:08 ` konglu 0 siblings, 0 replies; 50+ messages in thread From: konglu @ 2012-06-08 20:08 UTC (permalink / raw) To: Junio C Hamano Cc: Lucien Kong, git, Valentin Duperray, Franck Jonas, Thomas Nguy, Huynh Khoi Nguyen Nguyen, Matthieu Moy Junio C Hamano <gitster@pobox.com> a écrit : > konglu@minatec.inpg.fr writes: > >> That's what I thought, but it appeared to me that the description >> >> --onto <newbase>:: >> Starting point at which to create the new commits. >> If the --onto option is not specified, the starting >> point is <upstream>. May be any valid commit, and >> not just an existing branch name. >> >> only focus on the parameter <newbase>. > > Talking about <newbase> is equivalent to talking about --onto isn't > it? What the command does is described far above upfront in the > manual page; the description of options is the place to explain what > details are affected by giving (or not giving) the option in the > behaviour that was explained earlier. Alright, gonna keep it unchanged then :). ^ permalink raw reply [flat|nested] 50+ messages in thread
end of thread, other threads:[~2012-06-14 14:09 UTC | newest] Thread overview: 50+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2012-06-04 13:47 [PATCH] rebase [-i --exec | -ix] <CMD> Kong Lucien 2012-06-04 17:42 ` Junio C Hamano 2012-06-04 20:30 ` Matthieu Moy 2012-06-04 21:06 ` Junio C Hamano 2012-06-05 17:59 ` konglu 2012-06-05 18:13 ` Junio C Hamano 2012-06-04 17:48 ` Matthieu Moy 2012-06-06 10:34 ` [PATCHv2] " Lucien Kong 2012-06-06 20:03 ` Matthieu Moy 2012-06-06 22:54 ` Junio C Hamano 2012-06-07 8:25 ` Zbigniew Jędrzejewski-Szmek 2012-06-07 8:40 ` Johannes Sixt 2012-06-07 12:04 ` konglu 2012-06-07 13:43 ` Matthieu Moy 2012-06-08 14:53 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Lucien Kong 2012-06-08 14:53 ` [PATCHv3 2/2] rebase [-i --exec | -ix] <CMD> Lucien Kong 2012-06-08 17:02 ` Johannes Sixt 2012-06-08 18:56 ` Torsten Bögershausen 2012-06-08 19:15 ` konglu 2012-06-08 19:55 ` Torsten Bögershausen 2012-06-08 20:07 ` konglu 2012-06-08 20:51 ` Torsten Bögershausen 2012-06-08 21:03 ` konglu 2012-06-09 6:14 ` Torsten Bögershausen 2012-06-09 6:47 ` konglu 2012-06-10 10:44 ` [PATCHv4] " Lucien Kong 2012-06-10 11:56 ` Johannes Sixt 2012-06-11 15:14 ` Junio C Hamano 2012-06-12 18:55 ` Johannes Sixt 2012-06-12 20:29 ` Junio C Hamano 2012-06-12 8:05 ` [PATCHv5] " Lucien Kong 2012-06-12 9:23 ` Zbigniew Jędrzejewski-Szmek 2012-06-12 14:46 ` Junio C Hamano 2012-06-13 14:04 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 17:32 ` Junio C Hamano 2012-06-13 18:05 ` konglu 2012-06-13 18:22 ` Junio C Hamano 2012-06-13 19:38 ` konglu 2012-06-13 20:59 ` Johannes Sixt 2012-06-13 21:07 ` Zbigniew Jędrzejewski-Szmek 2012-06-13 22:25 ` Junio C Hamano 2012-06-13 22:35 ` Junio C Hamano 2012-06-13 22:43 ` Zbigniew Jędrzejewski-Szmek 2012-06-14 6:57 ` Matthieu Moy 2012-06-14 14:08 ` Marc Branchaud 2012-06-08 15:00 ` [PATCHv3 1/2] git-rebase.txt: "--onto" option updated Matthieu Moy 2012-06-08 17:07 ` Junio C Hamano 2012-06-08 19:06 ` konglu 2012-06-08 19:52 ` Junio C Hamano 2012-06-08 20:08 ` konglu
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).