commit: fix patch hunk editing with "commit -p -m"
[git/git.git] / builtin / commit.c
1 /*
2 * Builtin "git commit"
3 *
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
7
8 #include "cache.h"
9 #include "cache-tree.h"
10 #include "color.h"
11 #include "dir.h"
12 #include "builtin.h"
13 #include "diff.h"
14 #include "diffcore.h"
15 #include "commit.h"
16 #include "revision.h"
17 #include "wt-status.h"
18 #include "run-command.h"
19 #include "refs.h"
20 #include "log-tree.h"
21 #include "strbuf.h"
22 #include "utf8.h"
23 #include "parse-options.h"
24 #include "string-list.h"
25 #include "rerere.h"
26 #include "unpack-trees.h"
27 #include "quote.h"
28 #include "submodule.h"
29 #include "gpg-interface.h"
30 #include "column.h"
31 #include "sequencer.h"
32 #include "notes-utils.h"
33 #include "mailmap.h"
34
35 static const char * const builtin_commit_usage[] = {
36 N_("git commit [options] [--] <pathspec>..."),
37 NULL
38 };
39
40 static const char * const builtin_status_usage[] = {
41 N_("git status [options] [--] <pathspec>..."),
42 NULL
43 };
44
45 static const char implicit_ident_advice[] =
46 N_("Your name and email address were configured automatically based\n"
47 "on your username and hostname. Please check that they are accurate.\n"
48 "You can suppress this message by setting them explicitly:\n"
49 "\n"
50 " git config --global user.name \"Your Name\"\n"
51 " git config --global user.email you@example.com\n"
52 "\n"
53 "After doing this, you may fix the identity used for this commit with:\n"
54 "\n"
55 " git commit --amend --reset-author\n");
56
57 static const char empty_amend_advice[] =
58 N_("You asked to amend the most recent commit, but doing so would make\n"
59 "it empty. You can repeat your command with --allow-empty, or you can\n"
60 "remove the commit entirely with \"git reset HEAD^\".\n");
61
62 static const char empty_cherry_pick_advice[] =
63 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
64 "If you wish to commit it anyway, use:\n"
65 "\n"
66 " git commit --allow-empty\n"
67 "\n");
68
69 static const char empty_cherry_pick_advice_single[] =
70 N_("Otherwise, please use 'git reset'\n");
71
72 static const char empty_cherry_pick_advice_multi[] =
73 N_("If you wish to skip this commit, use:\n"
74 "\n"
75 " git reset\n"
76 "\n"
77 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
78 "the remaining commits.\n");
79
80 static const char *use_message_buffer;
81 static const char commit_editmsg[] = "COMMIT_EDITMSG";
82 static struct lock_file index_lock; /* real index */
83 static struct lock_file false_lock; /* used only for partial commits */
84 static enum {
85 COMMIT_AS_IS = 1,
86 COMMIT_NORMAL,
87 COMMIT_PARTIAL
88 } commit_style;
89
90 static const char *logfile, *force_author;
91 static const char *template_file;
92 /*
93 * The _message variables are commit names from which to take
94 * the commit message and/or authorship.
95 */
96 static const char *author_message, *author_message_buffer;
97 static char *edit_message, *use_message;
98 static char *fixup_message, *squash_message;
99 static int all, also, interactive, patch_interactive, only, amend, signoff;
100 static int edit_flag = -1; /* unspecified */
101 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
102 static int no_post_rewrite, allow_empty_message;
103 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
104 static char *sign_commit;
105
106 /*
107 * The default commit message cleanup mode will remove the lines
108 * beginning with # (shell comments) and leading and trailing
109 * whitespaces (empty lines or containing only whitespaces)
110 * if editor is used, and only the whitespaces if the message
111 * is specified explicitly.
112 */
113 static enum {
114 CLEANUP_SPACE,
115 CLEANUP_NONE,
116 CLEANUP_ALL
117 } cleanup_mode;
118 static const char *cleanup_arg;
119
120 static enum commit_whence whence;
121 static int sequencer_in_use;
122 static int use_editor = 1, include_status = 1;
123 static int show_ignored_in_status, have_option_m;
124 static const char *only_include_assumed;
125 static struct strbuf message = STRBUF_INIT;
126
127 static enum status_format {
128 STATUS_FORMAT_NONE = 0,
129 STATUS_FORMAT_LONG,
130 STATUS_FORMAT_SHORT,
131 STATUS_FORMAT_PORCELAIN,
132
133 STATUS_FORMAT_UNSPECIFIED
134 } status_format = STATUS_FORMAT_UNSPECIFIED;
135
136 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
137 {
138 struct strbuf *buf = opt->value;
139 if (unset) {
140 have_option_m = 0;
141 strbuf_setlen(buf, 0);
142 } else {
143 have_option_m = 1;
144 if (buf->len)
145 strbuf_addch(buf, '\n');
146 strbuf_addstr(buf, arg);
147 strbuf_complete_line(buf);
148 }
149 return 0;
150 }
151
152 static void determine_whence(struct wt_status *s)
153 {
154 if (file_exists(git_path("MERGE_HEAD")))
155 whence = FROM_MERGE;
156 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
157 whence = FROM_CHERRY_PICK;
158 if (file_exists(git_path("sequencer")))
159 sequencer_in_use = 1;
160 }
161 else
162 whence = FROM_COMMIT;
163 if (s)
164 s->whence = whence;
165 }
166
167 static void status_init_config(struct wt_status *s, config_fn_t fn)
168 {
169 wt_status_prepare(s);
170 gitmodules_config();
171 git_config(fn, s);
172 determine_whence(s);
173 s->hints = advice_status_hints; /* must come after git_config() */
174 }
175
176 static void rollback_index_files(void)
177 {
178 switch (commit_style) {
179 case COMMIT_AS_IS:
180 break; /* nothing to do */
181 case COMMIT_NORMAL:
182 rollback_lock_file(&index_lock);
183 break;
184 case COMMIT_PARTIAL:
185 rollback_lock_file(&index_lock);
186 rollback_lock_file(&false_lock);
187 break;
188 }
189 }
190
191 static int commit_index_files(void)
192 {
193 int err = 0;
194
195 switch (commit_style) {
196 case COMMIT_AS_IS:
197 break; /* nothing to do */
198 case COMMIT_NORMAL:
199 err = commit_lock_file(&index_lock);
200 break;
201 case COMMIT_PARTIAL:
202 err = commit_lock_file(&index_lock);
203 rollback_lock_file(&false_lock);
204 break;
205 }
206
207 return err;
208 }
209
210 /*
211 * Take a union of paths in the index and the named tree (typically, "HEAD"),
212 * and return the paths that match the given pattern in list.
213 */
214 static int list_paths(struct string_list *list, const char *with_tree,
215 const char *prefix, const struct pathspec *pattern)
216 {
217 int i;
218 char *m;
219
220 if (!pattern->nr)
221 return 0;
222
223 m = xcalloc(1, pattern->nr);
224
225 if (with_tree) {
226 char *max_prefix = common_prefix(pattern);
227 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
228 free(max_prefix);
229 }
230
231 for (i = 0; i < active_nr; i++) {
232 const struct cache_entry *ce = active_cache[i];
233 struct string_list_item *item;
234
235 if (ce->ce_flags & CE_UPDATE)
236 continue;
237 if (!match_pathspec_depth(pattern, ce->name, ce_namelen(ce), 0, m))
238 continue;
239 item = string_list_insert(list, ce->name);
240 if (ce_skip_worktree(ce))
241 item->util = item; /* better a valid pointer than a fake one */
242 }
243
244 return report_path_error(m, pattern, prefix);
245 }
246
247 static void add_remove_files(struct string_list *list)
248 {
249 int i;
250 for (i = 0; i < list->nr; i++) {
251 struct stat st;
252 struct string_list_item *p = &(list->items[i]);
253
254 /* p->util is skip-worktree */
255 if (p->util)
256 continue;
257
258 if (!lstat(p->string, &st)) {
259 if (add_to_cache(p->string, &st, 0))
260 die(_("updating files failed"));
261 } else
262 remove_file_from_cache(p->string);
263 }
264 }
265
266 static void create_base_index(const struct commit *current_head)
267 {
268 struct tree *tree;
269 struct unpack_trees_options opts;
270 struct tree_desc t;
271
272 if (!current_head) {
273 discard_cache();
274 return;
275 }
276
277 memset(&opts, 0, sizeof(opts));
278 opts.head_idx = 1;
279 opts.index_only = 1;
280 opts.merge = 1;
281 opts.src_index = &the_index;
282 opts.dst_index = &the_index;
283
284 opts.fn = oneway_merge;
285 tree = parse_tree_indirect(current_head->object.sha1);
286 if (!tree)
287 die(_("failed to unpack HEAD tree object"));
288 parse_tree(tree);
289 init_tree_desc(&t, tree->buffer, tree->size);
290 if (unpack_trees(1, &t, &opts))
291 exit(128); /* We've already reported the error, finish dying */
292 }
293
294 static void refresh_cache_or_die(int refresh_flags)
295 {
296 /*
297 * refresh_flags contains REFRESH_QUIET, so the only errors
298 * are for unmerged entries.
299 */
300 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
301 die_resolve_conflict("commit");
302 }
303
304 static char *prepare_index(int argc, const char **argv, const char *prefix,
305 const struct commit *current_head, int is_status)
306 {
307 int fd;
308 struct string_list partial;
309 struct pathspec pathspec;
310 char *old_index_env = NULL;
311 int refresh_flags = REFRESH_QUIET;
312
313 if (is_status)
314 refresh_flags |= REFRESH_UNMERGED;
315 parse_pathspec(&pathspec, 0,
316 PATHSPEC_PREFER_FULL,
317 prefix, argv);
318
319 if (read_cache_preload(&pathspec) < 0)
320 die(_("index file corrupt"));
321
322 if (interactive) {
323 fd = hold_locked_index(&index_lock, 1);
324
325 refresh_cache_or_die(refresh_flags);
326
327 if (write_cache(fd, active_cache, active_nr) ||
328 close_lock_file(&index_lock))
329 die(_("unable to create temporary index"));
330
331 old_index_env = getenv(INDEX_ENVIRONMENT);
332 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
333
334 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
335 die(_("interactive add failed"));
336
337 if (old_index_env && *old_index_env)
338 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
339 else
340 unsetenv(INDEX_ENVIRONMENT);
341
342 discard_cache();
343 read_cache_from(index_lock.filename);
344
345 commit_style = COMMIT_NORMAL;
346 return index_lock.filename;
347 }
348
349 /*
350 * Non partial, non as-is commit.
351 *
352 * (1) get the real index;
353 * (2) update the_index as necessary;
354 * (3) write the_index out to the real index (still locked);
355 * (4) return the name of the locked index file.
356 *
357 * The caller should run hooks on the locked real index, and
358 * (A) if all goes well, commit the real index;
359 * (B) on failure, rollback the real index.
360 */
361 if (all || (also && pathspec.nr)) {
362 fd = hold_locked_index(&index_lock, 1);
363 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
364 refresh_cache_or_die(refresh_flags);
365 update_main_cache_tree(WRITE_TREE_SILENT);
366 if (write_cache(fd, active_cache, active_nr) ||
367 close_lock_file(&index_lock))
368 die(_("unable to write new_index file"));
369 commit_style = COMMIT_NORMAL;
370 return index_lock.filename;
371 }
372
373 /*
374 * As-is commit.
375 *
376 * (1) return the name of the real index file.
377 *
378 * The caller should run hooks on the real index,
379 * and create commit from the_index.
380 * We still need to refresh the index here.
381 */
382 if (!only && !pathspec.nr) {
383 fd = hold_locked_index(&index_lock, 1);
384 refresh_cache_or_die(refresh_flags);
385 if (active_cache_changed) {
386 update_main_cache_tree(WRITE_TREE_SILENT);
387 if (write_cache(fd, active_cache, active_nr) ||
388 commit_locked_index(&index_lock))
389 die(_("unable to write new_index file"));
390 } else {
391 rollback_lock_file(&index_lock);
392 }
393 commit_style = COMMIT_AS_IS;
394 return get_index_file();
395 }
396
397 /*
398 * A partial commit.
399 *
400 * (0) find the set of affected paths;
401 * (1) get lock on the real index file;
402 * (2) update the_index with the given paths;
403 * (3) write the_index out to the real index (still locked);
404 * (4) get lock on the false index file;
405 * (5) reset the_index from HEAD;
406 * (6) update the_index the same way as (2);
407 * (7) write the_index out to the false index file;
408 * (8) return the name of the false index file (still locked);
409 *
410 * The caller should run hooks on the locked false index, and
411 * create commit from it. Then
412 * (A) if all goes well, commit the real index;
413 * (B) on failure, rollback the real index;
414 * In either case, rollback the false index.
415 */
416 commit_style = COMMIT_PARTIAL;
417
418 if (whence != FROM_COMMIT) {
419 if (whence == FROM_MERGE)
420 die(_("cannot do a partial commit during a merge."));
421 else if (whence == FROM_CHERRY_PICK)
422 die(_("cannot do a partial commit during a cherry-pick."));
423 }
424
425 memset(&partial, 0, sizeof(partial));
426 partial.strdup_strings = 1;
427 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
428 exit(1);
429
430 discard_cache();
431 if (read_cache() < 0)
432 die(_("cannot read the index"));
433
434 fd = hold_locked_index(&index_lock, 1);
435 add_remove_files(&partial);
436 refresh_cache(REFRESH_QUIET);
437 if (write_cache(fd, active_cache, active_nr) ||
438 close_lock_file(&index_lock))
439 die(_("unable to write new_index file"));
440
441 fd = hold_lock_file_for_update(&false_lock,
442 git_path("next-index-%"PRIuMAX,
443 (uintmax_t) getpid()),
444 LOCK_DIE_ON_ERROR);
445
446 create_base_index(current_head);
447 add_remove_files(&partial);
448 refresh_cache(REFRESH_QUIET);
449
450 if (write_cache(fd, active_cache, active_nr) ||
451 close_lock_file(&false_lock))
452 die(_("unable to write temporary index file"));
453
454 discard_cache();
455 read_cache_from(false_lock.filename);
456
457 return false_lock.filename;
458 }
459
460 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
461 struct wt_status *s)
462 {
463 unsigned char sha1[20];
464
465 if (s->relative_paths)
466 s->prefix = prefix;
467
468 if (amend) {
469 s->amend = 1;
470 s->reference = "HEAD^1";
471 }
472 s->verbose = verbose;
473 s->index_file = index_file;
474 s->fp = fp;
475 s->nowarn = nowarn;
476 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
477
478 wt_status_collect(s);
479
480 switch (status_format) {
481 case STATUS_FORMAT_SHORT:
482 wt_shortstatus_print(s);
483 break;
484 case STATUS_FORMAT_PORCELAIN:
485 wt_porcelain_print(s);
486 break;
487 case STATUS_FORMAT_UNSPECIFIED:
488 die("BUG: finalize_deferred_config() should have been called");
489 break;
490 case STATUS_FORMAT_NONE:
491 case STATUS_FORMAT_LONG:
492 wt_status_print(s);
493 break;
494 }
495
496 return s->commitable;
497 }
498
499 static int is_a_merge(const struct commit *current_head)
500 {
501 return !!(current_head->parents && current_head->parents->next);
502 }
503
504 static void export_one(const char *var, const char *s, const char *e, int hack)
505 {
506 struct strbuf buf = STRBUF_INIT;
507 if (hack)
508 strbuf_addch(&buf, hack);
509 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
510 setenv(var, buf.buf, 1);
511 strbuf_release(&buf);
512 }
513
514 static int sane_ident_split(struct ident_split *person)
515 {
516 if (!person->name_begin || !person->name_end ||
517 person->name_begin == person->name_end)
518 return 0; /* no human readable name */
519 if (!person->mail_begin || !person->mail_end ||
520 person->mail_begin == person->mail_end)
521 return 0; /* no usable mail */
522 if (!person->date_begin || !person->date_end ||
523 !person->tz_begin || !person->tz_end)
524 return 0;
525 return 1;
526 }
527
528 static void determine_author_info(struct strbuf *author_ident)
529 {
530 char *name, *email, *date;
531 struct ident_split author;
532
533 name = getenv("GIT_AUTHOR_NAME");
534 email = getenv("GIT_AUTHOR_EMAIL");
535 date = getenv("GIT_AUTHOR_DATE");
536
537 if (author_message) {
538 const char *a, *lb, *rb, *eol;
539 size_t len;
540
541 a = strstr(author_message_buffer, "\nauthor ");
542 if (!a)
543 die(_("invalid commit: %s"), author_message);
544
545 lb = strchrnul(a + strlen("\nauthor "), '<');
546 rb = strchrnul(lb, '>');
547 eol = strchrnul(rb, '\n');
548 if (!*lb || !*rb || !*eol)
549 die(_("invalid commit: %s"), author_message);
550
551 if (lb == a + strlen("\nauthor "))
552 /* \nauthor <foo@example.com> */
553 name = xcalloc(1, 1);
554 else
555 name = xmemdupz(a + strlen("\nauthor "),
556 (lb - strlen(" ") -
557 (a + strlen("\nauthor "))));
558 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
559 len = eol - (rb + strlen("> "));
560 date = xmalloc(len + 2);
561 *date = '@';
562 memcpy(date + 1, rb + strlen("> "), len);
563 date[len + 1] = '\0';
564 }
565
566 if (force_author) {
567 const char *lb = strstr(force_author, " <");
568 const char *rb = strchr(force_author, '>');
569
570 if (!lb || !rb)
571 die(_("malformed --author parameter"));
572 name = xstrndup(force_author, lb - force_author);
573 email = xstrndup(lb + 2, rb - (lb + 2));
574 }
575
576 if (force_date)
577 date = force_date;
578 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
579 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
580 sane_ident_split(&author)) {
581 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
582 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
583 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
584 }
585 }
586
587 static char *cut_ident_timestamp_part(char *string)
588 {
589 char *ket = strrchr(string, '>');
590 if (!ket || ket[1] != ' ')
591 die(_("Malformed ident string: '%s'"), string);
592 *++ket = '\0';
593 return ket;
594 }
595
596 static int prepare_to_commit(const char *index_file, const char *prefix,
597 struct commit *current_head,
598 struct wt_status *s,
599 struct strbuf *author_ident)
600 {
601 struct stat statbuf;
602 struct strbuf committer_ident = STRBUF_INIT;
603 int commitable, saved_color_setting;
604 struct strbuf sb = STRBUF_INIT;
605 char *buffer;
606 const char *hook_arg1 = NULL;
607 const char *hook_arg2 = NULL;
608 int ident_shown = 0;
609 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
610 int old_display_comment_prefix;
611
612 /* This checks and barfs if author is badly specified */
613 determine_author_info(author_ident);
614
615 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
616 return 0;
617
618 if (squash_message) {
619 /*
620 * Insert the proper subject line before other commit
621 * message options add their content.
622 */
623 if (use_message && !strcmp(use_message, squash_message))
624 strbuf_addstr(&sb, "squash! ");
625 else {
626 struct pretty_print_context ctx = {0};
627 struct commit *c;
628 c = lookup_commit_reference_by_name(squash_message);
629 if (!c)
630 die(_("could not lookup commit %s"), squash_message);
631 ctx.output_encoding = get_commit_output_encoding();
632 format_commit_message(c, "squash! %s\n\n", &sb,
633 &ctx);
634 }
635 }
636
637 if (message.len) {
638 strbuf_addbuf(&sb, &message);
639 hook_arg1 = "message";
640 } else if (logfile && !strcmp(logfile, "-")) {
641 if (isatty(0))
642 fprintf(stderr, _("(reading log message from standard input)\n"));
643 if (strbuf_read(&sb, 0, 0) < 0)
644 die_errno(_("could not read log from standard input"));
645 hook_arg1 = "message";
646 } else if (logfile) {
647 if (strbuf_read_file(&sb, logfile, 0) < 0)
648 die_errno(_("could not read log file '%s'"),
649 logfile);
650 hook_arg1 = "message";
651 } else if (use_message) {
652 buffer = strstr(use_message_buffer, "\n\n");
653 if (!use_editor && (!buffer || buffer[2] == '\0'))
654 die(_("commit has empty message"));
655 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
656 hook_arg1 = "commit";
657 hook_arg2 = use_message;
658 } else if (fixup_message) {
659 struct pretty_print_context ctx = {0};
660 struct commit *commit;
661 commit = lookup_commit_reference_by_name(fixup_message);
662 if (!commit)
663 die(_("could not lookup commit %s"), fixup_message);
664 ctx.output_encoding = get_commit_output_encoding();
665 format_commit_message(commit, "fixup! %s\n\n",
666 &sb, &ctx);
667 hook_arg1 = "message";
668 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
669 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
670 die_errno(_("could not read MERGE_MSG"));
671 hook_arg1 = "merge";
672 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
673 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
674 die_errno(_("could not read SQUASH_MSG"));
675 hook_arg1 = "squash";
676 } else if (template_file) {
677 if (strbuf_read_file(&sb, template_file, 0) < 0)
678 die_errno(_("could not read '%s'"), template_file);
679 hook_arg1 = "template";
680 clean_message_contents = 0;
681 }
682
683 /*
684 * The remaining cases don't modify the template message, but
685 * just set the argument(s) to the prepare-commit-msg hook.
686 */
687 else if (whence == FROM_MERGE)
688 hook_arg1 = "merge";
689 else if (whence == FROM_CHERRY_PICK) {
690 hook_arg1 = "commit";
691 hook_arg2 = "CHERRY_PICK_HEAD";
692 }
693
694 if (squash_message) {
695 /*
696 * If squash_commit was used for the commit subject,
697 * then we're possibly hijacking other commit log options.
698 * Reset the hook args to tell the real story.
699 */
700 hook_arg1 = "message";
701 hook_arg2 = "";
702 }
703
704 s->fp = fopen(git_path(commit_editmsg), "w");
705 if (s->fp == NULL)
706 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
707
708 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
709 old_display_comment_prefix = s->display_comment_prefix;
710 s->display_comment_prefix = 1;
711
712 /*
713 * Most hints are counter-productive when the commit has
714 * already started.
715 */
716 s->hints = 0;
717
718 if (clean_message_contents)
719 stripspace(&sb, 0);
720
721 if (signoff) {
722 /*
723 * See if we have a Conflicts: block at the end. If yes, count
724 * its size, so we can ignore it.
725 */
726 int ignore_footer = 0;
727 int i, eol, previous = 0;
728 const char *nl;
729
730 for (i = 0; i < sb.len; i++) {
731 nl = memchr(sb.buf + i, '\n', sb.len - i);
732 if (nl)
733 eol = nl - sb.buf;
734 else
735 eol = sb.len;
736 if (starts_with(sb.buf + previous, "\nConflicts:\n")) {
737 ignore_footer = sb.len - previous;
738 break;
739 }
740 while (i < eol)
741 i++;
742 previous = eol;
743 }
744
745 append_signoff(&sb, ignore_footer, 0);
746 }
747
748 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
749 die_errno(_("could not write commit template"));
750
751 strbuf_release(&sb);
752
753 /* This checks if committer ident is explicitly given */
754 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
755 if (use_editor && include_status) {
756 char *ai_tmp, *ci_tmp;
757 if (whence != FROM_COMMIT)
758 status_printf_ln(s, GIT_COLOR_NORMAL,
759 whence == FROM_MERGE
760 ? _("\n"
761 "It looks like you may be committing a merge.\n"
762 "If this is not correct, please remove the file\n"
763 " %s\n"
764 "and try again.\n")
765 : _("\n"
766 "It looks like you may be committing a cherry-pick.\n"
767 "If this is not correct, please remove the file\n"
768 " %s\n"
769 "and try again.\n"),
770 git_path(whence == FROM_MERGE
771 ? "MERGE_HEAD"
772 : "CHERRY_PICK_HEAD"));
773
774 fprintf(s->fp, "\n");
775 if (cleanup_mode == CLEANUP_ALL)
776 status_printf(s, GIT_COLOR_NORMAL,
777 _("Please enter the commit message for your changes."
778 " Lines starting\nwith '%c' will be ignored, and an empty"
779 " message aborts the commit.\n"), comment_line_char);
780 else /* CLEANUP_SPACE, that is. */
781 status_printf(s, GIT_COLOR_NORMAL,
782 _("Please enter the commit message for your changes."
783 " Lines starting\n"
784 "with '%c' will be kept; you may remove them"
785 " yourself if you want to.\n"
786 "An empty message aborts the commit.\n"), comment_line_char);
787 if (only_include_assumed)
788 status_printf_ln(s, GIT_COLOR_NORMAL,
789 "%s", only_include_assumed);
790
791 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
792 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
793 if (strcmp(author_ident->buf, committer_ident.buf))
794 status_printf_ln(s, GIT_COLOR_NORMAL,
795 _("%s"
796 "Author: %s"),
797 ident_shown++ ? "" : "\n",
798 author_ident->buf);
799
800 if (!committer_ident_sufficiently_given())
801 status_printf_ln(s, GIT_COLOR_NORMAL,
802 _("%s"
803 "Committer: %s"),
804 ident_shown++ ? "" : "\n",
805 committer_ident.buf);
806
807 if (ident_shown)
808 status_printf_ln(s, GIT_COLOR_NORMAL, "");
809
810 saved_color_setting = s->use_color;
811 s->use_color = 0;
812 commitable = run_status(s->fp, index_file, prefix, 1, s);
813 s->use_color = saved_color_setting;
814
815 *ai_tmp = ' ';
816 *ci_tmp = ' ';
817 } else {
818 unsigned char sha1[20];
819 const char *parent = "HEAD";
820
821 if (!active_nr && read_cache() < 0)
822 die(_("Cannot read index"));
823
824 if (amend)
825 parent = "HEAD^1";
826
827 if (get_sha1(parent, sha1))
828 commitable = !!active_nr;
829 else
830 commitable = index_differs_from(parent, 0);
831 }
832 strbuf_release(&committer_ident);
833
834 fclose(s->fp);
835
836 /*
837 * Reject an attempt to record a non-merge empty commit without
838 * explicit --allow-empty. In the cherry-pick case, it may be
839 * empty due to conflict resolution, which the user should okay.
840 */
841 if (!commitable && whence != FROM_MERGE && !allow_empty &&
842 !(amend && is_a_merge(current_head))) {
843 s->display_comment_prefix = old_display_comment_prefix;
844 run_status(stdout, index_file, prefix, 0, s);
845 if (amend)
846 fputs(_(empty_amend_advice), stderr);
847 else if (whence == FROM_CHERRY_PICK) {
848 fputs(_(empty_cherry_pick_advice), stderr);
849 if (!sequencer_in_use)
850 fputs(_(empty_cherry_pick_advice_single), stderr);
851 else
852 fputs(_(empty_cherry_pick_advice_multi), stderr);
853 }
854 return 0;
855 }
856
857 /*
858 * Re-read the index as pre-commit hook could have updated it,
859 * and write it out as a tree. We must do this before we invoke
860 * the editor and after we invoke run_status above.
861 */
862 discard_cache();
863 read_cache_from(index_file);
864 if (update_main_cache_tree(0)) {
865 error(_("Error building trees"));
866 return 0;
867 }
868
869 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
870 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
871 return 0;
872
873 if (use_editor) {
874 char index[PATH_MAX];
875 const char *env[2] = { NULL };
876 env[0] = index;
877 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
878 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
879 fprintf(stderr,
880 _("Please supply the message using either -m or -F option.\n"));
881 exit(1);
882 }
883 }
884
885 if (!no_verify &&
886 run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
887 return 0;
888 }
889
890 return 1;
891 }
892
893 static int rest_is_empty(struct strbuf *sb, int start)
894 {
895 int i, eol;
896 const char *nl;
897
898 /* Check if the rest is just whitespace and Signed-of-by's. */
899 for (i = start; i < sb->len; i++) {
900 nl = memchr(sb->buf + i, '\n', sb->len - i);
901 if (nl)
902 eol = nl - sb->buf;
903 else
904 eol = sb->len;
905
906 if (strlen(sign_off_header) <= eol - i &&
907 starts_with(sb->buf + i, sign_off_header)) {
908 i = eol;
909 continue;
910 }
911 while (i < eol)
912 if (!isspace(sb->buf[i++]))
913 return 0;
914 }
915
916 return 1;
917 }
918
919 /*
920 * Find out if the message in the strbuf contains only whitespace and
921 * Signed-off-by lines.
922 */
923 static int message_is_empty(struct strbuf *sb)
924 {
925 if (cleanup_mode == CLEANUP_NONE && sb->len)
926 return 0;
927 return rest_is_empty(sb, 0);
928 }
929
930 /*
931 * See if the user edited the message in the editor or left what
932 * was in the template intact
933 */
934 static int template_untouched(struct strbuf *sb)
935 {
936 struct strbuf tmpl = STRBUF_INIT;
937 char *start;
938
939 if (cleanup_mode == CLEANUP_NONE && sb->len)
940 return 0;
941
942 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
943 return 0;
944
945 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
946 start = (char *)skip_prefix(sb->buf, tmpl.buf);
947 if (!start)
948 start = sb->buf;
949 strbuf_release(&tmpl);
950 return rest_is_empty(sb, start - sb->buf);
951 }
952
953 static const char *find_author_by_nickname(const char *name)
954 {
955 struct rev_info revs;
956 struct commit *commit;
957 struct strbuf buf = STRBUF_INIT;
958 struct string_list mailmap = STRING_LIST_INIT_NODUP;
959 const char *av[20];
960 int ac = 0;
961
962 init_revisions(&revs, NULL);
963 strbuf_addf(&buf, "--author=%s", name);
964 av[++ac] = "--all";
965 av[++ac] = "-i";
966 av[++ac] = buf.buf;
967 av[++ac] = NULL;
968 setup_revisions(ac, av, &revs, NULL);
969 revs.mailmap = &mailmap;
970 read_mailmap(revs.mailmap, NULL);
971
972 prepare_revision_walk(&revs);
973 commit = get_revision(&revs);
974 if (commit) {
975 struct pretty_print_context ctx = {0};
976 ctx.date_mode = DATE_NORMAL;
977 strbuf_release(&buf);
978 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
979 clear_mailmap(&mailmap);
980 return strbuf_detach(&buf, NULL);
981 }
982 die(_("No existing author found with '%s'"), name);
983 }
984
985
986 static void handle_untracked_files_arg(struct wt_status *s)
987 {
988 if (!untracked_files_arg)
989 ; /* default already initialized */
990 else if (!strcmp(untracked_files_arg, "no"))
991 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
992 else if (!strcmp(untracked_files_arg, "normal"))
993 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
994 else if (!strcmp(untracked_files_arg, "all"))
995 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
996 else
997 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
998 }
999
1000 static const char *read_commit_message(const char *name)
1001 {
1002 const char *out_enc;
1003 struct commit *commit;
1004
1005 commit = lookup_commit_reference_by_name(name);
1006 if (!commit)
1007 die(_("could not lookup commit %s"), name);
1008 out_enc = get_commit_output_encoding();
1009 return logmsg_reencode(commit, NULL, out_enc);
1010 }
1011
1012 /*
1013 * Enumerate what needs to be propagated when --porcelain
1014 * is not in effect here.
1015 */
1016 static struct status_deferred_config {
1017 enum status_format status_format;
1018 int show_branch;
1019 } status_deferred_config = {
1020 STATUS_FORMAT_UNSPECIFIED,
1021 -1 /* unspecified */
1022 };
1023
1024 static void finalize_deferred_config(struct wt_status *s)
1025 {
1026 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1027 !s->null_termination);
1028
1029 if (s->null_termination) {
1030 if (status_format == STATUS_FORMAT_NONE ||
1031 status_format == STATUS_FORMAT_UNSPECIFIED)
1032 status_format = STATUS_FORMAT_PORCELAIN;
1033 else if (status_format == STATUS_FORMAT_LONG)
1034 die(_("--long and -z are incompatible"));
1035 }
1036
1037 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1038 status_format = status_deferred_config.status_format;
1039 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1040 status_format = STATUS_FORMAT_NONE;
1041
1042 if (use_deferred_config && s->show_branch < 0)
1043 s->show_branch = status_deferred_config.show_branch;
1044 if (s->show_branch < 0)
1045 s->show_branch = 0;
1046 }
1047
1048 static int parse_and_validate_options(int argc, const char *argv[],
1049 const struct option *options,
1050 const char * const usage[],
1051 const char *prefix,
1052 struct commit *current_head,
1053 struct wt_status *s)
1054 {
1055 int f = 0;
1056
1057 argc = parse_options(argc, argv, prefix, options, usage, 0);
1058 finalize_deferred_config(s);
1059
1060 if (force_author && !strchr(force_author, '>'))
1061 force_author = find_author_by_nickname(force_author);
1062
1063 if (force_author && renew_authorship)
1064 die(_("Using both --reset-author and --author does not make sense"));
1065
1066 if (logfile || have_option_m || use_message || fixup_message)
1067 use_editor = 0;
1068 if (0 <= edit_flag)
1069 use_editor = edit_flag;
1070
1071 /* Sanity check options */
1072 if (amend && !current_head)
1073 die(_("You have nothing to amend."));
1074 if (amend && whence != FROM_COMMIT) {
1075 if (whence == FROM_MERGE)
1076 die(_("You are in the middle of a merge -- cannot amend."));
1077 else if (whence == FROM_CHERRY_PICK)
1078 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1079 }
1080 if (fixup_message && squash_message)
1081 die(_("Options --squash and --fixup cannot be used together"));
1082 if (use_message)
1083 f++;
1084 if (edit_message)
1085 f++;
1086 if (fixup_message)
1087 f++;
1088 if (logfile)
1089 f++;
1090 if (f > 1)
1091 die(_("Only one of -c/-C/-F/--fixup can be used."));
1092 if (message.len && f > 0)
1093 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1094 if (f || message.len)
1095 template_file = NULL;
1096 if (edit_message)
1097 use_message = edit_message;
1098 if (amend && !use_message && !fixup_message)
1099 use_message = "HEAD";
1100 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1101 die(_("--reset-author can be used only with -C, -c or --amend."));
1102 if (use_message) {
1103 use_message_buffer = read_commit_message(use_message);
1104 if (!renew_authorship) {
1105 author_message = use_message;
1106 author_message_buffer = use_message_buffer;
1107 }
1108 }
1109 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1110 author_message = "CHERRY_PICK_HEAD";
1111 author_message_buffer = read_commit_message(author_message);
1112 }
1113
1114 if (patch_interactive)
1115 interactive = 1;
1116
1117 if (also + only + all + interactive > 1)
1118 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1119 if (argc == 0 && (also || (only && !amend)))
1120 die(_("No paths with --include/--only does not make sense."));
1121 if (argc == 0 && only && amend)
1122 only_include_assumed = _("Clever... amending the last one with dirty index.");
1123 if (argc > 0 && !also && !only)
1124 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1125 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1126 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1127 else if (!strcmp(cleanup_arg, "verbatim"))
1128 cleanup_mode = CLEANUP_NONE;
1129 else if (!strcmp(cleanup_arg, "whitespace"))
1130 cleanup_mode = CLEANUP_SPACE;
1131 else if (!strcmp(cleanup_arg, "strip"))
1132 cleanup_mode = CLEANUP_ALL;
1133 else
1134 die(_("Invalid cleanup mode %s"), cleanup_arg);
1135
1136 handle_untracked_files_arg(s);
1137
1138 if (all && argc > 0)
1139 die(_("Paths with -a does not make sense."));
1140
1141 if (status_format != STATUS_FORMAT_NONE)
1142 dry_run = 1;
1143
1144 return argc;
1145 }
1146
1147 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1148 const struct commit *current_head, struct wt_status *s)
1149 {
1150 int commitable;
1151 const char *index_file;
1152
1153 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1154 commitable = run_status(stdout, index_file, prefix, 0, s);
1155 rollback_index_files();
1156
1157 return commitable ? 0 : 1;
1158 }
1159
1160 static int parse_status_slot(const char *var, int offset)
1161 {
1162 if (!strcasecmp(var+offset, "header"))
1163 return WT_STATUS_HEADER;
1164 if (!strcasecmp(var+offset, "branch"))
1165 return WT_STATUS_ONBRANCH;
1166 if (!strcasecmp(var+offset, "updated")
1167 || !strcasecmp(var+offset, "added"))
1168 return WT_STATUS_UPDATED;
1169 if (!strcasecmp(var+offset, "changed"))
1170 return WT_STATUS_CHANGED;
1171 if (!strcasecmp(var+offset, "untracked"))
1172 return WT_STATUS_UNTRACKED;
1173 if (!strcasecmp(var+offset, "nobranch"))
1174 return WT_STATUS_NOBRANCH;
1175 if (!strcasecmp(var+offset, "unmerged"))
1176 return WT_STATUS_UNMERGED;
1177 return -1;
1178 }
1179
1180 static int git_status_config(const char *k, const char *v, void *cb)
1181 {
1182 struct wt_status *s = cb;
1183
1184 if (starts_with(k, "column."))
1185 return git_column_config(k, v, "status", &s->colopts);
1186 if (!strcmp(k, "status.submodulesummary")) {
1187 int is_bool;
1188 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1189 if (is_bool && s->submodule_summary)
1190 s->submodule_summary = -1;
1191 return 0;
1192 }
1193 if (!strcmp(k, "status.short")) {
1194 if (git_config_bool(k, v))
1195 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1196 else
1197 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1198 return 0;
1199 }
1200 if (!strcmp(k, "status.branch")) {
1201 status_deferred_config.show_branch = git_config_bool(k, v);
1202 return 0;
1203 }
1204 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1205 s->use_color = git_config_colorbool(k, v);
1206 return 0;
1207 }
1208 if (!strcmp(k, "status.displaycommentprefix")) {
1209 s->display_comment_prefix = git_config_bool(k, v);
1210 return 0;
1211 }
1212 if (starts_with(k, "status.color.") || starts_with(k, "color.status.")) {
1213 int slot = parse_status_slot(k, 13);
1214 if (slot < 0)
1215 return 0;
1216 if (!v)
1217 return config_error_nonbool(k);
1218 color_parse(v, k, s->color_palette[slot]);
1219 return 0;
1220 }
1221 if (!strcmp(k, "status.relativepaths")) {
1222 s->relative_paths = git_config_bool(k, v);
1223 return 0;
1224 }
1225 if (!strcmp(k, "status.showuntrackedfiles")) {
1226 if (!v)
1227 return config_error_nonbool(k);
1228 else if (!strcmp(v, "no"))
1229 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1230 else if (!strcmp(v, "normal"))
1231 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1232 else if (!strcmp(v, "all"))
1233 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1234 else
1235 return error(_("Invalid untracked files mode '%s'"), v);
1236 return 0;
1237 }
1238 return git_diff_ui_config(k, v, NULL);
1239 }
1240
1241 int cmd_status(int argc, const char **argv, const char *prefix)
1242 {
1243 static struct wt_status s;
1244 int fd;
1245 unsigned char sha1[20];
1246 static struct option builtin_status_options[] = {
1247 OPT__VERBOSE(&verbose, N_("be verbose")),
1248 OPT_SET_INT('s', "short", &status_format,
1249 N_("show status concisely"), STATUS_FORMAT_SHORT),
1250 OPT_BOOL('b', "branch", &s.show_branch,
1251 N_("show branch information")),
1252 OPT_SET_INT(0, "porcelain", &status_format,
1253 N_("machine-readable output"),
1254 STATUS_FORMAT_PORCELAIN),
1255 OPT_SET_INT(0, "long", &status_format,
1256 N_("show status in long format (default)"),
1257 STATUS_FORMAT_LONG),
1258 OPT_BOOL('z', "null", &s.null_termination,
1259 N_("terminate entries with NUL")),
1260 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1261 N_("mode"),
1262 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1263 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1264 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1265 N_("show ignored files")),
1266 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1267 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1268 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1269 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1270 OPT_END(),
1271 };
1272
1273 if (argc == 2 && !strcmp(argv[1], "-h"))
1274 usage_with_options(builtin_status_usage, builtin_status_options);
1275
1276 status_init_config(&s, git_status_config);
1277 argc = parse_options(argc, argv, prefix,
1278 builtin_status_options,
1279 builtin_status_usage, 0);
1280 finalize_colopts(&s.colopts, -1);
1281 finalize_deferred_config(&s);
1282
1283 handle_untracked_files_arg(&s);
1284 if (show_ignored_in_status)
1285 s.show_ignored_files = 1;
1286 parse_pathspec(&s.pathspec, 0,
1287 PATHSPEC_PREFER_FULL,
1288 prefix, argv);
1289
1290 read_cache_preload(&s.pathspec);
1291 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1292
1293 fd = hold_locked_index(&index_lock, 0);
1294 if (0 <= fd)
1295 update_index_if_able(&the_index, &index_lock);
1296
1297 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1298 s.ignore_submodule_arg = ignore_submodule_arg;
1299 wt_status_collect(&s);
1300
1301 if (s.relative_paths)
1302 s.prefix = prefix;
1303
1304 switch (status_format) {
1305 case STATUS_FORMAT_SHORT:
1306 wt_shortstatus_print(&s);
1307 break;
1308 case STATUS_FORMAT_PORCELAIN:
1309 wt_porcelain_print(&s);
1310 break;
1311 case STATUS_FORMAT_UNSPECIFIED:
1312 die("BUG: finalize_deferred_config() should have been called");
1313 break;
1314 case STATUS_FORMAT_NONE:
1315 case STATUS_FORMAT_LONG:
1316 s.verbose = verbose;
1317 s.ignore_submodule_arg = ignore_submodule_arg;
1318 wt_status_print(&s);
1319 break;
1320 }
1321 return 0;
1322 }
1323
1324 static void print_summary(const char *prefix, const unsigned char *sha1,
1325 int initial_commit)
1326 {
1327 struct rev_info rev;
1328 struct commit *commit;
1329 struct strbuf format = STRBUF_INIT;
1330 unsigned char junk_sha1[20];
1331 const char *head;
1332 struct pretty_print_context pctx = {0};
1333 struct strbuf author_ident = STRBUF_INIT;
1334 struct strbuf committer_ident = STRBUF_INIT;
1335
1336 commit = lookup_commit(sha1);
1337 if (!commit)
1338 die(_("couldn't look up newly created commit"));
1339 if (parse_commit(commit))
1340 die(_("could not parse newly created commit"));
1341
1342 strbuf_addstr(&format, "format:%h] %s");
1343
1344 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1345 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1346 if (strbuf_cmp(&author_ident, &committer_ident)) {
1347 strbuf_addstr(&format, "\n Author: ");
1348 strbuf_addbuf_percentquote(&format, &author_ident);
1349 }
1350 if (!committer_ident_sufficiently_given()) {
1351 strbuf_addstr(&format, "\n Committer: ");
1352 strbuf_addbuf_percentquote(&format, &committer_ident);
1353 if (advice_implicit_identity) {
1354 strbuf_addch(&format, '\n');
1355 strbuf_addstr(&format, _(implicit_ident_advice));
1356 }
1357 }
1358 strbuf_release(&author_ident);
1359 strbuf_release(&committer_ident);
1360
1361 init_revisions(&rev, prefix);
1362 setup_revisions(0, NULL, &rev, NULL);
1363
1364 rev.diff = 1;
1365 rev.diffopt.output_format =
1366 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1367
1368 rev.verbose_header = 1;
1369 rev.show_root_diff = 1;
1370 get_commit_format(format.buf, &rev);
1371 rev.always_show_header = 0;
1372 rev.diffopt.detect_rename = 1;
1373 rev.diffopt.break_opt = 0;
1374 diff_setup_done(&rev.diffopt);
1375
1376 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1377 printf("[%s%s ",
1378 starts_with(head, "refs/heads/") ?
1379 head + 11 :
1380 !strcmp(head, "HEAD") ?
1381 _("detached HEAD") :
1382 head,
1383 initial_commit ? _(" (root-commit)") : "");
1384
1385 if (!log_tree_commit(&rev, commit)) {
1386 rev.always_show_header = 1;
1387 rev.use_terminator = 1;
1388 log_tree_commit(&rev, commit);
1389 }
1390
1391 strbuf_release(&format);
1392 }
1393
1394 static int git_commit_config(const char *k, const char *v, void *cb)
1395 {
1396 struct wt_status *s = cb;
1397 int status;
1398
1399 if (!strcmp(k, "commit.template"))
1400 return git_config_pathname(&template_file, k, v);
1401 if (!strcmp(k, "commit.status")) {
1402 include_status = git_config_bool(k, v);
1403 return 0;
1404 }
1405 if (!strcmp(k, "commit.cleanup"))
1406 return git_config_string(&cleanup_arg, k, v);
1407
1408 status = git_gpg_config(k, v, NULL);
1409 if (status)
1410 return status;
1411 return git_status_config(k, v, s);
1412 }
1413
1414 static int run_rewrite_hook(const unsigned char *oldsha1,
1415 const unsigned char *newsha1)
1416 {
1417 /* oldsha1 SP newsha1 LF NUL */
1418 static char buf[2*40 + 3];
1419 struct child_process proc;
1420 const char *argv[3];
1421 int code;
1422 size_t n;
1423
1424 argv[0] = find_hook("post-rewrite");
1425 if (!argv[0])
1426 return 0;
1427
1428 argv[1] = "amend";
1429 argv[2] = NULL;
1430
1431 memset(&proc, 0, sizeof(proc));
1432 proc.argv = argv;
1433 proc.in = -1;
1434 proc.stdout_to_stderr = 1;
1435
1436 code = start_command(&proc);
1437 if (code)
1438 return code;
1439 n = snprintf(buf, sizeof(buf), "%s %s\n",
1440 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1441 write_in_full(proc.in, buf, n);
1442 close(proc.in);
1443 return finish_command(&proc);
1444 }
1445
1446 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1447 {
1448 const char *hook_env[3] = { NULL };
1449 char index[PATH_MAX];
1450 va_list args;
1451 int ret;
1452
1453 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1454 hook_env[0] = index;
1455
1456 /*
1457 * Let the hook know that no editor will be launched.
1458 */
1459 if (!editor_is_used)
1460 hook_env[1] = "GIT_EDITOR=:";
1461
1462 va_start(args, name);
1463 ret = run_hook_ve(hook_env, name, args);
1464 va_end(args);
1465
1466 return ret;
1467 }
1468
1469 int cmd_commit(int argc, const char **argv, const char *prefix)
1470 {
1471 static struct wt_status s;
1472 static struct option builtin_commit_options[] = {
1473 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1474 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1475
1476 OPT_GROUP(N_("Commit message options")),
1477 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1478 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1479 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1480 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1481 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1482 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1483 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1484 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1485 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1486 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1487 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1488 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1489 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1490 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1491 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1492 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1493 /* end commit message options */
1494
1495 OPT_GROUP(N_("Commit contents options")),
1496 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1497 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1498 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1499 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1500 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1501 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1502 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1503 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1504 STATUS_FORMAT_SHORT),
1505 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1506 OPT_SET_INT(0, "porcelain", &status_format,
1507 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1508 OPT_SET_INT(0, "long", &status_format,
1509 N_("show status in long format (default)"),
1510 STATUS_FORMAT_LONG),
1511 OPT_BOOL('z', "null", &s.null_termination,
1512 N_("terminate entries with NUL")),
1513 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1514 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1515 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, N_("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)"), PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1516 /* end commit contents options */
1517
1518 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1519 N_("ok to record an empty change")),
1520 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1521 N_("ok to record a change with an empty message")),
1522
1523 OPT_END()
1524 };
1525
1526 struct strbuf sb = STRBUF_INIT;
1527 struct strbuf author_ident = STRBUF_INIT;
1528 const char *index_file, *reflog_msg;
1529 char *nl;
1530 unsigned char sha1[20];
1531 struct ref_lock *ref_lock;
1532 struct commit_list *parents = NULL, **pptr = &parents;
1533 struct stat statbuf;
1534 int allow_fast_forward = 1;
1535 struct commit *current_head = NULL;
1536 struct commit_extra_header *extra = NULL;
1537
1538 if (argc == 2 && !strcmp(argv[1], "-h"))
1539 usage_with_options(builtin_commit_usage, builtin_commit_options);
1540
1541 status_init_config(&s, git_commit_config);
1542 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1543 s.colopts = 0;
1544
1545 if (get_sha1("HEAD", sha1))
1546 current_head = NULL;
1547 else {
1548 current_head = lookup_commit_or_die(sha1, "HEAD");
1549 if (parse_commit(current_head))
1550 die(_("could not parse HEAD commit"));
1551 }
1552 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1553 builtin_commit_usage,
1554 prefix, current_head, &s);
1555 if (dry_run)
1556 return dry_run_commit(argc, argv, prefix, current_head, &s);
1557 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1558
1559 /* Set up everything for writing the commit object. This includes
1560 running hooks, writing the trees, and interacting with the user. */
1561 if (!prepare_to_commit(index_file, prefix,
1562 current_head, &s, &author_ident)) {
1563 rollback_index_files();
1564 return 1;
1565 }
1566
1567 /* Determine parents */
1568 reflog_msg = getenv("GIT_REFLOG_ACTION");
1569 if (!current_head) {
1570 if (!reflog_msg)
1571 reflog_msg = "commit (initial)";
1572 } else if (amend) {
1573 struct commit_list *c;
1574
1575 if (!reflog_msg)
1576 reflog_msg = "commit (amend)";
1577 for (c = current_head->parents; c; c = c->next)
1578 pptr = &commit_list_insert(c->item, pptr)->next;
1579 } else if (whence == FROM_MERGE) {
1580 struct strbuf m = STRBUF_INIT;
1581 FILE *fp;
1582
1583 if (!reflog_msg)
1584 reflog_msg = "commit (merge)";
1585 pptr = &commit_list_insert(current_head, pptr)->next;
1586 fp = fopen(git_path("MERGE_HEAD"), "r");
1587 if (fp == NULL)
1588 die_errno(_("could not open '%s' for reading"),
1589 git_path("MERGE_HEAD"));
1590 while (strbuf_getline(&m, fp, '\n') != EOF) {
1591 struct commit *parent;
1592
1593 parent = get_merge_parent(m.buf);
1594 if (!parent)
1595 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1596 pptr = &commit_list_insert(parent, pptr)->next;
1597 }
1598 fclose(fp);
1599 strbuf_release(&m);
1600 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1601 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1602 die_errno(_("could not read MERGE_MODE"));
1603 if (!strcmp(sb.buf, "no-ff"))
1604 allow_fast_forward = 0;
1605 }
1606 if (allow_fast_forward)
1607 parents = reduce_heads(parents);
1608 } else {
1609 if (!reflog_msg)
1610 reflog_msg = (whence == FROM_CHERRY_PICK)
1611 ? "commit (cherry-pick)"
1612 : "commit";
1613 pptr = &commit_list_insert(current_head, pptr)->next;
1614 }
1615
1616 /* Finally, get the commit message */
1617 strbuf_reset(&sb);
1618 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1619 int saved_errno = errno;
1620 rollback_index_files();
1621 die(_("could not read commit message: %s"), strerror(saved_errno));
1622 }
1623
1624 /* Truncate the message just before the diff, if any. */
1625 if (verbose)
1626 wt_status_truncate_message_at_cut_line(&sb);
1627
1628 if (cleanup_mode != CLEANUP_NONE)
1629 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1630 if (template_untouched(&sb) && !allow_empty_message) {
1631 rollback_index_files();
1632 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1633 exit(1);
1634 }
1635 if (message_is_empty(&sb) && !allow_empty_message) {
1636 rollback_index_files();
1637 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1638 exit(1);
1639 }
1640
1641 if (amend) {
1642 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1643 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1644 } else {
1645 struct commit_extra_header **tail = &extra;
1646 append_merge_tag_headers(parents, &tail);
1647 }
1648
1649 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1650 author_ident.buf, sign_commit, extra)) {
1651 rollback_index_files();
1652 die(_("failed to write commit object"));
1653 }
1654 strbuf_release(&author_ident);
1655 free_commit_extra_headers(extra);
1656
1657 ref_lock = lock_any_ref_for_update("HEAD",
1658 !current_head
1659 ? NULL
1660 : current_head->object.sha1,
1661 0, NULL);
1662
1663 nl = strchr(sb.buf, '\n');
1664 if (nl)
1665 strbuf_setlen(&sb, nl + 1 - sb.buf);
1666 else
1667 strbuf_addch(&sb, '\n');
1668 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1669 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1670
1671 if (!ref_lock) {
1672 rollback_index_files();
1673 die(_("cannot lock HEAD ref"));
1674 }
1675 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1676 rollback_index_files();
1677 die(_("cannot update HEAD ref"));
1678 }
1679
1680 unlink(git_path("CHERRY_PICK_HEAD"));
1681 unlink(git_path("REVERT_HEAD"));
1682 unlink(git_path("MERGE_HEAD"));
1683 unlink(git_path("MERGE_MSG"));
1684 unlink(git_path("MERGE_MODE"));
1685 unlink(git_path("SQUASH_MSG"));
1686
1687 if (commit_index_files())
1688 die (_("Repository has been updated, but unable to write\n"
1689 "new_index file. Check that disk is not full or quota is\n"
1690 "not exceeded, and then \"git reset HEAD\" to recover."));
1691
1692 rerere(0);
1693 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1694 if (amend && !no_post_rewrite) {
1695 struct notes_rewrite_cfg *cfg;
1696 cfg = init_copy_notes_for_rewrite("amend");
1697 if (cfg) {
1698 /* we are amending, so current_head is not NULL */
1699 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1700 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1701 }
1702 run_rewrite_hook(current_head->object.sha1, sha1);
1703 }
1704 if (!quiet)
1705 print_summary(prefix, sha1, !current_head);
1706
1707 return 0;
1708 }