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