Merge remote branch 'ko/master' into jc/read-tree-cache-tree-fix
[git] / builtin / revert.c
1 #include "cache.h"
2 #include "builtin.h"
3 #include "object.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "wt-status.h"
7 #include "run-command.h"
8 #include "exec_cmd.h"
9 #include "utf8.h"
10 #include "parse-options.h"
11 #include "cache-tree.h"
12 #include "diff.h"
13 #include "revision.h"
14 #include "rerere.h"
15 #include "merge-recursive.h"
16 #include "refs.h"
17
18 /*
19  * This implements the builtins revert and cherry-pick.
20  *
21  * Copyright (c) 2007 Johannes E. Schindelin
22  *
23  * Based on git-revert.sh, which is
24  *
25  * Copyright (c) 2005 Linus Torvalds
26  * Copyright (c) 2005 Junio C Hamano
27  */
28
29 static const char * const revert_usage[] = {
30         "git revert [options] <commit-ish>",
31         NULL
32 };
33
34 static const char * const cherry_pick_usage[] = {
35         "git cherry-pick [options] <commit-ish>",
36         NULL
37 };
38
39 static int edit, no_replay, no_commit, mainline, signoff, allow_ff;
40 static enum { REVERT, CHERRY_PICK } action;
41 static struct commit *commit;
42 static int commit_argc;
43 static const char **commit_argv;
44 static int allow_rerere_auto;
45
46 static const char *me;
47 static const char *strategy;
48
49 #define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
50
51 static char *get_encoding(const char *message);
52
53 static const char * const *revert_or_cherry_pick_usage(void)
54 {
55         return action == REVERT ? revert_usage : cherry_pick_usage;
56 }
57
58 static void parse_args(int argc, const char **argv)
59 {
60         const char * const * usage_str = revert_or_cherry_pick_usage();
61         int noop;
62         struct option options[] = {
63                 OPT_BOOLEAN('n', "no-commit", &no_commit, "don't automatically commit"),
64                 OPT_BOOLEAN('e', "edit", &edit, "edit the commit message"),
65                 OPT_BOOLEAN('r', NULL, &noop, "no-op (backward compatibility)"),
66                 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
67                 OPT_INTEGER('m', "mainline", &mainline, "parent number"),
68                 OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),
69                 OPT_STRING(0, "strategy", &strategy, "strategy", "merge strategy"),
70                 OPT_END(),
71                 OPT_END(),
72                 OPT_END(),
73         };
74
75         if (action == CHERRY_PICK) {
76                 struct option cp_extra[] = {
77                         OPT_BOOLEAN('x', NULL, &no_replay, "append commit name"),
78                         OPT_BOOLEAN(0, "ff", &allow_ff, "allow fast-forward"),
79                         OPT_END(),
80                 };
81                 if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra))
82                         die("program error");
83         }
84
85         commit_argc = parse_options(argc, argv, NULL, options, usage_str,
86                                     PARSE_OPT_KEEP_ARGV0 |
87                                     PARSE_OPT_KEEP_UNKNOWN);
88         if (commit_argc < 2)
89                 usage_with_options(usage_str, options);
90
91         commit_argv = argv;
92 }
93
94 struct commit_message {
95         char *parent_label;
96         const char *label;
97         const char *subject;
98         char *reencoded_message;
99         const char *message;
100 };
101
102 static int get_message(const char *raw_message, struct commit_message *out)
103 {
104         const char *encoding;
105         const char *p, *abbrev, *eol;
106         char *q;
107         int abbrev_len, oneline_len;
108
109         if (!raw_message)
110                 return -1;
111         encoding = get_encoding(raw_message);
112         if (!encoding)
113                 encoding = "UTF-8";
114         if (!git_commit_encoding)
115                 git_commit_encoding = "UTF-8";
116
117         out->reencoded_message = NULL;
118         out->message = raw_message;
119         if (strcmp(encoding, git_commit_encoding))
120                 out->reencoded_message = reencode_string(raw_message,
121                                         git_commit_encoding, encoding);
122         if (out->reencoded_message)
123                 out->message = out->reencoded_message;
124
125         abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
126         abbrev_len = strlen(abbrev);
127
128         /* Find beginning and end of commit subject. */
129         p = out->message;
130         while (*p && (*p != '\n' || p[1] != '\n'))
131                 p++;
132         if (*p) {
133                 p += 2;
134                 for (eol = p + 1; *eol && *eol != '\n'; eol++)
135                         ; /* do nothing */
136         } else
137                 eol = p;
138         oneline_len = eol - p;
139
140         out->parent_label = xmalloc(strlen("parent of ") + abbrev_len +
141                               strlen("... ") + oneline_len + 1);
142         q = out->parent_label;
143         q = mempcpy(q, "parent of ", strlen("parent of "));
144         out->label = q;
145         q = mempcpy(q, abbrev, abbrev_len);
146         q = mempcpy(q, "... ", strlen("... "));
147         out->subject = q;
148         q = mempcpy(q, p, oneline_len);
149         *q = '\0';
150         return 0;
151 }
152
153 static void free_message(struct commit_message *msg)
154 {
155         free(msg->parent_label);
156         free(msg->reencoded_message);
157 }
158
159 static char *get_encoding(const char *message)
160 {
161         const char *p = message, *eol;
162
163         if (!p)
164                 die ("Could not read commit message of %s",
165                                 sha1_to_hex(commit->object.sha1));
166         while (*p && *p != '\n') {
167                 for (eol = p + 1; *eol && *eol != '\n'; eol++)
168                         ; /* do nothing */
169                 if (!prefixcmp(p, "encoding ")) {
170                         char *result = xmalloc(eol - 8 - p);
171                         strlcpy(result, p + 9, eol - 8 - p);
172                         return result;
173                 }
174                 p = eol;
175                 if (*p == '\n')
176                         p++;
177         }
178         return NULL;
179 }
180
181 static void add_message_to_msg(struct strbuf *msgbuf, const char *message)
182 {
183         const char *p = message;
184         while (*p && (*p != '\n' || p[1] != '\n'))
185                 p++;
186
187         if (!*p)
188                 strbuf_addstr(msgbuf, sha1_to_hex(commit->object.sha1));
189
190         p += 2;
191         strbuf_addstr(msgbuf, p);
192 }
193
194 static void set_author_ident_env(const char *message)
195 {
196         const char *p = message;
197         if (!p)
198                 die ("Could not read commit message of %s",
199                                 sha1_to_hex(commit->object.sha1));
200         while (*p && *p != '\n') {
201                 const char *eol;
202
203                 for (eol = p; *eol && *eol != '\n'; eol++)
204                         ; /* do nothing */
205                 if (!prefixcmp(p, "author ")) {
206                         char *line, *pend, *email, *timestamp;
207
208                         p += 7;
209                         line = xmemdupz(p, eol - p);
210                         email = strchr(line, '<');
211                         if (!email)
212                                 die ("Could not extract author email from %s",
213                                         sha1_to_hex(commit->object.sha1));
214                         if (email == line)
215                                 pend = line;
216                         else
217                                 for (pend = email; pend != line + 1 &&
218                                                 isspace(pend[-1]); pend--);
219                                         ; /* do nothing */
220                         *pend = '\0';
221                         email++;
222                         timestamp = strchr(email, '>');
223                         if (!timestamp)
224                                 die ("Could not extract author time from %s",
225                                         sha1_to_hex(commit->object.sha1));
226                         *timestamp = '\0';
227                         for (timestamp++; *timestamp && isspace(*timestamp);
228                                         timestamp++)
229                                 ; /* do nothing */
230                         setenv("GIT_AUTHOR_NAME", line, 1);
231                         setenv("GIT_AUTHOR_EMAIL", email, 1);
232                         setenv("GIT_AUTHOR_DATE", timestamp, 1);
233                         free(line);
234                         return;
235                 }
236                 p = eol;
237                 if (*p == '\n')
238                         p++;
239         }
240         die ("No author information found in %s",
241                         sha1_to_hex(commit->object.sha1));
242 }
243
244 static char *help_msg(void)
245 {
246         struct strbuf helpbuf = STRBUF_INIT;
247         char *msg = getenv("GIT_CHERRY_PICK_HELP");
248
249         if (msg)
250                 return msg;
251
252         strbuf_addstr(&helpbuf, "  After resolving the conflicts,\n"
253                 "mark the corrected paths with 'git add <paths>' or 'git rm <paths>'\n"
254                 "and commit the result");
255
256         if (action == CHERRY_PICK) {
257                 strbuf_addf(&helpbuf, " with: \n"
258                         "\n"
259                         "        git commit -c %s\n",
260                             sha1_to_hex(commit->object.sha1));
261         }
262         else
263                 strbuf_addch(&helpbuf, '.');
264         return strbuf_detach(&helpbuf, NULL);
265 }
266
267 static void write_message(struct strbuf *msgbuf, const char *filename)
268 {
269         static struct lock_file msg_file;
270
271         int msg_fd = hold_lock_file_for_update(&msg_file, filename,
272                                                LOCK_DIE_ON_ERROR);
273         if (write_in_full(msg_fd, msgbuf->buf, msgbuf->len) < 0)
274                 die_errno("Could not write to %s.", filename);
275         strbuf_release(msgbuf);
276         if (commit_lock_file(&msg_file) < 0)
277                 die("Error wrapping up %s", filename);
278 }
279
280 static struct tree *empty_tree(void)
281 {
282         struct tree *tree = xcalloc(1, sizeof(struct tree));
283
284         tree->object.parsed = 1;
285         tree->object.type = OBJ_TREE;
286         pretend_sha1_file(NULL, 0, OBJ_TREE, tree->object.sha1);
287         return tree;
288 }
289
290 static NORETURN void die_dirty_index(const char *me)
291 {
292         if (read_cache_unmerged()) {
293                 die_resolve_conflict(me);
294         } else {
295                 if (advice_commit_before_merge)
296                         die("Your local changes would be overwritten by %s.\n"
297                             "Please, commit your changes or stash them to proceed.", me);
298                 else
299                         die("Your local changes would be overwritten by %s.\n", me);
300         }
301 }
302
303 static int fast_forward_to(const unsigned char *to, const unsigned char *from)
304 {
305         struct ref_lock *ref_lock;
306
307         read_cache();
308         if (checkout_fast_forward(from, to))
309                 exit(1); /* the callee should have complained already */
310         ref_lock = lock_any_ref_for_update("HEAD", from, 0);
311         return write_ref_sha1(ref_lock, to, "cherry-pick");
312 }
313
314 static void do_recursive_merge(struct commit *base, struct commit *next,
315                                const char *base_label, const char *next_label,
316                                unsigned char *head, struct strbuf *msgbuf,
317                                char *defmsg)
318 {
319         struct merge_options o;
320         struct tree *result, *next_tree, *base_tree, *head_tree;
321         int clean, index_fd;
322         static struct lock_file index_lock;
323
324         index_fd = hold_locked_index(&index_lock, 1);
325
326         read_cache();
327         init_merge_options(&o);
328         o.ancestor = base ? base_label : "(empty tree)";
329         o.branch1 = "HEAD";
330         o.branch2 = next ? next_label : "(empty tree)";
331
332         head_tree = parse_tree_indirect(head);
333         next_tree = next ? next->tree : empty_tree();
334         base_tree = base ? base->tree : empty_tree();
335
336         clean = merge_trees(&o,
337                             head_tree,
338                             next_tree, base_tree, &result);
339
340         if (active_cache_changed &&
341             (write_cache(index_fd, active_cache, active_nr) ||
342              commit_locked_index(&index_lock)))
343                 die("%s: Unable to write new index file", me);
344         rollback_lock_file(&index_lock);
345
346         if (!clean) {
347                 int i;
348                 strbuf_addstr(msgbuf, "\nConflicts:\n\n");
349                 for (i = 0; i < active_nr;) {
350                         struct cache_entry *ce = active_cache[i++];
351                         if (ce_stage(ce)) {
352                                 strbuf_addch(msgbuf, '\t');
353                                 strbuf_addstr(msgbuf, ce->name);
354                                 strbuf_addch(msgbuf, '\n');
355                                 while (i < active_nr && !strcmp(ce->name,
356                                                 active_cache[i]->name))
357                                         i++;
358                         }
359                 }
360                 write_message(msgbuf, defmsg);
361                 fprintf(stderr, "Automatic %s failed.%s\n",
362                         me, help_msg());
363                 rerere(allow_rerere_auto);
364                 exit(1);
365         }
366         write_message(msgbuf, defmsg);
367         fprintf(stderr, "Finished one %s.\n", me);
368 }
369
370 static int do_pick_commit(void)
371 {
372         unsigned char head[20];
373         struct commit *base, *next, *parent;
374         const char *base_label, *next_label;
375         struct commit_message msg = { NULL, NULL, NULL, NULL, NULL };
376         char *defmsg = NULL;
377         struct strbuf msgbuf = STRBUF_INIT;
378
379         if (no_commit) {
380                 /*
381                  * We do not intend to commit immediately.  We just want to
382                  * merge the differences in, so let's compute the tree
383                  * that represents the "current" state for merge-recursive
384                  * to work on.
385                  */
386                 if (write_cache_as_tree(head, 0, NULL))
387                         die ("Your index file is unmerged.");
388         } else {
389                 if (get_sha1("HEAD", head))
390                         die ("You do not have a valid HEAD");
391                 if (index_differs_from("HEAD", 0))
392                         die_dirty_index(me);
393         }
394         discard_cache();
395
396         if (!commit->parents) {
397                 if (action == REVERT)
398                         die ("Cannot revert a root commit");
399                 parent = NULL;
400         }
401         else if (commit->parents->next) {
402                 /* Reverting or cherry-picking a merge commit */
403                 int cnt;
404                 struct commit_list *p;
405
406                 if (!mainline)
407                         die("Commit %s is a merge but no -m option was given.",
408                             sha1_to_hex(commit->object.sha1));
409
410                 for (cnt = 1, p = commit->parents;
411                      cnt != mainline && p;
412                      cnt++)
413                         p = p->next;
414                 if (cnt != mainline || !p)
415                         die("Commit %s does not have parent %d",
416                             sha1_to_hex(commit->object.sha1), mainline);
417                 parent = p->item;
418         } else if (0 < mainline)
419                 die("Mainline was specified but commit %s is not a merge.",
420                     sha1_to_hex(commit->object.sha1));
421         else
422                 parent = commit->parents->item;
423
424         if (allow_ff && !hashcmp(parent->object.sha1, head))
425                 return fast_forward_to(commit->object.sha1, head);
426
427         if (parent && parse_commit(parent) < 0)
428                 die("%s: cannot parse parent commit %s",
429                     me, sha1_to_hex(parent->object.sha1));
430
431         if (get_message(commit->buffer, &msg) != 0)
432                 die("Cannot get commit message for %s",
433                                 sha1_to_hex(commit->object.sha1));
434
435         /*
436          * "commit" is an existing commit.  We would want to apply
437          * the difference it introduces since its first parent "prev"
438          * on top of the current HEAD if we are cherry-pick.  Or the
439          * reverse of it if we are revert.
440          */
441
442         defmsg = git_pathdup("MERGE_MSG");
443
444         if (action == REVERT) {
445                 base = commit;
446                 base_label = msg.label;
447                 next = parent;
448                 next_label = msg.parent_label;
449                 strbuf_addstr(&msgbuf, "Revert \"");
450                 strbuf_addstr(&msgbuf, msg.subject);
451                 strbuf_addstr(&msgbuf, "\"\n\nThis reverts commit ");
452                 strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
453
454                 if (commit->parents->next) {
455                         strbuf_addstr(&msgbuf, ", reversing\nchanges made to ");
456                         strbuf_addstr(&msgbuf, sha1_to_hex(parent->object.sha1));
457                 }
458                 strbuf_addstr(&msgbuf, ".\n");
459         } else {
460                 base = parent;
461                 base_label = msg.parent_label;
462                 next = commit;
463                 next_label = msg.label;
464                 set_author_ident_env(msg.message);
465                 add_message_to_msg(&msgbuf, msg.message);
466                 if (no_replay) {
467                         strbuf_addstr(&msgbuf, "(cherry picked from commit ");
468                         strbuf_addstr(&msgbuf, sha1_to_hex(commit->object.sha1));
469                         strbuf_addstr(&msgbuf, ")\n");
470                 }
471         }
472
473         if (!strategy || !strcmp(strategy, "recursive") || action == REVERT)
474                 do_recursive_merge(base, next, base_label, next_label,
475                                    head, &msgbuf, defmsg);
476         else {
477                 int res;
478                 struct commit_list *common = NULL;
479                 struct commit_list *remotes = NULL;
480                 write_message(&msgbuf, defmsg);
481                 commit_list_insert(base, &common);
482                 commit_list_insert(next, &remotes);
483                 res = try_merge_command(strategy, common,
484                                         sha1_to_hex(head), remotes);
485                 free_commit_list(common);
486                 free_commit_list(remotes);
487                 if (res) {
488                         fprintf(stderr, "Automatic %s with strategy %s failed.%s\n",
489                                 me, strategy, help_msg());
490                         rerere(allow_rerere_auto);
491                         exit(1);
492                 }
493         }
494
495         free_message(&msg);
496
497         /*
498          *
499          * If we are cherry-pick, and if the merge did not result in
500          * hand-editing, we will hit this commit and inherit the original
501          * author date and name.
502          * If we are revert, or if our cherry-pick results in a hand merge,
503          * we had better say that the current user is responsible for that.
504          */
505
506         if (!no_commit) {
507                 /* 6 is max possible length of our args array including NULL */
508                 const char *args[6];
509                 int res;
510                 int i = 0;
511
512                 args[i++] = "commit";
513                 args[i++] = "-n";
514                 if (signoff)
515                         args[i++] = "-s";
516                 if (!edit) {
517                         args[i++] = "-F";
518                         args[i++] = defmsg;
519                 }
520                 args[i] = NULL;
521                 res = run_command_v_opt(args, RUN_GIT_CMD);
522                 free(defmsg);
523
524                 return res;
525         }
526
527         free(defmsg);
528
529         return 0;
530 }
531
532 static void prepare_revs(struct rev_info *revs)
533 {
534         int argc;
535
536         init_revisions(revs, NULL);
537         revs->no_walk = 1;
538         if (action != REVERT)
539                 revs->reverse = 1;
540
541         argc = setup_revisions(commit_argc, commit_argv, revs, NULL);
542         if (argc > 1)
543                 usage(*revert_or_cherry_pick_usage());
544
545         if (prepare_revision_walk(revs))
546                 die("revision walk setup failed");
547
548         if (!revs->commits)
549                 die("empty commit set passed");
550 }
551
552 static int revert_or_cherry_pick(int argc, const char **argv)
553 {
554         struct rev_info revs;
555
556         git_config(git_default_config, NULL);
557         me = action == REVERT ? "revert" : "cherry-pick";
558         setenv(GIT_REFLOG_ACTION, me, 0);
559         parse_args(argc, argv);
560
561         if (allow_ff) {
562                 if (signoff)
563                         die("cherry-pick --ff cannot be used with --signoff");
564                 if (no_commit)
565                         die("cherry-pick --ff cannot be used with --no-commit");
566                 if (no_replay)
567                         die("cherry-pick --ff cannot be used with -x");
568                 if (edit)
569                         die("cherry-pick --ff cannot be used with --edit");
570         }
571
572         if (read_cache() < 0)
573                 die("git %s: failed to read the index", me);
574
575         prepare_revs(&revs);
576
577         while ((commit = get_revision(&revs))) {
578                 int res = do_pick_commit();
579                 if (res)
580                         return res;
581         }
582
583         return 0;
584 }
585
586 int cmd_revert(int argc, const char **argv, const char *prefix)
587 {
588         if (isatty(0))
589                 edit = 1;
590         action = REVERT;
591         return revert_or_cherry_pick(argc, argv);
592 }
593
594 int cmd_cherry_pick(int argc, const char **argv, const char *prefix)
595 {
596         action = CHERRY_PICK;
597         return revert_or_cherry_pick(argc, argv);
598 }