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/*
13 * This implements the builtins revert and cherry-pick.
14 *
15 * Copyright (c) 2007 Johannes E. Schindelin
16 *
17 * Based on git-revert.sh, which is
18 *
19 * Copyright (c) 2005 Linus Torvalds
20 * Copyright (c) 2005 Junio C Hamano
21 */
22static const char * const revert_usage[] = {
24 "git-revert [options] <commit-ish>",
25 NULL
26};
27static const char * const cherry_pick_usage[] = {
29 "git-cherry-pick [options] <commit-ish>",
30 NULL
31};
32static int edit, no_replay, no_commit, needed_deref, mainline;
34static enum { REVERT, CHERRY_PICK } action;
35static struct commit *commit;
36static const char *me;
38#define GIT_REFLOG_ACTION "GIT_REFLOG_ACTION"
40static void parse_args(int argc, const char **argv)
42{
43 const char * const * usage_str =
44 action == REVERT ? revert_usage : cherry_pick_usage;
45 unsigned char sha1[20];
46 const char *arg;
47 int noop;
48 struct option options[] = {
49 OPT_BOOLEAN('n', "no-commit", &no_commit, "don't automatically commit"),
50 OPT_BOOLEAN('e', "edit", &edit, "edit the commit message"),
51 OPT_BOOLEAN('x', NULL, &no_replay, "append commit name when cherry-picking"),
52 OPT_BOOLEAN('r', NULL, &noop, "no-op (backward compatibility)"),
53 OPT_INTEGER('m', "mainline", &mainline, "parent number"),
54 OPT_END(),
55 };
56 if (parse_options(argc, argv, options, usage_str, 0) != 1)
58 usage_with_options(usage_str, options);
59 arg = argv[0];
60 if (get_sha1(arg, sha1))
62 die ("Cannot find '%s'", arg);
63 commit = (struct commit *)parse_object(sha1);
64 if (!commit)
65 die ("Could not find %s", sha1_to_hex(sha1));
66 if (commit->object.type == OBJ_TAG) {
67 commit = (struct commit *)
68 deref_tag((struct object *)commit, arg, strlen(arg));
69 needed_deref = 1;
70 }
71 if (commit->object.type != OBJ_COMMIT)
72 die ("'%s' does not point to a commit", arg);
73}
74static char *get_oneline(const char *message)
76{
77 char *result;
78 const char *p = message, *abbrev, *eol;
79 int abbrev_len, oneline_len;
80 if (!p)
82 die ("Could not read commit message of %s",
83 sha1_to_hex(commit->object.sha1));
84 while (*p && (*p != '\n' || p[1] != '\n'))
85 p++;
86 if (*p) {
88 p += 2;
89 for (eol = p + 1; *eol && *eol != '\n'; eol++)
90 ; /* do nothing */
91 } else
92 eol = p;
93 abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
94 abbrev_len = strlen(abbrev);
95 oneline_len = eol - p;
96 result = xmalloc(abbrev_len + 5 + oneline_len);
97 memcpy(result, abbrev, abbrev_len);
98 memcpy(result + abbrev_len, "... ", 4);
99 memcpy(result + abbrev_len + 4, p, oneline_len);
100 result[abbrev_len + 4 + oneline_len] = '\0';
101 return result;
102}
103static char *get_encoding(const char *message)
105{
106 const char *p = message, *eol;
107 if (!p)
109 die ("Could not read commit message of %s",
110 sha1_to_hex(commit->object.sha1));
111 while (*p && *p != '\n') {
112 for (eol = p + 1; *eol && *eol != '\n'; eol++)
113 ; /* do nothing */
114 if (!prefixcmp(p, "encoding ")) {
115 char *result = xmalloc(eol - 8 - p);
116 strlcpy(result, p + 9, eol - 8 - p);
117 return result;
118 }
119 p = eol;
120 if (*p == '\n')
121 p++;
122 }
123 return NULL;
124}
125static struct lock_file msg_file;
127static int msg_fd;
128static void add_to_msg(const char *string)
130{
131 int len = strlen(string);
132 if (write_in_full(msg_fd, string, len) < 0)
133 die ("Could not write to MERGE_MSG");
134}
135static void add_message_to_msg(const char *message)
137{
138 const char *p = message;
139 while (*p && (*p != '\n' || p[1] != '\n'))
140 p++;
141 if (!*p)
143 add_to_msg(sha1_to_hex(commit->object.sha1));
144 p += 2;
146 add_to_msg(p);
147 return;
148}
149static void set_author_ident_env(const char *message)
151{
152 const char *p = message;
153 if (!p)
154 die ("Could not read commit message of %s",
155 sha1_to_hex(commit->object.sha1));
156 while (*p && *p != '\n') {
157 const char *eol;
158 for (eol = p; *eol && *eol != '\n'; eol++)
160 ; /* do nothing */
161 if (!prefixcmp(p, "author ")) {
162 char *line, *pend, *email, *timestamp;
163 p += 7;
165 line = xmemdupz(p, eol - p);
166 email = strchr(line, '<');
167 if (!email)
168 die ("Could not extract author email from %s",
169 sha1_to_hex(commit->object.sha1));
170 if (email == line)
171 pend = line;
172 else
173 for (pend = email; pend != line + 1 &&
174 isspace(pend[-1]); pend--);
175 ; /* do nothing */
176 *pend = '\0';
177 email++;
178 timestamp = strchr(email, '>');
179 if (!timestamp)
180 die ("Could not extract author email from %s",
181 sha1_to_hex(commit->object.sha1));
182 *timestamp = '\0';
183 for (timestamp++; *timestamp && isspace(*timestamp);
184 timestamp++)
185 ; /* do nothing */
186 setenv("GIT_AUTHOR_NAME", line, 1);
187 setenv("GIT_AUTHOR_EMAIL", email, 1);
188 setenv("GIT_AUTHOR_DATE", timestamp, 1);
189 free(line);
190 return;
191 }
192 p = eol;
193 if (*p == '\n')
194 p++;
195 }
196 die ("No author information found in %s",
197 sha1_to_hex(commit->object.sha1));
198}
199static int merge_recursive(const char *base_sha1,
201 const char *head_sha1, const char *head_name,
202 const char *next_sha1, const char *next_name)
203{
204 char buffer[256];
205 const char *argv[6];
206 sprintf(buffer, "GITHEAD_%s", head_sha1);
208 setenv(buffer, head_name, 1);
209 sprintf(buffer, "GITHEAD_%s", next_sha1);
210 setenv(buffer, next_name, 1);
211 /*
213 * This three way merge is an interesting one. We are at
214 * $head, and would want to apply the change between $commit
215 * and $prev on top of us (when reverting), or the change between
216 * $prev and $commit on top of us (when cherry-picking or replaying).
217 */
218 argv[0] = "merge-recursive";
219 argv[1] = base_sha1;
220 argv[2] = "--";
221 argv[3] = head_sha1;
222 argv[4] = next_sha1;
223 argv[5] = NULL;
224 return run_command_v_opt(argv, RUN_COMMAND_NO_STDIN | RUN_GIT_CMD);
226}
227static int revert_or_cherry_pick(int argc, const char **argv)
229{
230 unsigned char head[20];
231 struct commit *base, *next, *parent;
232 int i;
233 char *oneline, *reencoded_message = NULL;
234 const char *message, *encoding;
235 const char *defmsg = xstrdup(git_path("MERGE_MSG"));
236 git_config(git_default_config);
238 me = action == REVERT ? "revert" : "cherry-pick";
239 setenv(GIT_REFLOG_ACTION, me, 0);
240 parse_args(argc, argv);
241 /* this is copied from the shell script, but it's never triggered... */
243 if (action == REVERT && !no_replay)
244 die("revert is incompatible with replay");
245 if (no_commit) {
247 /*
248 * We do not intend to commit immediately. We just want to
249 * merge the differences in, so let's compute the tree
250 * that represents the "current" state for merge-recursive
251 * to work on.
252 */
253 if (write_tree(head, 0, NULL))
254 die ("Your index file is unmerged.");
255 } else {
256 struct wt_status s;
257 if (get_sha1("HEAD", head))
259 die ("You do not have a valid HEAD");
260 wt_status_prepare(&s);
261 if (s.commitable)
262 die ("Dirty index: cannot %s", me);
263 discard_cache();
264 }
265 if (!commit->parents)
267 die ("Cannot %s a root commit", me);
268 if (commit->parents->next) {
269 /* Reverting or cherry-picking a merge commit */
270 int cnt;
271 struct commit_list *p;
272 if (!mainline)
274 die("Commit %s is a merge but no -m option was given.",
275 sha1_to_hex(commit->object.sha1));
276 for (cnt = 1, p = commit->parents;
278 cnt != mainline && p;
279 cnt++)
280 p = p->next;
281 if (cnt != mainline || !p)
282 die("Commit %s does not have parent %d",
283 sha1_to_hex(commit->object.sha1), mainline);
284 parent = p->item;
285 } else if (0 < mainline)
286 die("Mainline was specified but commit %s is not a merge.",
287 sha1_to_hex(commit->object.sha1));
288 else
289 parent = commit->parents->item;
290 if (!(message = commit->buffer))
292 die ("Cannot get commit message for %s",
293 sha1_to_hex(commit->object.sha1));
294 /*
296 * "commit" is an existing commit. We would want to apply
297 * the difference it introduces since its first parent "prev"
298 * on top of the current HEAD if we are cherry-pick. Or the
299 * reverse of it if we are revert.
300 */
301 msg_fd = hold_lock_file_for_update(&msg_file, defmsg, 1);
303 encoding = get_encoding(message);
305 if (!encoding)
306 encoding = "utf-8";
307 if (!git_commit_encoding)
308 git_commit_encoding = "utf-8";
309 if ((reencoded_message = reencode_string(message,
310 git_commit_encoding, encoding)))
311 message = reencoded_message;
312 oneline = get_oneline(message);
314 if (action == REVERT) {
316 char *oneline_body = strchr(oneline, ' ');
317 base = commit;
319 next = parent;
320 add_to_msg("Revert \"");
321 add_to_msg(oneline_body + 1);
322 add_to_msg("\"\n\nThis reverts commit ");
323 add_to_msg(sha1_to_hex(commit->object.sha1));
324 add_to_msg(".\n");
325 } else {
326 base = parent;
327 next = commit;
328 set_author_ident_env(message);
329 add_message_to_msg(message);
330 if (no_replay) {
331 add_to_msg("(cherry picked from commit ");
332 add_to_msg(sha1_to_hex(commit->object.sha1));
333 add_to_msg(")\n");
334 }
335 }
336 if (needed_deref) {
337 add_to_msg("(original 'git ");
338 add_to_msg(me);
339 add_to_msg("' arguments: ");
340 for (i = 0; i < argc; i++) {
341 if (i)
342 add_to_msg(" ");
343 add_to_msg(argv[i]);
344 }
345 add_to_msg(")\n");
346 }
347 if (merge_recursive(sha1_to_hex(base->object.sha1),
349 sha1_to_hex(head), "HEAD",
350 sha1_to_hex(next->object.sha1), oneline) ||
351 write_tree(head, 0, NULL)) {
352 add_to_msg("\nConflicts:\n\n");
353 read_cache();
354 for (i = 0; i < active_nr;) {
355 struct cache_entry *ce = active_cache[i++];
356 if (ce_stage(ce)) {
357 add_to_msg("\t");
358 add_to_msg(ce->name);
359 add_to_msg("\n");
360 while (i < active_nr && !strcmp(ce->name,
361 active_cache[i]->name))
362 i++;
363 }
364 }
365 if (close(msg_fd) || commit_lock_file(&msg_file) < 0)
366 die ("Error wrapping up %s", defmsg);
367 fprintf(stderr, "Automatic %s failed. "
368 "After resolving the conflicts,\n"
369 "mark the corrected paths with 'git add <paths>' "
370 "and commit the result.\n", me);
371 if (action == CHERRY_PICK) {
372 fprintf(stderr, "When commiting, use the option "
373 "'-c %s' to retain authorship and message.\n",
374 find_unique_abbrev(commit->object.sha1,
375 DEFAULT_ABBREV));
376 }
377 exit(1);
378 }
379 if (close(msg_fd) || commit_lock_file(&msg_file) < 0)
380 die ("Error wrapping up %s", defmsg);
381 fprintf(stderr, "Finished one %s.\n", me);
382 /*
384 *
385 * If we are cherry-pick, and if the merge did not result in
386 * hand-editing, we will hit this commit and inherit the original
387 * author date and name.
388 * If we are revert, or if our cherry-pick results in a hand merge,
389 * we had better say that the current user is responsible for that.
390 */
391 if (!no_commit) {
393 if (edit)
394 return execl_git_cmd("commit", "-n", NULL);
395 else
396 return execl_git_cmd("commit", "-n", "-F", defmsg, NULL);
397 }
398 if (reencoded_message)
399 free(reencoded_message);
400 return 0;
402}
403int cmd_revert(int argc, const char **argv, const char *prefix)
405{
406 if (isatty(0))
407 edit = 1;
408 no_replay = 1;
409 action = REVERT;
410 return revert_or_cherry_pick(argc, argv);
411}
412int cmd_cherry_pick(int argc, const char **argv, const char *prefix)
414{
415 no_replay = 0;
416 action = CHERRY_PICK;
417 return revert_or_cherry_pick(argc, argv);
418}