Code

revert: Introduce --continue to continue the operation
authorRamkumar Ramachandra <artagnon@gmail.com>
Thu, 4 Aug 2011 10:39:15 +0000 (16:09 +0530)
committerJunio C Hamano <gitster@pobox.com>
Mon, 8 Aug 2011 16:28:24 +0000 (09:28 -0700)
Introduce a new "git cherry-pick --continue" command which uses the
information in ".git/sequencer" to continue a cherry-pick that stopped
because of a conflict or other error.  It works by dropping the first
instruction from .git/sequencer/todo and performing the remaining
cherry-picks listed there, with options (think "-s" and "-X") from the
initial command listed in ".git/sequencer/opts".

So now you can do:

  $ git cherry-pick -Xpatience foo..bar
  ... description conflict in commit moo ...
  $ git cherry-pick --continue
  error: 'cherry-pick' is not possible because you have unmerged files.
  fatal: failed to resume cherry-pick
  $ echo resolved >conflictingfile
  $ git add conflictingfile && git commit
  $ git cherry-pick --continue; # resumes with the commit after "moo"

During the "git commit" stage, CHERRY_PICK_HEAD will aid by providing
the commit message from the conflicting "moo" commit.  Note that the
cherry-pick mechanism has no control at this stage, so the user is
free to violate anything that was specified during the first
cherry-pick invocation.  For example, if "-x" was specified during the
first cherry-pick invocation, the user is free to edit out the message
during commit time.  Note that the "--signoff" option specified at
cherry-pick invocation time is not reflected in the commit message
provided by CHERRY_PICK_HEAD; the user must take care to add
"--signoff" during the "git commit" invocation.

Helped-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Documentation/git-cherry-pick.txt
Documentation/git-revert.txt
Documentation/sequencer.txt
builtin/revert.c
t/t3510-cherry-pick-sequence.sh

index 138a29284953e19884d05be424f9059a5a247936..663186bda747ce02af4b5ca1732254a0e2425369 100644 (file)
@@ -9,6 +9,7 @@ SYNOPSIS
 --------
 'git cherry-pick' [--edit] [-n] [-m parent-number] [-s] [-x] [--ff] <commit>...
 'git cherry-pick' --reset
+'git cherry-pick' --continue
 
 DESCRIPTION
 -----------
index 783ffb4a68f757c42e5f546f73b25f6d270dc426..9be2fe2b2fe8a00941490e476f672280ae6eccd5 100644 (file)
@@ -9,6 +9,7 @@ SYNOPSIS
 --------
 'git revert' [--edit | --no-edit] [-n] [-m parent-number] [-s] <commit>...
 'git revert' --reset
+'git revert' --continue
 
 DESCRIPTION
 -----------
index 16ce88ce6b4eda27a2c91e01f3053b478d7cde93..3e6df338bed519eb74cf233f40589ddbfb0da57b 100644 (file)
@@ -2,3 +2,8 @@
        Forget about the current operation in progress.  Can be used
        to clear the sequencer state after a failed cherry-pick or
        revert.
+
+--continue::
+       Continue the operation in progress using the information in
+       '.git/sequencer'.  Can be used to continue after resolving
+       conflicts in a failed cherry-pick or revert.
index 19b6739104a6a11bf85b6d3c5015b4481fbd6020..4f0d8f173362d8d1ee16f88ebb2ae6bea99be1f6 100644 (file)
@@ -40,7 +40,7 @@ static const char * const cherry_pick_usage[] = {
 };
 
 enum replay_action { REVERT, CHERRY_PICK };
-enum replay_subcommand { REPLAY_NONE, REPLAY_RESET };
+enum replay_subcommand { REPLAY_NONE, REPLAY_RESET, REPLAY_CONTINUE };
 
 struct replay_opts {
        enum replay_action action;
@@ -117,14 +117,37 @@ static void verify_opt_compatible(const char *me, const char *base_opt, ...)
                die(_("%s: %s cannot be used with %s"), me, this_opt, base_opt);
 }
 
