built-in add -p: implement the "checkout" patch modes

This patch teaches the built-in `git add -p` machinery all the tricks it
needs to know in order to act as the work horse for `git checkout -p`.

Apart from the minor changes (slightly reworded messages, different
`diff` and `apply --check` invocations), it requires a new function to
actually apply the changes, as `git checkout -p` is a bit special in
that respect: when the desired changes do not apply to the index, but
apply to the work tree, Git does not fail straight away, but asks the
user whether to apply the changes to the worktree at least.

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/add-interactive.h b/add-interactive.h
index 1f6a61326e9d4f13769edad5eed491e1c8c615fa..77907f6e212dcfec4b5391da41b8399da1ea98db 100644 (file)
--- a/add-interactive.h
+++ b/add-interactive.h
@@ -27,6 +27,7 @@ enum add_p_mode {
        ADD_P_ADD,
        ADD_P_STASH,
        ADD_P_RESET,
+       ADD_P_CHECKOUT,
 };
 
 int run_add_p(struct repository *r, enum add_p_mode mode,

diff --git a/add-patch.c b/add-patch.c
index af0a86f0f7bd89fdd318035b4e0cc651d2c4982a..ec5116c187006e914514f12dd0848bdac09c4aa2 100644 (file)
--- a/add-patch.c
+++ b/add-patch.c
@@ -111,6 +111,71 @@ static struct patch_mode patch_mode_reset_nothead = {
                        "the file\n"),
 };
 
