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