replace memset with string-list initializers
[git.git] / builtin / commit.c
blob023df406f836b5709cbd85396a6c9bd70cbcdefb
1 /*
2 * Builtin "git commit"
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
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"
35 static const char * const builtin_commit_usage[] = {
36 N_("git commit [options] [--] <pathspec>..."),
37 NULL
40 static const char * const builtin_status_usage[] = {
41 N_("git status [options] [--] <pathspec>..."),
42 NULL
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");
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");
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");
69 static const char empty_cherry_pick_advice_single[] =
70 N_("Otherwise, please use 'git reset'\n");
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");
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;
90 static const char *logfile, *force_author;
91 static const char *template_file;
93 * The _message variables are commit names from which to take
94 * the commit message and/or authorship.
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;
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.
113 static enum {
114 CLEANUP_SPACE,
115 CLEANUP_NONE,
116 CLEANUP_SCISSORS,
117 CLEANUP_ALL
118 } cleanup_mode;
119 static const char *cleanup_arg;
121 static enum commit_whence whence;
122 static int sequencer_in_use;
123 static int use_editor = 1, include_status = 1;
124 static int show_ignored_in_status, have_option_m;
125 static const char *only_include_assumed;
126 static struct strbuf message = STRBUF_INIT;
128 static enum status_format {
129 STATUS_FORMAT_NONE = 0,
130 STATUS_FORMAT_LONG,
131 STATUS_FORMAT_SHORT,
132 STATUS_FORMAT_PORCELAIN,
134 STATUS_FORMAT_UNSPECIFIED
135 } status_format = STATUS_FORMAT_UNSPECIFIED;
137 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
139 struct strbuf *buf = opt->value;
140 if (unset) {
141 have_option_m = 0;
142 strbuf_setlen(buf, 0);
143 } else {
144 have_option_m = 1;
145 if (buf->len)
146 strbuf_addch(buf, '\n');
147 strbuf_addstr(buf, arg);
148 strbuf_complete_line(buf);
150 return 0;
153 static void determine_whence(struct wt_status *s)
155 if (file_exists(git_path("MERGE_HEAD")))
156 whence = FROM_MERGE;
157 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
158 whence = FROM_CHERRY_PICK;
159 if (file_exists(git_path("sequencer")))
160 sequencer_in_use = 1;
162 else
163 whence = FROM_COMMIT;
164 if (s)
165 s->whence = whence;
168 static void status_init_config(struct wt_status *s, config_fn_t fn)
170 wt_status_prepare(s);
171 gitmodules_config();
172 git_config(fn, s);
173 determine_whence(s);
174 s->hints = advice_status_hints; /* must come after git_config() */
177 static void rollback_index_files(void)
179 switch (commit_style) {
180 case COMMIT_AS_IS:
181 break; /* nothing to do */
182 case COMMIT_NORMAL:
183 rollback_lock_file(&index_lock);
184 break;
185 case COMMIT_PARTIAL:
186 rollback_lock_file(&index_lock);
187 rollback_lock_file(&false_lock);
188 break;
192 static int commit_index_files(void)
194 int err = 0;
196 switch (commit_style) {
197 case COMMIT_AS_IS:
198 break; /* nothing to do */
199 case COMMIT_NORMAL:
200 err = commit_lock_file(&index_lock);
201 break;
202 case COMMIT_PARTIAL:
203 err = commit_lock_file(&index_lock);
204 rollback_lock_file(&false_lock);
205 break;
208 return err;
212 * Take a union of paths in the index and the named tree (typically, "HEAD"),
213 * and return the paths that match the given pattern in list.
215 static int list_paths(struct string_list *list, const char *with_tree,
216 const char *prefix, const struct pathspec *pattern)
218 int i;
219 char *m;
221 if (!pattern->nr)
222 return 0;
224 m = xcalloc(1, pattern->nr);
226 if (with_tree) {
227 char *max_prefix = common_prefix(pattern);
228 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
229 free(max_prefix);
232 for (i = 0; i < active_nr; i++) {
233 const struct cache_entry *ce = active_cache[i];
234 struct string_list_item *item;
236 if (ce->ce_flags & CE_UPDATE)
237 continue;
238 if (!ce_path_match(ce, pattern, m))
239 continue;
240 item = string_list_insert(list, ce->name);
241 if (ce_skip_worktree(ce))
242 item->util = item; /* better a valid pointer than a fake one */
245 return report_path_error(m, pattern, prefix);
248 static void add_remove_files(struct string_list *list)
250 int i;
251 for (i = 0; i < list->nr; i++) {
252 struct stat st;
253 struct string_list_item *p = &(list->items[i]);
255 /* p->util is skip-worktree */
256 if (p->util)
257 continue;
259 if (!lstat(p->string, &st)) {
260 if (add_to_cache(p->string, &st, 0))
261 die(_("updating files failed"));
262 } else
263 remove_file_from_cache(p->string);
267 static void create_base_index(const struct commit *current_head)
269 struct tree *tree;
270 struct unpack_trees_options opts;
271 struct tree_desc t;
273 if (!current_head) {
274 discard_cache();
275 return;
278 memset(&opts, 0, sizeof(opts));
279 opts.head_idx = 1;
280 opts.index_only = 1;
281 opts.merge = 1;
282 opts.src_index = &the_index;
283 opts.dst_index = &the_index;
285 opts.fn = oneway_merge;
286 tree = parse_tree_indirect(current_head->object.sha1);
287 if (!tree)
288 die(_("failed to unpack HEAD tree object"));
289 parse_tree(tree);
290 init_tree_desc(&t, tree->buffer, tree->size);
291 if (unpack_trees(1, &t, &opts))
292 exit(128); /* We've already reported the error, finish dying */
295 static void refresh_cache_or_die(int refresh_flags)
298 * refresh_flags contains REFRESH_QUIET, so the only errors
299 * are for unmerged entries.
301 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
302 die_resolve_conflict("commit");
305 static char *prepare_index(int argc, const char **argv, const char *prefix,
306 const struct commit *current_head, int is_status)
308 int fd;
309 struct string_list partial;
310 struct pathspec pathspec;
311 int refresh_flags = REFRESH_QUIET;
313 if (is_status)
314 refresh_flags |= REFRESH_UNMERGED;
315 parse_pathspec(&pathspec, 0,
316 PATHSPEC_PREFER_FULL,
317 prefix, argv);
319 if (read_cache_preload(&pathspec) < 0)
320 die(_("index file corrupt"));
322 if (interactive) {
323 char *old_index_env = NULL;
324 fd = hold_locked_index(&index_lock, 1);
326 refresh_cache_or_die(refresh_flags);
328 if (write_cache(fd, active_cache, active_nr) ||
329 close_lock_file(&index_lock))
330 die(_("unable to create temporary index"));
332 old_index_env = getenv(INDEX_ENVIRONMENT);
333 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
335 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
336 die(_("interactive add failed"));
338 if (old_index_env && *old_index_env)
339 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
340 else
341 unsetenv(INDEX_ENVIRONMENT);
343 discard_cache();
344 read_cache_from(index_lock.filename);
346 commit_style = COMMIT_NORMAL;
347 return index_lock.filename;
351 * Non partial, non as-is commit.
353 * (1) get the real index;
354 * (2) update the_index as necessary;
355 * (3) write the_index out to the real index (still locked);
356 * (4) return the name of the locked index file.
358 * The caller should run hooks on the locked real index, and
359 * (A) if all goes well, commit the real index;
360 * (B) on failure, rollback the real index.
362 if (all || (also && pathspec.nr)) {
363 fd = hold_locked_index(&index_lock, 1);
364 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
365 refresh_cache_or_die(refresh_flags);
366 update_main_cache_tree(WRITE_TREE_SILENT);
367 if (write_cache(fd, active_cache, active_nr) ||
368 close_lock_file(&index_lock))
369 die(_("unable to write new_index file"));
370 commit_style = COMMIT_NORMAL;
371 return index_lock.filename;
375 * As-is commit.
377 * (1) return the name of the real index file.
379 * The caller should run hooks on the real index,
380 * and create commit from the_index.
381 * We still need to refresh the index here.
383 if (!only && !pathspec.nr) {
384 fd = hold_locked_index(&index_lock, 1);
385 refresh_cache_or_die(refresh_flags);
386 if (active_cache_changed) {
387 update_main_cache_tree(WRITE_TREE_SILENT);
388 if (write_cache(fd, active_cache, active_nr) ||
389 commit_locked_index(&index_lock))
390 die(_("unable to write new_index file"));
391 } else {
392 rollback_lock_file(&index_lock);
394 commit_style = COMMIT_AS_IS;
395 return get_index_file();
399 * A partial commit.
401 * (0) find the set of affected paths;
402 * (1) get lock on the real index file;
403 * (2) update the_index with the given paths;
404 * (3) write the_index out to the real index (still locked);
405 * (4) get lock on the false index file;
406 * (5) reset the_index from HEAD;
407 * (6) update the_index the same way as (2);
408 * (7) write the_index out to the false index file;
409 * (8) return the name of the false index file (still locked);
411 * The caller should run hooks on the locked false index, and
412 * create commit from it. Then
413 * (A) if all goes well, commit the real index;
414 * (B) on failure, rollback the real index;
415 * In either case, rollback the false index.
417 commit_style = COMMIT_PARTIAL;
419 if (whence != FROM_COMMIT) {
420 if (whence == FROM_MERGE)
421 die(_("cannot do a partial commit during a merge."));
422 else if (whence == FROM_CHERRY_PICK)
423 die(_("cannot do a partial commit during a cherry-pick."));
426 string_list_init(&partial, 1);
427 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
428 exit(1);
430 discard_cache();
431 if (read_cache() < 0)
432 die(_("cannot read the index"));
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"));
441 fd = hold_lock_file_for_update(&false_lock,
442 git_path("next-index-%"PRIuMAX,
443 (uintmax_t) getpid()),
444 LOCK_DIE_ON_ERROR);
446 create_base_index(current_head);
447 add_remove_files(&partial);
448 refresh_cache(REFRESH_QUIET);
450 if (write_cache(fd, active_cache, active_nr) ||
451 close_lock_file(&false_lock))
452 die(_("unable to write temporary index file"));
454 discard_cache();
455 read_cache_from(false_lock.filename);
457 return false_lock.filename;
460 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
461 struct wt_status *s)
463 unsigned char sha1[20];
465 if (s->relative_paths)
466 s->prefix = prefix;
468 if (amend) {
469 s->amend = 1;
470 s->reference = "HEAD^1";
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;
478 wt_status_collect(s);
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;
496 return s->commitable;
499 static int is_a_merge(const struct commit *current_head)
501 return !!(current_head->parents && current_head->parents->next);
504 static void export_one(const char *var, const char *s, const char *e, int hack)
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);
514 static int sane_ident_split(struct ident_split *person)
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;
528 static int parse_force_date(const char *in, char *out, int len)
530 if (len < 1)
531 return -1;
532 *out++ = '@';
533 len--;
535 if (parse_date(in, out, len) < 0) {
536 int errors = 0;
537 unsigned long t = approxidate_careful(in, &errors);
538 if (errors)
539 return -1;
540 snprintf(out, len, "%lu", t);
543 return 0;
546 static void determine_author_info(struct strbuf *author_ident)
548 char *name, *email, *date;
549 struct ident_split author;
550 char date_buf[64];
552 name = getenv("GIT_AUTHOR_NAME");
553 email = getenv("GIT_AUTHOR_EMAIL");
554 date = getenv("GIT_AUTHOR_DATE");
556 if (author_message) {
557 const char *a, *lb, *rb, *eol;
558 size_t len;
560 a = strstr(author_message_buffer, "\nauthor ");
561 if (!a)
562 die(_("invalid commit: %s"), author_message);
564 lb = strchrnul(a + strlen("\nauthor "), '<');
565 rb = strchrnul(lb, '>');
566 eol = strchrnul(rb, '\n');
567 if (!*lb || !*rb || !*eol)
568 die(_("invalid commit: %s"), author_message);
570 if (lb == a + strlen("\nauthor "))
571 /* \nauthor <foo@example.com> */
572 name = xcalloc(1, 1);
573 else
574 name = xmemdupz(a + strlen("\nauthor "),
575 (lb - strlen(" ") -
576 (a + strlen("\nauthor "))));
577 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
578 len = eol - (rb + strlen("> "));
579 date = xmalloc(len + 2);
580 *date = '@';
581 memcpy(date + 1, rb + strlen("> "), len);
582 date[len + 1] = '\0';
585 if (force_author) {
586 const char *lb = strstr(force_author, " <");
587 const char *rb = strchr(force_author, '>');
589 if (!lb || !rb)
590 die(_("malformed --author parameter"));
591 name = xstrndup(force_author, lb - force_author);
592 email = xstrndup(lb + 2, rb - (lb + 2));
595 if (force_date) {
596 if (parse_force_date(force_date, date_buf, sizeof(date_buf)))
597 die(_("invalid date format: %s"), force_date);
598 date = date_buf;
601 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
602 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
603 sane_ident_split(&author)) {
604 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
605 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
606 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
610 static void split_ident_or_die(struct ident_split *id, const struct strbuf *buf)
612 if (split_ident_line(id, buf->buf, buf->len) ||
613 !sane_ident_split(id))
614 die(_("Malformed ident string: '%s'"), buf->buf);
617 static int author_date_is_interesting(void)
619 return author_message || force_date;
622 static void adjust_comment_line_char(const struct strbuf *sb)
624 char candidates[] = "#;@!$%^&|:";
625 char *candidate;
626 const char *p;
628 comment_line_char = candidates[0];
629 if (!memchr(sb->buf, comment_line_char, sb->len))
630 return;
632 p = sb->buf;
633 candidate = strchr(candidates, *p);
634 if (candidate)
635 *candidate = ' ';
636 for (p = sb->buf; *p; p++) {
637 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
638 candidate = strchr(candidates, p[1]);
639 if (candidate)
640 *candidate = ' ';
644 for (p = candidates; *p == ' '; p++)
646 if (!*p)
647 die(_("unable to select a comment character that is not used\n"
648 "in the current commit message"));
649 comment_line_char = *p;
652 static int prepare_to_commit(const char *index_file, const char *prefix,
653 struct commit *current_head,
654 struct wt_status *s,
655 struct strbuf *author_ident)
657 struct stat statbuf;
658 struct strbuf committer_ident = STRBUF_INIT;
659 int commitable;
660 struct strbuf sb = STRBUF_INIT;
661 const char *hook_arg1 = NULL;
662 const char *hook_arg2 = NULL;
663 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
664 int old_display_comment_prefix;
666 /* This checks and barfs if author is badly specified */
667 determine_author_info(author_ident);
669 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
670 return 0;
672 if (squash_message) {
674 * Insert the proper subject line before other commit
675 * message options add their content.
677 if (use_message && !strcmp(use_message, squash_message))
678 strbuf_addstr(&sb, "squash! ");
679 else {
680 struct pretty_print_context ctx = {0};
681 struct commit *c;
682 c = lookup_commit_reference_by_name(squash_message);
683 if (!c)
684 die(_("could not lookup commit %s"), squash_message);
685 ctx.output_encoding = get_commit_output_encoding();
686 format_commit_message(c, "squash! %s\n\n", &sb,
687 &ctx);
691 if (message.len) {
692 strbuf_addbuf(&sb, &message);
693 hook_arg1 = "message";
694 } else if (logfile && !strcmp(logfile, "-")) {
695 if (isatty(0))
696 fprintf(stderr, _("(reading log message from standard input)\n"));
697 if (strbuf_read(&sb, 0, 0) < 0)
698 die_errno(_("could not read log from standard input"));
699 hook_arg1 = "message";
700 } else if (logfile) {
701 if (strbuf_read_file(&sb, logfile, 0) < 0)
702 die_errno(_("could not read log file '%s'"),
703 logfile);
704 hook_arg1 = "message";
705 } else if (use_message) {
706 char *buffer;
707 buffer = strstr(use_message_buffer, "\n\n");
708 if (buffer)
709 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
710 hook_arg1 = "commit";
711 hook_arg2 = use_message;
712 } else if (fixup_message) {
713 struct pretty_print_context ctx = {0};
714 struct commit *commit;
715 commit = lookup_commit_reference_by_name(fixup_message);
716 if (!commit)
717 die(_("could not lookup commit %s"), fixup_message);
718 ctx.output_encoding = get_commit_output_encoding();
719 format_commit_message(commit, "fixup! %s\n\n",
720 &sb, &ctx);
721 hook_arg1 = "message";
722 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
723 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
724 die_errno(_("could not read MERGE_MSG"));
725 hook_arg1 = "merge";
726 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
727 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
728 die_errno(_("could not read SQUASH_MSG"));
729 hook_arg1 = "squash";
730 } else if (template_file) {
731 if (strbuf_read_file(&sb, template_file, 0) < 0)
732 die_errno(_("could not read '%s'"), template_file);
733 hook_arg1 = "template";
734 clean_message_contents = 0;
738 * The remaining cases don't modify the template message, but
739 * just set the argument(s) to the prepare-commit-msg hook.
741 else if (whence == FROM_MERGE)
742 hook_arg1 = "merge";
743 else if (whence == FROM_CHERRY_PICK) {
744 hook_arg1 = "commit";
745 hook_arg2 = "CHERRY_PICK_HEAD";
748 if (squash_message) {
750 * If squash_commit was used for the commit subject,
751 * then we're possibly hijacking other commit log options.
752 * Reset the hook args to tell the real story.
754 hook_arg1 = "message";
755 hook_arg2 = "";
758 s->fp = fopen(git_path(commit_editmsg), "w");
759 if (s->fp == NULL)
760 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
762 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
763 old_display_comment_prefix = s->display_comment_prefix;
764 s->display_comment_prefix = 1;
767 * Most hints are counter-productive when the commit has
768 * already started.
770 s->hints = 0;
772 if (clean_message_contents)
773 stripspace(&sb, 0);
775 if (signoff) {
777 * See if we have a Conflicts: block at the end. If yes, count
778 * its size, so we can ignore it.
780 int ignore_footer = 0;
781 int i, eol, previous = 0;
782 const char *nl;
784 for (i = 0; i < sb.len; i++) {
785 nl = memchr(sb.buf + i, '\n', sb.len - i);
786 if (nl)
787 eol = nl - sb.buf;
788 else
789 eol = sb.len;
790 if (starts_with(sb.buf + previous, "\nConflicts:\n")) {
791 ignore_footer = sb.len - previous;
792 break;
794 while (i < eol)
795 i++;
796 previous = eol;
799 append_signoff(&sb, ignore_footer, 0);
802 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
803 die_errno(_("could not write commit template"));
805 if (auto_comment_line_char)
806 adjust_comment_line_char(&sb);
807 strbuf_release(&sb);
809 /* This checks if committer ident is explicitly given */
810 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
811 if (use_editor && include_status) {
812 int ident_shown = 0;
813 int saved_color_setting;
814 struct ident_split ci, ai;
816 if (whence != FROM_COMMIT) {
817 if (cleanup_mode == CLEANUP_SCISSORS)
818 wt_status_add_cut_line(s->fp);
819 status_printf_ln(s, GIT_COLOR_NORMAL,
820 whence == FROM_MERGE
821 ? _("\n"
822 "It looks like you may be committing a merge.\n"
823 "If this is not correct, please remove the file\n"
824 " %s\n"
825 "and try again.\n")
826 : _("\n"
827 "It looks like you may be committing a cherry-pick.\n"
828 "If this is not correct, please remove the file\n"
829 " %s\n"
830 "and try again.\n"),
831 git_path(whence == FROM_MERGE
832 ? "MERGE_HEAD"
833 : "CHERRY_PICK_HEAD"));
836 fprintf(s->fp, "\n");
837 if (cleanup_mode == CLEANUP_ALL)
838 status_printf(s, GIT_COLOR_NORMAL,
839 _("Please enter the commit message for your changes."
840 " Lines starting\nwith '%c' will be ignored, and an empty"
841 " message aborts the commit.\n"), comment_line_char);
842 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
843 wt_status_add_cut_line(s->fp);
844 else /* CLEANUP_SPACE, that is. */
845 status_printf(s, GIT_COLOR_NORMAL,
846 _("Please enter the commit message for your changes."
847 " Lines starting\n"
848 "with '%c' will be kept; you may remove them"
849 " yourself if you want to.\n"
850 "An empty message aborts the commit.\n"), comment_line_char);
851 if (only_include_assumed)
852 status_printf_ln(s, GIT_COLOR_NORMAL,
853 "%s", only_include_assumed);
855 split_ident_or_die(&ai, author_ident);
856 split_ident_or_die(&ci, &committer_ident);
858 if (ident_cmp(&ai, &ci))
859 status_printf_ln(s, GIT_COLOR_NORMAL,
860 _("%s"
861 "Author: %.*s <%.*s>"),
862 ident_shown++ ? "" : "\n",
863 (int)(ai.name_end - ai.name_begin), ai.name_begin,
864 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
866 if (author_date_is_interesting())
867 status_printf_ln(s, GIT_COLOR_NORMAL,
868 _("%s"
869 "Date: %s"),
870 ident_shown++ ? "" : "\n",
871 show_ident_date(&ai, DATE_NORMAL));
873 if (!committer_ident_sufficiently_given())
874 status_printf_ln(s, GIT_COLOR_NORMAL,
875 _("%s"
876 "Committer: %.*s <%.*s>"),
877 ident_shown++ ? "" : "\n",
878 (int)(ci.name_end - ci.name_begin), ci.name_begin,
879 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
881 if (ident_shown)
882 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
884 saved_color_setting = s->use_color;
885 s->use_color = 0;
886 commitable = run_status(s->fp, index_file, prefix, 1, s);
887 s->use_color = saved_color_setting;
888 } else {
889 unsigned char sha1[20];
890 const char *parent = "HEAD";
892 if (!active_nr && read_cache() < 0)
893 die(_("Cannot read index"));
895 if (amend)
896 parent = "HEAD^1";
898 if (get_sha1(parent, sha1))
899 commitable = !!active_nr;
900 else {
902 * Unless the user did explicitly request a submodule
903 * ignore mode by passing a command line option we do
904 * not ignore any changed submodule SHA-1s when
905 * comparing index and parent, no matter what is
906 * configured. Otherwise we won't commit any
907 * submodules which were manually staged, which would
908 * be really confusing.
910 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
911 if (ignore_submodule_arg &&
912 !strcmp(ignore_submodule_arg, "all"))
913 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
914 commitable = index_differs_from(parent, diff_flags);
917 strbuf_release(&committer_ident);
919 fclose(s->fp);
922 * Reject an attempt to record a non-merge empty commit without
923 * explicit --allow-empty. In the cherry-pick case, it may be
924 * empty due to conflict resolution, which the user should okay.
926 if (!commitable && whence != FROM_MERGE && !allow_empty &&
927 !(amend && is_a_merge(current_head))) {
928 s->display_comment_prefix = old_display_comment_prefix;
929 run_status(stdout, index_file, prefix, 0, s);
930 if (amend)
931 fputs(_(empty_amend_advice), stderr);
932 else if (whence == FROM_CHERRY_PICK) {
933 fputs(_(empty_cherry_pick_advice), stderr);
934 if (!sequencer_in_use)
935 fputs(_(empty_cherry_pick_advice_single), stderr);
936 else
937 fputs(_(empty_cherry_pick_advice_multi), stderr);
939 return 0;
943 * Re-read the index as pre-commit hook could have updated it,
944 * and write it out as a tree. We must do this before we invoke
945 * the editor and after we invoke run_status above.
947 discard_cache();
948 read_cache_from(index_file);
949 if (update_main_cache_tree(0)) {
950 error(_("Error building trees"));
951 return 0;
954 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
955 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
956 return 0;
958 if (use_editor) {
959 char index[PATH_MAX];
960 const char *env[2] = { NULL };
961 env[0] = index;
962 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
963 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
964 fprintf(stderr,
965 _("Please supply the message using either -m or -F option.\n"));
966 exit(1);
970 if (!no_verify &&
971 run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
972 return 0;
975 return 1;
978 static int rest_is_empty(struct strbuf *sb, int start)
980 int i, eol;
981 const char *nl;
983 /* Check if the rest is just whitespace and Signed-of-by's. */
984 for (i = start; i < sb->len; i++) {
985 nl = memchr(sb->buf + i, '\n', sb->len - i);
986 if (nl)
987 eol = nl - sb->buf;
988 else
989 eol = sb->len;
991 if (strlen(sign_off_header) <= eol - i &&
992 starts_with(sb->buf + i, sign_off_header)) {
993 i = eol;
994 continue;
996 while (i < eol)
997 if (!isspace(sb->buf[i++]))
998 return 0;
1001 return 1;
1005 * Find out if the message in the strbuf contains only whitespace and
1006 * Signed-off-by lines.
1008 static int message_is_empty(struct strbuf *sb)
1010 if (cleanup_mode == CLEANUP_NONE && sb->len)
1011 return 0;
1012 return rest_is_empty(sb, 0);
1016 * See if the user edited the message in the editor or left what
1017 * was in the template intact
1019 static int template_untouched(struct strbuf *sb)
1021 struct strbuf tmpl = STRBUF_INIT;
1022 const char *start;
1024 if (cleanup_mode == CLEANUP_NONE && sb->len)
1025 return 0;
1027 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1028 return 0;
1030 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1031 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1032 start = sb->buf;
1033 strbuf_release(&tmpl);
1034 return rest_is_empty(sb, start - sb->buf);
1037 static const char *find_author_by_nickname(const char *name)
1039 struct rev_info revs;
1040 struct commit *commit;
1041 struct strbuf buf = STRBUF_INIT;
1042 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1043 const char *av[20];
1044 int ac = 0;
1046 init_revisions(&revs, NULL);
1047 strbuf_addf(&buf, "--author=%s", name);
1048 av[++ac] = "--all";
1049 av[++ac] = "-i";
1050 av[++ac] = buf.buf;
1051 av[++ac] = NULL;
1052 setup_revisions(ac, av, &revs, NULL);
1053 revs.mailmap = &mailmap;
1054 read_mailmap(revs.mailmap, NULL);
1056 prepare_revision_walk(&revs);
1057 commit = get_revision(&revs);
1058 if (commit) {
1059 struct pretty_print_context ctx = {0};
1060 ctx.date_mode = DATE_NORMAL;
1061 strbuf_release(&buf);
1062 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1063 clear_mailmap(&mailmap);
1064 return strbuf_detach(&buf, NULL);
1066 die(_("No existing author found with '%s'"), name);
1070 static void handle_untracked_files_arg(struct wt_status *s)
1072 if (!untracked_files_arg)
1073 ; /* default already initialized */
1074 else if (!strcmp(untracked_files_arg, "no"))
1075 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1076 else if (!strcmp(untracked_files_arg, "normal"))
1077 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1078 else if (!strcmp(untracked_files_arg, "all"))
1079 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1080 else
1081 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1084 static const char *read_commit_message(const char *name)
1086 const char *out_enc;
1087 struct commit *commit;
1089 commit = lookup_commit_reference_by_name(name);
1090 if (!commit)
1091 die(_("could not lookup commit %s"), name);
1092 out_enc = get_commit_output_encoding();
1093 return logmsg_reencode(commit, NULL, out_enc);
1097 * Enumerate what needs to be propagated when --porcelain
1098 * is not in effect here.
1100 static struct status_deferred_config {
1101 enum status_format status_format;
1102 int show_branch;
1103 } status_deferred_config = {
1104 STATUS_FORMAT_UNSPECIFIED,
1105 -1 /* unspecified */
1108 static void finalize_deferred_config(struct wt_status *s)
1110 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1111 !s->null_termination);
1113 if (s->null_termination) {
1114 if (status_format == STATUS_FORMAT_NONE ||
1115 status_format == STATUS_FORMAT_UNSPECIFIED)
1116 status_format = STATUS_FORMAT_PORCELAIN;
1117 else if (status_format == STATUS_FORMAT_LONG)
1118 die(_("--long and -z are incompatible"));
1121 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1122 status_format = status_deferred_config.status_format;
1123 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1124 status_format = STATUS_FORMAT_NONE;
1126 if (use_deferred_config && s->show_branch < 0)
1127 s->show_branch = status_deferred_config.show_branch;
1128 if (s->show_branch < 0)
1129 s->show_branch = 0;
1132 static int parse_and_validate_options(int argc, const char *argv[],
1133 const struct option *options,
1134 const char * const usage[],
1135 const char *prefix,
1136 struct commit *current_head,
1137 struct wt_status *s)
1139 int f = 0;
1141 argc = parse_options(argc, argv, prefix, options, usage, 0);
1142 finalize_deferred_config(s);
1144 if (force_author && !strchr(force_author, '>'))
1145 force_author = find_author_by_nickname(force_author);
1147 if (force_author && renew_authorship)
1148 die(_("Using both --reset-author and --author does not make sense"));
1150 if (logfile || have_option_m || use_message || fixup_message)
1151 use_editor = 0;
1152 if (0 <= edit_flag)
1153 use_editor = edit_flag;
1155 /* Sanity check options */
1156 if (amend && !current_head)
1157 die(_("You have nothing to amend."));
1158 if (amend && whence != FROM_COMMIT) {
1159 if (whence == FROM_MERGE)
1160 die(_("You are in the middle of a merge -- cannot amend."));
1161 else if (whence == FROM_CHERRY_PICK)
1162 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1164 if (fixup_message && squash_message)
1165 die(_("Options --squash and --fixup cannot be used together"));
1166 if (use_message)
1167 f++;
1168 if (edit_message)
1169 f++;
1170 if (fixup_message)
1171 f++;
1172 if (logfile)
1173 f++;
1174 if (f > 1)
1175 die(_("Only one of -c/-C/-F/--fixup can be used."));
1176 if (message.len && f > 0)
1177 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1178 if (f || message.len)
1179 template_file = NULL;
1180 if (edit_message)
1181 use_message = edit_message;
1182 if (amend && !use_message && !fixup_message)
1183 use_message = "HEAD";
1184 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1185 die(_("--reset-author can be used only with -C, -c or --amend."));
1186 if (use_message) {
1187 use_message_buffer = read_commit_message(use_message);
1188 if (!renew_authorship) {
1189 author_message = use_message;
1190 author_message_buffer = use_message_buffer;
1193 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1194 author_message = "CHERRY_PICK_HEAD";
1195 author_message_buffer = read_commit_message(author_message);
1198 if (patch_interactive)
1199 interactive = 1;
1201 if (also + only + all + interactive > 1)
1202 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1203 if (argc == 0 && (also || (only && !amend)))
1204 die(_("No paths with --include/--only does not make sense."));
1205 if (argc == 0 && only && amend)
1206 only_include_assumed = _("Clever... amending the last one with dirty index.");
1207 if (argc > 0 && !also && !only)
1208 only_include_assumed = _("Explicit paths specified without -i or -o; assuming --only paths...");
1209 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1210 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1211 else if (!strcmp(cleanup_arg, "verbatim"))
1212 cleanup_mode = CLEANUP_NONE;
1213 else if (!strcmp(cleanup_arg, "whitespace"))
1214 cleanup_mode = CLEANUP_SPACE;
1215 else if (!strcmp(cleanup_arg, "strip"))
1216 cleanup_mode = CLEANUP_ALL;
1217 else if (!strcmp(cleanup_arg, "scissors"))
1218 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1219 else
1220 die(_("Invalid cleanup mode %s"), cleanup_arg);
1222 handle_untracked_files_arg(s);
1224 if (all && argc > 0)
1225 die(_("Paths with -a does not make sense."));
1227 if (status_format != STATUS_FORMAT_NONE)
1228 dry_run = 1;
1230 return argc;
1233 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1234 const struct commit *current_head, struct wt_status *s)
1236 int commitable;
1237 const char *index_file;
1239 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1240 commitable = run_status(stdout, index_file, prefix, 0, s);
1241 rollback_index_files();
1243 return commitable ? 0 : 1;
1246 static int parse_status_slot(const char *var, int offset)
1248 if (!strcasecmp(var+offset, "header"))
1249 return WT_STATUS_HEADER;
1250 if (!strcasecmp(var+offset, "branch"))
1251 return WT_STATUS_ONBRANCH;
1252 if (!strcasecmp(var+offset, "updated")
1253 || !strcasecmp(var+offset, "added"))
1254 return WT_STATUS_UPDATED;
1255 if (!strcasecmp(var+offset, "changed"))
1256 return WT_STATUS_CHANGED;
1257 if (!strcasecmp(var+offset, "untracked"))
1258 return WT_STATUS_UNTRACKED;
1259 if (!strcasecmp(var+offset, "nobranch"))
1260 return WT_STATUS_NOBRANCH;
1261 if (!strcasecmp(var+offset, "unmerged"))
1262 return WT_STATUS_UNMERGED;
1263 return -1;
1266 static int git_status_config(const char *k, const char *v, void *cb)
1268 struct wt_status *s = cb;
1270 if (starts_with(k, "column."))
1271 return git_column_config(k, v, "status", &s->colopts);
1272 if (!strcmp(k, "status.submodulesummary")) {
1273 int is_bool;
1274 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1275 if (is_bool && s->submodule_summary)
1276 s->submodule_summary = -1;
1277 return 0;
1279 if (!strcmp(k, "status.short")) {
1280 if (git_config_bool(k, v))
1281 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1282 else
1283 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1284 return 0;
1286 if (!strcmp(k, "status.branch")) {
1287 status_deferred_config.show_branch = git_config_bool(k, v);
1288 return 0;
1290 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1291 s->use_color = git_config_colorbool(k, v);
1292 return 0;
1294 if (!strcmp(k, "status.displaycommentprefix")) {
1295 s->display_comment_prefix = git_config_bool(k, v);
1296 return 0;
1298 if (starts_with(k, "status.color.") || starts_with(k, "color.status.")) {
1299 int slot = parse_status_slot(k, 13);
1300 if (slot < 0)
1301 return 0;
1302 if (!v)
1303 return config_error_nonbool(k);
1304 color_parse(v, k, s->color_palette[slot]);
1305 return 0;
1307 if (!strcmp(k, "status.relativepaths")) {
1308 s->relative_paths = git_config_bool(k, v);
1309 return 0;
1311 if (!strcmp(k, "status.showuntrackedfiles")) {
1312 if (!v)
1313 return config_error_nonbool(k);
1314 else if (!strcmp(v, "no"))
1315 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1316 else if (!strcmp(v, "normal"))
1317 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1318 else if (!strcmp(v, "all"))
1319 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1320 else
1321 return error(_("Invalid untracked files mode '%s'"), v);
1322 return 0;
1324 return git_diff_ui_config(k, v, NULL);
1327 int cmd_status(int argc, const char **argv, const char *prefix)
1329 static struct wt_status s;
1330 int fd;
1331 unsigned char sha1[20];
1332 static struct option builtin_status_options[] = {
1333 OPT__VERBOSE(&verbose, N_("be verbose")),
1334 OPT_SET_INT('s', "short", &status_format,
1335 N_("show status concisely"), STATUS_FORMAT_SHORT),
1336 OPT_BOOL('b', "branch", &s.show_branch,
1337 N_("show branch information")),
1338 OPT_SET_INT(0, "porcelain", &status_format,
1339 N_("machine-readable output"),
1340 STATUS_FORMAT_PORCELAIN),
1341 OPT_SET_INT(0, "long", &status_format,
1342 N_("show status in long format (default)"),
1343 STATUS_FORMAT_LONG),
1344 OPT_BOOL('z', "null", &s.null_termination,
1345 N_("terminate entries with NUL")),
1346 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1347 N_("mode"),
1348 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1349 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1350 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1351 N_("show ignored files")),
1352 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1353 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1354 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1355 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1356 OPT_END(),
1359 if (argc == 2 && !strcmp(argv[1], "-h"))
1360 usage_with_options(builtin_status_usage, builtin_status_options);
1362 status_init_config(&s, git_status_config);
1363 argc = parse_options(argc, argv, prefix,
1364 builtin_status_options,
1365 builtin_status_usage, 0);
1366 finalize_colopts(&s.colopts, -1);
1367 finalize_deferred_config(&s);
1369 handle_untracked_files_arg(&s);
1370 if (show_ignored_in_status)
1371 s.show_ignored_files = 1;
1372 parse_pathspec(&s.pathspec, 0,
1373 PATHSPEC_PREFER_FULL,
1374 prefix, argv);
1376 read_cache_preload(&s.pathspec);
1377 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1379 fd = hold_locked_index(&index_lock, 0);
1380 if (0 <= fd)
1381 update_index_if_able(&the_index, &index_lock);
1383 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1384 s.ignore_submodule_arg = ignore_submodule_arg;
1385 wt_status_collect(&s);
1387 if (s.relative_paths)
1388 s.prefix = prefix;
1390 switch (status_format) {
1391 case STATUS_FORMAT_SHORT:
1392 wt_shortstatus_print(&s);
1393 break;
1394 case STATUS_FORMAT_PORCELAIN:
1395 wt_porcelain_print(&s);
1396 break;
1397 case STATUS_FORMAT_UNSPECIFIED:
1398 die("BUG: finalize_deferred_config() should have been called");
1399 break;
1400 case STATUS_FORMAT_NONE:
1401 case STATUS_FORMAT_LONG:
1402 s.verbose = verbose;
1403 s.ignore_submodule_arg = ignore_submodule_arg;
1404 wt_status_print(&s);
1405 break;
1407 return 0;
1410 static void print_summary(const char *prefix, const unsigned char *sha1,
1411 int initial_commit)
1413 struct rev_info rev;
1414 struct commit *commit;
1415 struct strbuf format = STRBUF_INIT;
1416 unsigned char junk_sha1[20];
1417 const char *head;
1418 struct pretty_print_context pctx = {0};
1419 struct strbuf author_ident = STRBUF_INIT;
1420 struct strbuf committer_ident = STRBUF_INIT;
1422 commit = lookup_commit(sha1);
1423 if (!commit)
1424 die(_("couldn't look up newly created commit"));
1425 if (parse_commit(commit))
1426 die(_("could not parse newly created commit"));
1428 strbuf_addstr(&format, "format:%h] %s");
1430 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1431 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1432 if (strbuf_cmp(&author_ident, &committer_ident)) {
1433 strbuf_addstr(&format, "\n Author: ");
1434 strbuf_addbuf_percentquote(&format, &author_ident);
1436 if (author_date_is_interesting()) {
1437 struct strbuf date = STRBUF_INIT;
1438 format_commit_message(commit, "%ad", &date, &pctx);
1439 strbuf_addstr(&format, "\n Date: ");
1440 strbuf_addbuf_percentquote(&format, &date);
1441 strbuf_release(&date);
1443 if (!committer_ident_sufficiently_given()) {
1444 strbuf_addstr(&format, "\n Committer: ");
1445 strbuf_addbuf_percentquote(&format, &committer_ident);
1446 if (advice_implicit_identity) {
1447 strbuf_addch(&format, '\n');
1448 strbuf_addstr(&format, _(implicit_ident_advice));
1451 strbuf_release(&author_ident);
1452 strbuf_release(&committer_ident);
1454 init_revisions(&rev, prefix);
1455 setup_revisions(0, NULL, &rev, NULL);
1457 rev.diff = 1;
1458 rev.diffopt.output_format =
1459 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1461 rev.verbose_header = 1;
1462 rev.show_root_diff = 1;
1463 get_commit_format(format.buf, &rev);
1464 rev.always_show_header = 0;
1465 rev.diffopt.detect_rename = 1;
1466 rev.diffopt.break_opt = 0;
1467 diff_setup_done(&rev.diffopt);
1469 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1470 printf("[%s%s ",
1471 starts_with(head, "refs/heads/") ?
1472 head + 11 :
1473 !strcmp(head, "HEAD") ?
1474 _("detached HEAD") :
1475 head,
1476 initial_commit ? _(" (root-commit)") : "");
1478 if (!log_tree_commit(&rev, commit)) {
1479 rev.always_show_header = 1;
1480 rev.use_terminator = 1;
1481 log_tree_commit(&rev, commit);
1484 strbuf_release(&format);
1487 static int git_commit_config(const char *k, const char *v, void *cb)
1489 struct wt_status *s = cb;
1490 int status;
1492 if (!strcmp(k, "commit.template"))
1493 return git_config_pathname(&template_file, k, v);
1494 if (!strcmp(k, "commit.status")) {
1495 include_status = git_config_bool(k, v);
1496 return 0;
1498 if (!strcmp(k, "commit.cleanup"))
1499 return git_config_string(&cleanup_arg, k, v);
1500 if (!strcmp(k, "commit.gpgsign")) {
1501 sign_commit = git_config_bool(k, v) ? "" : NULL;
1502 return 0;
1505 status = git_gpg_config(k, v, NULL);
1506 if (status)
1507 return status;
1508 return git_status_config(k, v, s);
1511 static int run_rewrite_hook(const unsigned char *oldsha1,
1512 const unsigned char *newsha1)
1514 /* oldsha1 SP newsha1 LF NUL */
1515 static char buf[2*40 + 3];
1516 struct child_process proc;
1517 const char *argv[3];
1518 int code;
1519 size_t n;
1521 argv[0] = find_hook("post-rewrite");
1522 if (!argv[0])
1523 return 0;
1525 argv[1] = "amend";
1526 argv[2] = NULL;
1528 memset(&proc, 0, sizeof(proc));
1529 proc.argv = argv;
1530 proc.in = -1;
1531 proc.stdout_to_stderr = 1;
1533 code = start_command(&proc);
1534 if (code)
1535 return code;
1536 n = snprintf(buf, sizeof(buf), "%s %s\n",
1537 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1538 write_in_full(proc.in, buf, n);
1539 close(proc.in);
1540 return finish_command(&proc);
1543 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1545 const char *hook_env[3] = { NULL };
1546 char index[PATH_MAX];
1547 va_list args;
1548 int ret;
1550 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1551 hook_env[0] = index;
1554 * Let the hook know that no editor will be launched.
1556 if (!editor_is_used)
1557 hook_env[1] = "GIT_EDITOR=:";
1559 va_start(args, name);
1560 ret = run_hook_ve(hook_env, name, args);
1561 va_end(args);
1563 return ret;
1566 int cmd_commit(int argc, const char **argv, const char *prefix)
1568 static struct wt_status s;
1569 static struct option builtin_commit_options[] = {
1570 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1571 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1573 OPT_GROUP(N_("Commit message options")),
1574 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1575 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1576 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1577 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1578 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1579 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1580 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1581 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1582 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1583 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1584 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1585 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1586 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1587 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1588 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1589 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1590 /* end commit message options */
1592 OPT_GROUP(N_("Commit contents options")),
1593 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1594 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1595 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1596 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1597 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1598 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1599 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1600 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1601 STATUS_FORMAT_SHORT),
1602 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1603 OPT_SET_INT(0, "porcelain", &status_format,
1604 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1605 OPT_SET_INT(0, "long", &status_format,
1606 N_("show status in long format (default)"),
1607 STATUS_FORMAT_LONG),
1608 OPT_BOOL('z', "null", &s.null_termination,
1609 N_("terminate entries with NUL")),
1610 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1611 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1612 { 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" },
1613 /* end commit contents options */
1615 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1616 N_("ok to record an empty change")),
1617 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1618 N_("ok to record a change with an empty message")),
1620 OPT_END()
1623 struct strbuf sb = STRBUF_INIT;
1624 struct strbuf author_ident = STRBUF_INIT;
1625 const char *index_file, *reflog_msg;
1626 char *nl;
1627 unsigned char sha1[20];
1628 struct ref_lock *ref_lock;
1629 struct commit_list *parents = NULL, **pptr = &parents;
1630 struct stat statbuf;
1631 struct commit *current_head = NULL;
1632 struct commit_extra_header *extra = NULL;
1634 if (argc == 2 && !strcmp(argv[1], "-h"))
1635 usage_with_options(builtin_commit_usage, builtin_commit_options);
1637 status_init_config(&s, git_commit_config);
1638 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1639 s.colopts = 0;
1641 if (get_sha1("HEAD", sha1))
1642 current_head = NULL;
1643 else {
1644 current_head = lookup_commit_or_die(sha1, "HEAD");
1645 if (parse_commit(current_head))
1646 die(_("could not parse HEAD commit"));
1648 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1649 builtin_commit_usage,
1650 prefix, current_head, &s);
1651 if (dry_run)
1652 return dry_run_commit(argc, argv, prefix, current_head, &s);
1653 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1655 /* Set up everything for writing the commit object. This includes
1656 running hooks, writing the trees, and interacting with the user. */
1657 if (!prepare_to_commit(index_file, prefix,
1658 current_head, &s, &author_ident)) {
1659 rollback_index_files();
1660 return 1;
1663 /* Determine parents */
1664 reflog_msg = getenv("GIT_REFLOG_ACTION");
1665 if (!current_head) {
1666 if (!reflog_msg)
1667 reflog_msg = "commit (initial)";
1668 } else if (amend) {
1669 struct commit_list *c;
1671 if (!reflog_msg)
1672 reflog_msg = "commit (amend)";
1673 for (c = current_head->parents; c; c = c->next)
1674 pptr = &commit_list_insert(c->item, pptr)->next;
1675 } else if (whence == FROM_MERGE) {
1676 struct strbuf m = STRBUF_INIT;
1677 FILE *fp;
1678 int allow_fast_forward = 1;
1680 if (!reflog_msg)
1681 reflog_msg = "commit (merge)";
1682 pptr = &commit_list_insert(current_head, pptr)->next;
1683 fp = fopen(git_path("MERGE_HEAD"), "r");
1684 if (fp == NULL)
1685 die_errno(_("could not open '%s' for reading"),
1686 git_path("MERGE_HEAD"));
1687 while (strbuf_getline(&m, fp, '\n') != EOF) {
1688 struct commit *parent;
1690 parent = get_merge_parent(m.buf);
1691 if (!parent)
1692 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1693 pptr = &commit_list_insert(parent, pptr)->next;
1695 fclose(fp);
1696 strbuf_release(&m);
1697 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1698 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1699 die_errno(_("could not read MERGE_MODE"));
1700 if (!strcmp(sb.buf, "no-ff"))
1701 allow_fast_forward = 0;
1703 if (allow_fast_forward)
1704 parents = reduce_heads(parents);
1705 } else {
1706 if (!reflog_msg)
1707 reflog_msg = (whence == FROM_CHERRY_PICK)
1708 ? "commit (cherry-pick)"
1709 : "commit";
1710 pptr = &commit_list_insert(current_head, pptr)->next;
1713 /* Finally, get the commit message */
1714 strbuf_reset(&sb);
1715 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1716 int saved_errno = errno;
1717 rollback_index_files();
1718 die(_("could not read commit message: %s"), strerror(saved_errno));
1721 if (verbose || /* Truncate the message just before the diff, if any. */
1722 cleanup_mode == CLEANUP_SCISSORS)
1723 wt_status_truncate_message_at_cut_line(&sb);
1725 if (cleanup_mode != CLEANUP_NONE)
1726 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1727 if (template_untouched(&sb) && !allow_empty_message) {
1728 rollback_index_files();
1729 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1730 exit(1);
1732 if (message_is_empty(&sb) && !allow_empty_message) {
1733 rollback_index_files();
1734 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1735 exit(1);
1738 if (amend) {
1739 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1740 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1741 } else {
1742 struct commit_extra_header **tail = &extra;
1743 append_merge_tag_headers(parents, &tail);
1746 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->sha1,
1747 parents, sha1, author_ident.buf, sign_commit, extra)) {
1748 rollback_index_files();
1749 die(_("failed to write commit object"));
1751 strbuf_release(&author_ident);
1752 free_commit_extra_headers(extra);
1754 ref_lock = lock_any_ref_for_update("HEAD",
1755 !current_head
1756 ? NULL
1757 : current_head->object.sha1,
1758 0, NULL);
1759 if (!ref_lock) {
1760 rollback_index_files();
1761 die(_("cannot lock HEAD ref"));
1764 nl = strchr(sb.buf, '\n');
1765 if (nl)
1766 strbuf_setlen(&sb, nl + 1 - sb.buf);
1767 else
1768 strbuf_addch(&sb, '\n');
1769 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1770 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1772 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1773 rollback_index_files();
1774 die(_("cannot update HEAD ref"));
1777 unlink(git_path("CHERRY_PICK_HEAD"));
1778 unlink(git_path("REVERT_HEAD"));
1779 unlink(git_path("MERGE_HEAD"));
1780 unlink(git_path("MERGE_MSG"));
1781 unlink(git_path("MERGE_MODE"));
1782 unlink(git_path("SQUASH_MSG"));
1784 if (commit_index_files())
1785 die (_("Repository has been updated, but unable to write\n"
1786 "new_index file. Check that disk is not full or quota is\n"
1787 "not exceeded, and then \"git reset HEAD\" to recover."));
1789 rerere(0);
1790 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1791 if (amend && !no_post_rewrite) {
1792 struct notes_rewrite_cfg *cfg;
1793 cfg = init_copy_notes_for_rewrite("amend");
1794 if (cfg) {
1795 /* we are amending, so current_head is not NULL */
1796 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1797 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1799 run_rewrite_hook(current_head->object.sha1, sha1);
1801 if (!quiet)
1802 print_summary(prefix, sha1, !current_head);
1804 return 0;