+static struct patch_mode patch_mode_checkout_index = {
+       .diff_cmd = { "diff-files", NULL },
+       .apply_args = { "-R", NULL },
+       .apply_check_args = { "-R", NULL },
+       .is_reverse = 1,
+       .prompt_mode = {
+               N_("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
+               N_("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
+               N_("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
+       },
+       .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
+                            "will immediately be marked for discarding."),
+       .help_patch_text =
+               N_("y - discard this hunk from worktree\n"
+                  "n - do not discard this hunk from worktree\n"
+                  "q - quit; do not discard this hunk or any of the remaining "
+                       "ones\n"
+                  "a - discard this hunk and all later hunks in the file\n"
+                  "d - do not discard this hunk or any of the later hunks in "
+                       "the file\n"),
+};
+
+static struct patch_mode patch_mode_checkout_head = {
+       .diff_cmd = { "diff-index", NULL },
+       .apply_for_checkout = 1,
+       .apply_check_args = { "-R", NULL },
+       .is_reverse = 1,
+       .prompt_mode = {
+               N_("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
+               N_("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
+               N_("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
+       },
+       .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
+                            "will immediately be marked for discarding."),
+       .help_patch_text =
+               N_("y - discard this hunk from index and worktree\n"
+                  "n - do not discard this hunk from index and worktree\n"
+                  "q - quit; do not discard this hunk or any of the remaining "
+                       "ones\n"
+                  "a - discard this hunk and all later hunks in the file\n"
+                  "d - do not discard this hunk or any of the later hunks in "
+                       "the file\n"),
+};
+
+static struct patch_mode patch_mode_checkout_nothead = {
+       .diff_cmd = { "diff-index", "-R", NULL },
+       .apply_for_checkout = 1,
+       .apply_check_args = { NULL },
+       .prompt_mode = {
+               N_("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
+               N_("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
+               N_("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
+       },
+       .edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
+                            "will immediately be marked for applying."),
+       .help_patch_text =
+               N_("y - apply this hunk to index and worktree\n"
+                  "n - do not apply this hunk to index and worktree\n"
+                  "q - quit; do not apply this hunk or any of the remaining "
+                       "ones\n"
+                  "a - apply this hunk and all later hunks in the file\n"
+                  "d - do not apply this hunk or any of the later hunks in "
+                       "the file\n"),
+};
+
 struct hunk_header {
        unsigned long old_offset, old_count, new_offset, new_count;
        /*
@@ -1067,6 +1132,57 @@ static int edit_hunk_loop(struct add_p_state *s,
        }
 }
 
+static int apply_for_checkout(struct add_p_state *s, struct strbuf *diff,
+                             int is_reverse)
+{
+       const char *reverse = is_reverse ? "-R" : NULL;
+       struct child_process check_index = CHILD_PROCESS_INIT;
+       struct child_process check_worktree = CHILD_PROCESS_INIT;
+       struct child_process apply_index = CHILD_PROCESS_INIT;
+       struct child_process apply_worktree = CHILD_PROCESS_INIT;
+       int applies_index, applies_worktree;
+
+       setup_child_process(s, &check_index,
+                           "apply", "--cached", "--check", reverse, NULL);
+       applies_index = !pipe_command(&check_index, diff->buf, diff->len,
+                                     NULL, 0, NULL, 0);
+
+       setup_child_process(s, &check_worktree,
+                           "apply", "--check", reverse, NULL);
+       applies_worktree = !pipe_command(&check_worktree, diff->buf, diff->len,
+                                        NULL, 0, NULL, 0);
+
+       if (applies_worktree && applies_index) {
+               setup_child_process(s, &apply_index,
+                                   "apply", "--cached", reverse, NULL);
+               pipe_command(&apply_index, diff->buf, diff->len,
+                            NULL, 0, NULL, 0);
+
+               setup_child_process(s, &apply_worktree,
+                                   "apply", reverse, NULL);
+               pipe_command(&apply_worktree, diff->buf, diff->len,
+                            NULL, 0, NULL, 0);
+
+               return 1;
+       }
+
+       if (!applies_index) {
+               err(s, _("The selected hunks do not apply to the index!"));
+               if (prompt_yesno(s, _("Apply them to the worktree "
+                                         "anyway? ")) > 0) {
+                       setup_child_process(s, &apply_worktree,
+                                           "apply", reverse, NULL);
+                       return pipe_command(&apply_worktree, diff->buf,
+                                           diff->len, NULL, 0, NULL, 0);
+               }
+               err(s, _("Nothing was applied.\n"));
+       } else
+               /* As a last resort, show the diff to the user */
+               fwrite(diff->buf, diff->len, 1, stderr);
+
+       return 0;
+}
+
 #define SUMMARY_HEADER_WIDTH 20
 #define SUMMARY_LINE_WIDTH 80
 static void summarize_hunk(struct add_p_state *s, struct hunk *hunk,
@@ -1392,11 +1508,16 @@ soft_increment:
                reassemble_patch(s, file_diff, 0, &s->buf);
 
                discard_index(s->s.r->index);
-               setup_child_process(s, &cp, "apply", NULL);
-               argv_array_pushv(&cp.args, s->mode->apply_args);
-               if (pipe_command(&cp, s->buf.buf, s->buf.len,
-                                NULL, 0, NULL, 0))
-                       error(_("'git apply' failed"));
+               if (s->mode->apply_for_checkout)
+                       apply_for_checkout(s, &s->buf,
+                                          s->mode->is_reverse);
+               else {
+                       setup_child_process(s, &cp, "apply", NULL);
+                       argv_array_pushv(&cp.args, s->mode->apply_args);
+                       if (pipe_command(&cp, s->buf.buf, s->buf.len,
+                                        NULL, 0, NULL, 0))
+                               error(_("'git apply' failed"));
+               }
                if (!repo_read_index(s->s.r))
                        repo_refresh_and_write_index(s->s.r, REFRESH_QUIET, 0,
                                                     1, NULL, NULL, NULL);
@@ -1423,6 +1544,13 @@ int run_add_p(struct repository *r, enum add_p_mode mode,
                        s.mode = &patch_mode_reset_head;
                else
                        s.mode = &patch_mode_reset_nothead;
+       } else if (mode == ADD_P_CHECKOUT) {
+               if (!revision)
+                       s.mode = &patch_mode_checkout_index;
+               else if (!strcmp(revision, "HEAD"))
+                       s.mode = &patch_mode_checkout_head;
+               else
+                       s.mode = &patch_mode_checkout_nothead;
        } else
                s.mode = &patch_mode_add;
        s.revision = revision;

diff --git a/builtin/add.c b/builtin/add.c
index fa8bf6b10a53e819f32b8af4f0d66df166fa5b31..191856b036cce6e6725b1cf6e9700a75ce9d8623 100644 (file)
--- a/builtin/add.c
+++ b/builtin/add.c
@@ -206,9 +206,10 @@ int run_add_interactive(const char *revision, const char *patch_mode,
                        mode = ADD_P_STASH;
                else if (!strcmp(patch_mode, "--patch=reset"))
                        mode = ADD_P_RESET;
+               else if (!strcmp(patch_mode, "--patch=checkout"))
+                       mode = ADD_P_CHECKOUT;
                else
-                       die("'%s' not yet supported in the built-in add -p",
-                           patch_mode);
+                       die("'%s' not supported", patch_mode);
 
                return !!run_add_p(the_repository, mode, revision, pathspec);
        }