+static void verify_opt_mutually_compatible(const char *me, ...)
+{
+       const char *opt1, *opt2;
+       va_list ap;
+
+       va_start(ap, me);
+       while ((opt1 = va_arg(ap, const char *))) {
+               if (va_arg(ap, int))
+                       break;
+       }
+       if (opt1) {
+               while ((opt2 = va_arg(ap, const char *))) {
+                       if (va_arg(ap, int))
+                               break;
+               }
+       }
+
+       if (opt1 && opt2)
+               die(_("%s: %s cannot be used with %s"), me, opt1, opt2);
+}
+
 static void parse_args(int argc, const char **argv, struct replay_opts *opts)
 {
        const char * const * usage_str = revert_or_cherry_pick_usage(opts);
        const char *me = action_name(opts);
        int noop;
        int reset = 0;
+       int contin = 0;
        struct option options[] = {
                OPT_BOOLEAN(0, "reset", &reset, "forget the current operation"),
+               OPT_BOOLEAN(0, "continue", &contin, "continue the current operation"),
                OPT_BOOLEAN('n', "no-commit", &opts->no_commit, "don't automatically commit"),
                OPT_BOOLEAN('e', "edit", &opts->edit, "edit the commit message"),
                { OPTION_BOOLEAN, 'r', NULL, &noop, NULL, "no-op (backward compatibility)",
@@ -154,15 +177,29 @@ static void parse_args(int argc, const char **argv, struct replay_opts *opts)
                                        PARSE_OPT_KEEP_ARGV0 |
                                        PARSE_OPT_KEEP_UNKNOWN);
 
+       /* Check for incompatible subcommands */
+       verify_opt_mutually_compatible(me,
+                               "--reset", reset,
+                               "--continue", contin,
+                               NULL);
+
        /* Set the subcommand */
        if (reset)
                opts->subcommand = REPLAY_RESET;
+       else if (contin)
+               opts->subcommand = REPLAY_CONTINUE;
        else
                opts->subcommand = REPLAY_NONE;
 
        /* Check for incompatible command line arguments */
-       if (opts->subcommand == REPLAY_RESET) {
-               verify_opt_compatible(me, "--reset",
+       if (opts->subcommand != REPLAY_NONE) {
+               char *this_operation;
+               if (opts->subcommand == REPLAY_RESET)
+                       this_operation = "--reset";
+               else
+                       this_operation = "--continue";
+
+               verify_opt_compatible(me, this_operation,
                                "--no-commit", opts->no_commit,
                                "--signoff", opts->signoff,
                                "--mainline", opts->mainline,
@@ -668,6 +705,137 @@ static int format_todo(struct strbuf *buf, struct commit_list *todo_list,
        return 0;
 }
 
+static struct commit *parse_insn_line(char *start, struct replay_opts *opts)
+{
+       unsigned char commit_sha1[20];
+       char sha1_abbrev[40];
+       enum replay_action action;
+       int insn_len = 0;
+       char *p, *q;
+
+       if (!prefixcmp(start, "pick ")) {
+               action = CHERRY_PICK;
+               insn_len = strlen("pick");
+               p = start + insn_len + 1;
+       } else if (!prefixcmp(start, "revert ")) {
+               action = REVERT;
+               insn_len = strlen("revert");
+               p = start + insn_len + 1;
+       } else
+               return NULL;
+
+       q = strchr(p, ' ');
+       if (!q)
+               return NULL;
+       q++;
+
+       strlcpy(sha1_abbrev, p, q - p);
+
+       /*
+        * Verify that the action matches up with the one in
+        * opts; we don't support arbitrary instructions
+        */
+       if (action != opts->action) {
+               const char *action_str;
+               action_str = action == REVERT ? "revert" : "cherry-pick";
+               error(_("Cannot %s during a %s"), action_str, action_name(opts));
+               return NULL;
+       }
+
+       if (get_sha1(sha1_abbrev, commit_sha1) < 0)
+               return NULL;
+
+       return lookup_commit_reference(commit_sha1);
+}
+
+static int parse_insn_buffer(char *buf, struct commit_list **todo_list,
+                       struct replay_opts *opts)
+{
+       struct commit_list **next = todo_list;
+       struct commit *commit;
+       char *p = buf;
+       int i;
+
+       for (i = 1; *p; i++) {
+               commit = parse_insn_line(p, opts);
+               if (!commit)
+                       return error(_("Could not parse line %d."), i);
+               next = commit_list_append(commit, next);
+               p = strchrnul(p, '\n');
+               if (*p)
+                       p++;
+       }
+       if (!*todo_list)
+               return error(_("No commits parsed."));
+       return 0;
+}
+
+static void read_populate_todo(struct commit_list **todo_list,
+                       struct replay_opts *opts)
+{
+       const char *todo_file = git_path(SEQ_TODO_FILE);
+       struct strbuf buf = STRBUF_INIT;
+       int fd, res;
+
+       fd = open(todo_file, O_RDONLY);
+       if (fd < 0)
+               die_errno(_("Could not open %s."), todo_file);
+       if (strbuf_read(&buf, fd, 0) < 0) {
+               close(fd);
+               strbuf_release(&buf);
+               die(_("Could not read %s."), todo_file);
+       }
+       close(fd);
+
+       res = parse_insn_buffer(buf.buf, todo_list, opts);
+       strbuf_release(&buf);
+       if (res)
+               die(_("Unusable instruction sheet: %s"), todo_file);
+}
+
+static int populate_opts_cb(const char *key, const char *value, void *data)
+{
+       struct replay_opts *opts = data;
+       int error_flag = 1;
+
+       if (!value)
+               error_flag = 0;
+       else if (!strcmp(key, "options.no-commit"))
+               opts->no_commit = git_config_bool_or_int(key, value, &error_flag);
+       else if (!strcmp(key, "options.edit"))
+               opts->edit = git_config_bool_or_int(key, value, &error_flag);
+       else if (!strcmp(key, "options.signoff"))
+               opts->signoff = git_config_bool_or_int(key, value, &error_flag);
+       else if (!strcmp(key, "options.record-origin"))
+               opts->record_origin = git_config_bool_or_int(key, value, &error_flag);
+       else if (!strcmp(key, "options.allow-ff"))
+               opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);
+       else if (!strcmp(key, "options.mainline"))
+               opts->mainline = git_config_int(key, value);
+       else if (!strcmp(key, "options.strategy"))
+               git_config_string(&opts->strategy, key, value);
+       else if (!strcmp(key, "options.strategy-option")) {
+               ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);
+               opts->xopts[opts->xopts_nr++] = xstrdup(value);
+       } else
+               return error(_("Invalid key: %s"), key);
+
+       if (!error_flag)
+               return error(_("Invalid value for %s: %s"), key, value);
+
+       return 0;
+}
+
+static void read_populate_opts(struct replay_opts **opts_ptr)
+{
+       const char *opts_file = git_path(SEQ_OPTS_FILE);
+
+       if (!file_exists(opts_file))
+               return;
+       if (git_config_from_file(populate_opts_cb, opts_file, *opts_ptr) < 0)
+               die(_("Malformed options sheet: %s"), opts_file);
+}
+
 static void walk_revs_populate_todo(struct commit_list **todo_list,
                                struct replay_opts *opts)
 {
@@ -811,6 +979,15 @@ static int pick_revisions(struct replay_opts *opts)
        if (opts->subcommand == REPLAY_RESET) {
                remove_sequencer_state(1);
                return 0;
+       } else if (opts->subcommand == REPLAY_CONTINUE) {
+               if (!file_exists(git_path(SEQ_TODO_FILE)))
+                       goto error;
+               read_populate_opts(&opts);
+               read_populate_todo(&todo_list, opts);
+
+               /* Verify that the conflict has been resolved */
+               if (!index_differs_from("HEAD", 0))
+                       todo_list = todo_list->next;
        } else {
                /*
                 * Start a new cherry-pick/ revert sequence; but
@@ -821,7 +998,8 @@ static int pick_revisions(struct replay_opts *opts)
                walk_revs_populate_todo(&todo_list, opts);
                if (create_seq_dir() < 0) {
                        fatal(_("A cherry-pick or revert is in progress."));
-                       advise(_("Use --reset to forget about it"));
+                       advise(_("Use --continue to continue the operation"));
+                       advise(_("or --reset to forget about it"));
                        exit(128);
                }
                if (get_sha1("HEAD", sha1)) {
@@ -833,6 +1011,8 @@ static int pick_revisions(struct replay_opts *opts)
                save_opts(opts);
        }
        return pick_commits(todo_list, opts);
+error:
+       die(_("No %s in progress"), action_name(opts));
 }
 
 int cmd_revert(int argc, const char **argv, const char *prefix)
index 566a15ed8a6261d02fa186368d85d3bc0249d5c9..3bca2b3dd5cc252cad615b83f84891f6dc2bacfe 100755 (executable)
@@ -115,4 +115,100 @@ test_expect_success 'cherry-pick does not implicitly stomp an existing operation
        test_cmp expect actual
 '
 
+test_expect_success '--continue complains when no cherry-pick is in progress' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick --continue
+'
+
+test_expect_success '--continue complains when there are unresolved conflicts' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick base..anotherpick &&
+       test_must_fail git cherry-pick --continue
+'
+
+test_expect_success '--continue continues after conflicts are resolved' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick base..anotherpick &&
+       echo "c" >foo &&
+       git add foo &&
+       git commit &&
+       git cherry-pick --continue &&
+       test_path_is_missing .git/sequencer &&
+       {
+               git rev-list HEAD |
+               git diff-tree --root --stdin |
+               sed "s/$_x40/OBJID/g"
+       } >actual &&
+       cat >expect <<-\EOF &&
+       OBJID
+       :100644 100644 OBJID OBJID M    foo
+       OBJID
+       :100644 100644 OBJID OBJID M    foo
+       OBJID
+       :100644 100644 OBJID OBJID M    unrelated
+       OBJID
+       :000000 100644 OBJID OBJID A    foo
+       :000000 100644 OBJID OBJID A    unrelated
+       EOF
+       test_cmp expect actual
+'
+
+test_expect_success '--continue respects opts' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick -x base..anotherpick &&
+       echo "c" >foo &&
+       git add foo &&
+       git commit &&
+       git cherry-pick --continue &&
+       test_path_is_missing .git/sequencer &&
+       git cat-file commit HEAD >anotherpick_msg &&
+       git cat-file commit HEAD~1 >picked_msg &&
+       git cat-file commit HEAD~2 >unrelatedpick_msg &&
+       git cat-file commit HEAD~3 >initial_msg &&
+       test_must_fail grep "cherry picked from" initial_msg &&
+       grep "cherry picked from" unrelatedpick_msg &&
+       grep "cherry picked from" picked_msg &&
+       grep "cherry picked from" anotherpick_msg
+'
+
+test_expect_success '--signoff is not automatically propagated to resolved conflict' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick --signoff base..anotherpick &&
+       echo "c" >foo &&
+       git add foo &&
+       git commit &&
+       git cherry-pick --continue &&
+       test_path_is_missing .git/sequencer &&
+       git cat-file commit HEAD >anotherpick_msg &&
+       git cat-file commit HEAD~1 >picked_msg &&
+       git cat-file commit HEAD~2 >unrelatedpick_msg &&
+       git cat-file commit HEAD~3 >initial_msg &&
+       test_must_fail grep "Signed-off-by:" initial_msg &&
+       grep "Signed-off-by:" unrelatedpick_msg &&
+       test_must_fail grep "Signed-off-by:" picked_msg &&
+       grep "Signed-off-by:" anotherpick_msg
+'
+
+test_expect_success 'malformed instruction sheet 1' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick base..anotherpick &&
+       echo "resolved" >foo &&
+       git add foo &&
+       git commit &&
+       sed "s/pick /pick/" .git/sequencer/todo >new_sheet &&
+       cp new_sheet .git/sequencer/todo &&
+       test_must_fail git cherry-pick --continue
+'
+
+test_expect_success 'malformed instruction sheet 2' '
+       pristine_detach initial &&
+       test_must_fail git cherry-pick base..anotherpick &&
+       echo "resolved" >foo &&
+       git add foo &&
+       git commit &&
+       sed "s/pick/revert/" .git/sequencer/todo >new_sheet &&
+       cp new_sheet .git/sequencer/todo &&
+       test_must_fail git cherry-pick --continue
+'
+
 test_done