commit: disable status hints when writing to COMMIT_EDITMSG
[git.git] / builtin / commit.c
blob321462a435d2fa2b22d4fb59decbe7e39d1f7084
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"
34 static const char * const builtin_commit_usage[] = {
35 N_("git commit [options] [--] <pathspec>..."),
36 NULL
39 static const char * const builtin_status_usage[] = {
40 N_("git status [options] [--] <pathspec>..."),
41 NULL
44 static const char implicit_ident_advice[] =
45 N_("Your name and email address were configured automatically based\n"
46 "on your username and hostname. Please check that they are accurate.\n"
47 "You can suppress this message by setting them explicitly:\n"
48 "\n"
49 " git config --global user.name \"Your Name\"\n"
50 " git config --global user.email you@example.com\n"
51 "\n"
52 "After doing this, you may fix the identity used for this commit with:\n"
53 "\n"
54 " git commit --amend --reset-author\n");
56 static const char empty_amend_advice[] =
57 N_("You asked to amend the most recent commit, but doing so would make\n"
58 "it empty. You can repeat your command with --allow-empty, or you can\n"
59 "remove the commit entirely with \"git reset HEAD^\".\n");
61 static const char empty_cherry_pick_advice[] =
62 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
63 "If you wish to commit it anyway, use:\n"
64 "\n"
65 " git commit --allow-empty\n"
66 "\n");
68 static const char empty_cherry_pick_advice_single[] =
69 N_("Otherwise, please use 'git reset'\n");
71 static const char empty_cherry_pick_advice_multi[] =
72 N_("If you wish to skip this commit, use:\n"
73 "\n"
74 " git reset\n"
75 "\n"
76 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
77 "the remaining commits.\n");
79 static const char *use_message_buffer;
80 static const char commit_editmsg[] = "COMMIT_EDITMSG";
81 static struct lock_file index_lock; /* real index */
82 static struct lock_file false_lock; /* used only for partial commits */
83 static enum {
84 COMMIT_AS_IS = 1,
85 COMMIT_NORMAL,
86 COMMIT_PARTIAL
87 } commit_style;
89 static const char *logfile, *force_author;
90 static const char *template_file;
92 * The _message variables are commit names from which to take
93 * the commit message and/or authorship.
95 static const char *author_message, *author_message_buffer;
96 static char *edit_message, *use_message;
97 static char *fixup_message, *squash_message;
98 static int all, also, interactive, patch_interactive, only, amend, signoff;
99 static int edit_flag = -1; /* unspecified */
100 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
101 static int no_post_rewrite, allow_empty_message;
102 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
103 static char *sign_commit;
106 * The default commit message cleanup mode will remove the lines
107 * beginning with # (shell comments) and leading and trailing
108 * whitespaces (empty lines or containing only whitespaces)
109 * if editor is used, and only the whitespaces if the message
110 * is specified explicitly.
112 static enum {
113 CLEANUP_SPACE,
114 CLEANUP_NONE,
115 CLEANUP_ALL
116 } cleanup_mode;
117 static const char *cleanup_arg;
119 static enum commit_whence whence;
120 static int sequencer_in_use;
121 static int use_editor = 1, include_status = 1;
122 static int show_ignored_in_status, have_option_m;
123 static const char *only_include_assumed;
124 static struct strbuf message = STRBUF_INIT;
126 static enum status_format {
127 STATUS_FORMAT_NONE = 0,
128 STATUS_FORMAT_LONG,
129 STATUS_FORMAT_SHORT,
130 STATUS_FORMAT_PORCELAIN,
132 STATUS_FORMAT_UNSPECIFIED
133 } status_format = STATUS_FORMAT_UNSPECIFIED;
135 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
137 struct strbuf *buf = opt->value;
138 if (unset) {
139 have_option_m = 0;
140 strbuf_setlen(buf, 0);
141 } else {
142 have_option_m = 1;
143 if (buf->len)
144 strbuf_addch(buf, '\n');
145 strbuf_addstr(buf, arg);
146 strbuf_complete_line(buf);
148 return 0;
151 static void determine_whence(struct wt_status *s)
153 if (file_exists(git_path("MERGE_HEAD")))
154 whence = FROM_MERGE;
155 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
156 whence = FROM_CHERRY_PICK;
157 if (file_exists(git_path("sequencer")))
158 sequencer_in_use = 1;
160 else
161 whence = FROM_COMMIT;
162 if (s)
163 s->whence = whence;
166 static void status_init_config(struct wt_status *s, config_fn_t fn)
168 wt_status_prepare(s);
169 gitmodules_config();
170 git_config(fn, s);
171 determine_whence(s);
172 s->hints = advice_status_hints; /* must come after git_config() */
175 static void rollback_index_files(void)
177 switch (commit_style) {
178 case COMMIT_AS_IS:
179 break; /* nothing to do */
180 case COMMIT_NORMAL:
181 rollback_lock_file(&index_lock);
182 break;
183 case COMMIT_PARTIAL:
184 rollback_lock_file(&index_lock);
185 rollback_lock_file(&false_lock);
186 break;
190 static int commit_index_files(void)
192 int err = 0;
194 switch (commit_style) {
195 case COMMIT_AS_IS:
196 break; /* nothing to do */
197 case COMMIT_NORMAL:
198 err = commit_lock_file(&index_lock);
199 break;
200 case COMMIT_PARTIAL:
201 err = commit_lock_file(&index_lock);
202 rollback_lock_file(&false_lock);
203 break;
206 return err;
210 * Take a union of paths in the index and the named tree (typically, "HEAD"),
211 * and return the paths that match the given pattern in list.
213 static int list_paths(struct string_list *list, const char *with_tree,
214 const char *prefix, const char **pattern)
216 int i;
217 char *m;
219 if (!pattern)
220 return 0;
222 for (i = 0; pattern[i]; i++)
224 m = xcalloc(1, i);
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 (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, 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 const char **pathspec = NULL;
311 char *old_index_env = NULL;
312 int refresh_flags = REFRESH_QUIET;
314 if (is_status)
315 refresh_flags |= REFRESH_UNMERGED;
317 if (*argv)
318 pathspec = get_pathspec(prefix, argv);
320 if (read_cache_preload(pathspec) < 0)
321 die(_("index file corrupt"));
323 if (interactive) {
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 && *pathspec)) {
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 || !*pathspec)) {
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 memset(&partial, 0, sizeof(partial));
427 partial.strdup_strings = 1;
428 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
429 exit(1);
431 discard_cache();
432 if (read_cache() < 0)
433 die(_("cannot read the index"));
435 fd = hold_locked_index(&index_lock, 1);
436 add_remove_files(&partial);
437 refresh_cache(REFRESH_QUIET);
438 if (write_cache(fd, active_cache, active_nr) ||
439 close_lock_file(&index_lock))
440 die(_("unable to write new_index file"));
442 fd = hold_lock_file_for_update(&false_lock,
443 git_path("next-index-%"PRIuMAX,
444 (uintmax_t) getpid()),
445 LOCK_DIE_ON_ERROR);
447 create_base_index(current_head);
448 add_remove_files(&partial);
449 refresh_cache(REFRESH_QUIET);
451 if (write_cache(fd, active_cache, active_nr) ||
452 close_lock_file(&false_lock))
453 die(_("unable to write temporary index file"));
455 discard_cache();
456 read_cache_from(false_lock.filename);
458 return false_lock.filename;
461 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
462 struct wt_status *s)
464 unsigned char sha1[20];
466 if (s->relative_paths)
467 s->prefix = prefix;
469 if (amend) {
470 s->amend = 1;
471 s->reference = "HEAD^1";
473 s->verbose = verbose;
474 s->index_file = index_file;
475 s->fp = fp;
476 s->nowarn = nowarn;
477 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
479 wt_status_collect(s);
481 switch (status_format) {
482 case STATUS_FORMAT_SHORT:
483 wt_shortstatus_print(s);
484 break;
485 case STATUS_FORMAT_PORCELAIN:
486 wt_porcelain_print(s);
487 break;
488 case STATUS_FORMAT_UNSPECIFIED:
489 die("BUG: finalize_deferred_config() should have been called");
490 break;
491 case STATUS_FORMAT_NONE:
492 case STATUS_FORMAT_LONG:
493 wt_status_print(s);
494 break;
497 return s->commitable;
500 static int is_a_merge(const struct commit *current_head)
502 return !!(current_head->parents && current_head->parents->next);
505 static void export_one(const char *var, const char *s, const char *e, int hack)
507 struct strbuf buf = STRBUF_INIT;
508 if (hack)
509 strbuf_addch(&buf, hack);
510 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
511 setenv(var, buf.buf, 1);
512 strbuf_release(&buf);
515 static int sane_ident_split(struct ident_split *person)
517 if (!person->name_begin || !person->name_end ||
518 person->name_begin == person->name_end)
519 return 0; /* no human readable name */
520 if (!person->mail_begin || !person->mail_end ||
521 person->mail_begin == person->mail_end)
522 return 0; /* no usable mail */
523 if (!person->date_begin || !person->date_end ||
524 !person->tz_begin || !person->tz_end)
525 return 0;
526 return 1;
529 static void determine_author_info(struct strbuf *author_ident)
531 char *name, *email, *date;
532 struct ident_split author;
534 name = getenv("GIT_AUTHOR_NAME");
535 email = getenv("GIT_AUTHOR_EMAIL");
536 date = getenv("GIT_AUTHOR_DATE");
538 if (author_message) {
539 const char *a, *lb, *rb, *eol;
540 size_t len;
542 a = strstr(author_message_buffer, "\nauthor ");
543 if (!a)
544 die(_("invalid commit: %s"), author_message);
546 lb = strchrnul(a + strlen("\nauthor "), '<');
547 rb = strchrnul(lb, '>');
548 eol = strchrnul(rb, '\n');
549 if (!*lb || !*rb || !*eol)
550 die(_("invalid commit: %s"), author_message);
552 if (lb == a + strlen("\nauthor "))
553 /* \nauthor <foo@example.com> */
554 name = xcalloc(1, 1);
555 else
556 name = xmemdupz(a + strlen("\nauthor "),
557 (lb - strlen(" ") -
558 (a + strlen("\nauthor "))));
559 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
560 len = eol - (rb + strlen("> "));
561 date = xmalloc(len + 2);
562 *date = '@';
563 memcpy(date + 1, rb + strlen("> "), len);
564 date[len + 1] = '\0';
567 if (force_author) {
568 const char *lb = strstr(force_author, " <");
569 const char *rb = strchr(force_author, '>');
571 if (!lb || !rb)
572 die(_("malformed --author parameter"));
573 name = xstrndup(force_author, lb - force_author);
574 email = xstrndup(lb + 2, rb - (lb + 2));
577 if (force_date)
578 date = force_date;
579 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
580 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
581 sane_ident_split(&author)) {
582 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
583 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
584 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
588 static char *cut_ident_timestamp_part(char *string)
590 char *ket = strrchr(string, '>');
591 if (!ket || ket[1] != ' ')
592 die(_("Malformed ident string: '%s'"), string);
593 *++ket = '\0';
594 return ket;
597 static int prepare_to_commit(const char *index_file, const char *prefix,
598 struct commit *current_head,
599 struct wt_status *s,
600 struct strbuf *author_ident)
602 struct stat statbuf;
603 struct strbuf committer_ident = STRBUF_INIT;
604 int commitable, saved_color_setting;
605 struct strbuf sb = STRBUF_INIT;
606 char *buffer;
607 const char *hook_arg1 = NULL;
608 const char *hook_arg2 = NULL;
609 int ident_shown = 0;
610 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
612 /* This checks and barfs if author is badly specified */
613 determine_author_info(author_ident);
615 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
616 return 0;
618 if (squash_message) {
620 * Insert the proper subject line before other commit
621 * message options add their content.
623 if (use_message && !strcmp(use_message, squash_message))
624 strbuf_addstr(&sb, "squash! ");
625 else {
626 struct pretty_print_context ctx = {0};
627 struct commit *c;
628 c = lookup_commit_reference_by_name(squash_message);
629 if (!c)
630 die(_("could not lookup commit %s"), squash_message);
631 ctx.output_encoding = get_commit_output_encoding();
632 format_commit_message(c, "squash! %s\n\n", &sb,
633 &ctx);
637 if (message.len) {
638 strbuf_addbuf(&sb, &message);
639 hook_arg1 = "message";
640 } else if (logfile && !strcmp(logfile, "-")) {
641 if (isatty(0))
642 fprintf(stderr, _("(reading log message from standard input)\n"));
643 if (strbuf_read(&sb, 0, 0) < 0)
644 die_errno(_("could not read log from standard input"));
645 hook_arg1 = "message";
646 } else if (logfile) {
647 if (strbuf_read_file(&sb, logfile, 0) < 0)
648 die_errno(_("could not read log file '%s'"),
649 logfile);
650 hook_arg1 = "message";
651 } else if (use_message) {
652 buffer = strstr(use_message_buffer, "\n\n");
653 if (!use_editor && (!buffer || buffer[2] == '\0'))
654 die(_("commit has empty message"));
655 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
656 hook_arg1 = "commit";
657 hook_arg2 = use_message;
658 } else if (fixup_message) {
659 struct pretty_print_context ctx = {0};
660 struct commit *commit;
661 commit = lookup_commit_reference_by_name(fixup_message);
662 if (!commit)
663 die(_("could not lookup commit %s"), fixup_message);
664 ctx.output_encoding = get_commit_output_encoding();
665 format_commit_message(commit, "fixup! %s\n\n",
666 &sb, &ctx);
667 hook_arg1 = "message";
668 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
669 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
670 die_errno(_("could not read MERGE_MSG"));
671 hook_arg1 = "merge";
672 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
673 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
674 die_errno(_("could not read SQUASH_MSG"));
675 hook_arg1 = "squash";
676 } else if (template_file) {
677 if (strbuf_read_file(&sb, template_file, 0) < 0)
678 die_errno(_("could not read '%s'"), template_file);
679 hook_arg1 = "template";
680 clean_message_contents = 0;
684 * The remaining cases don't modify the template message, but
685 * just set the argument(s) to the prepare-commit-msg hook.
687 else if (whence == FROM_MERGE)
688 hook_arg1 = "merge";
689 else if (whence == FROM_CHERRY_PICK) {
690 hook_arg1 = "commit";
691 hook_arg2 = "CHERRY_PICK_HEAD";
694 if (squash_message) {
696 * If squash_commit was used for the commit subject,
697 * then we're possibly hijacking other commit log options.
698 * Reset the hook args to tell the real story.
700 hook_arg1 = "message";
701 hook_arg2 = "";
704 s->fp = fopen(git_path(commit_editmsg), "w");
705 if (s->fp == NULL)
706 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
709 * Most hints are counter-productive when the commit has
710 * already started.
712 s->hints = 0;
714 if (clean_message_contents)
715 stripspace(&sb, 0);
717 if (signoff) {
719 * See if we have a Conflicts: block at the end. If yes, count
720 * its size, so we can ignore it.
722 int ignore_footer = 0;
723 int i, eol, previous = 0;
724 const char *nl;
726 for (i = 0; i < sb.len; i++) {
727 nl = memchr(sb.buf + i, '\n', sb.len - i);
728 if (nl)
729 eol = nl - sb.buf;
730 else
731 eol = sb.len;
732 if (!prefixcmp(sb.buf + previous, "\nConflicts:\n")) {
733 ignore_footer = sb.len - previous;
734 break;
736 while (i < eol)
737 i++;
738 previous = eol;
741 append_signoff(&sb, ignore_footer, 0);
744 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
745 die_errno(_("could not write commit template"));
747 strbuf_release(&sb);
749 /* This checks if committer ident is explicitly given */
750 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
751 if (use_editor && include_status) {
752 char *ai_tmp, *ci_tmp;
753 if (whence != FROM_COMMIT)
754 status_printf_ln(s, GIT_COLOR_NORMAL,
755 whence == FROM_MERGE
756 ? _("\n"
757 "It looks like you may be committing a merge.\n"
758 "If this is not correct, please remove the file\n"
759 " %s\n"
760 "and try again.\n")
761 : _("\n"
762 "It looks like you may be committing a cherry-pick.\n"
763 "If this is not correct, please remove the file\n"
764 " %s\n"
765 "and try again.\n"),
766 git_path(whence == FROM_MERGE
767 ? "MERGE_HEAD"
768 : "CHERRY_PICK_HEAD"));
770 fprintf(s->fp, "\n");
771 if (cleanup_mode == CLEANUP_ALL)
772 status_printf(s, GIT_COLOR_NORMAL,
773 _("Please enter the commit message for your changes."
774 " Lines starting\nwith '%c' will be ignored, and an empty"
775 " message aborts the commit.\n"), comment_line_char);
776 else /* CLEANUP_SPACE, that is. */
777 status_printf(s, GIT_COLOR_NORMAL,
778 _("Please enter the commit message for your changes."
779 " Lines starting\n"
780 "with '%c' will be kept; you may remove them"
781 " yourself if you want to.\n"
782 "An empty message aborts the commit.\n"), comment_line_char);
783 if (only_include_assumed)
784 status_printf_ln(s, GIT_COLOR_NORMAL,
785 "%s", only_include_assumed);
787 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
788 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
789 if (strcmp(author_ident->buf, committer_ident.buf))
790 status_printf_ln(s, GIT_COLOR_NORMAL,
791 _("%s"
792 "Author: %s"),
793 ident_shown++ ? "" : "\n",
794 author_ident->buf);
796 if (!committer_ident_sufficiently_given())
797 status_printf_ln(s, GIT_COLOR_NORMAL,
798 _("%s"
799 "Committer: %s"),
800 ident_shown++ ? "" : "\n",
801 committer_ident.buf);
803 if (ident_shown)
804 status_printf_ln(s, GIT_COLOR_NORMAL, "");
806 saved_color_setting = s->use_color;
807 s->use_color = 0;
808 commitable = run_status(s->fp, index_file, prefix, 1, s);
809 s->use_color = saved_color_setting;
811 *ai_tmp = ' ';
812 *ci_tmp = ' ';
813 } else {
814 unsigned char sha1[20];
815 const char *parent = "HEAD";
817 if (!active_nr && read_cache() < 0)
818 die(_("Cannot read index"));
820 if (amend)
821 parent = "HEAD^1";
823 if (get_sha1(parent, sha1))
824 commitable = !!active_nr;
825 else
826 commitable = index_differs_from(parent, 0);
828 strbuf_release(&committer_ident);
830 fclose(s->fp);
833 * Reject an attempt to record a non-merge empty commit without
834 * explicit --allow-empty. In the cherry-pick case, it may be
835 * empty due to conflict resolution, which the user should okay.
837 if (!commitable && whence != FROM_MERGE && !allow_empty &&
838 !(amend && is_a_merge(current_head))) {
839 run_status(stdout, index_file, prefix, 0, s);
840 if (amend)
841 fputs(_(empty_amend_advice), stderr);
842 else if (whence == FROM_CHERRY_PICK) {
843 fputs(_(empty_cherry_pick_advice), stderr);
844 if (!sequencer_in_use)
845 fputs(_(empty_cherry_pick_advice_single), stderr);
846 else
847 fputs(_(empty_cherry_pick_advice_multi), stderr);
849 return 0;
853 * Re-read the index as pre-commit hook could have updated it,
854 * and write it out as a tree. We must do this before we invoke
855 * the editor and after we invoke run_status above.
857 discard_cache();
858 read_cache_from(index_file);
859 if (update_main_cache_tree(0)) {
860 error(_("Error building trees"));
861 return 0;
864 if (run_hook(index_file, "prepare-commit-msg",
865 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
866 return 0;
868 if (use_editor) {
869 char index[PATH_MAX];
870 const char *env[2] = { NULL };
871 env[0] = index;
872 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
873 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
874 fprintf(stderr,
875 _("Please supply the message using either -m or -F option.\n"));
876 exit(1);
880 if (!no_verify &&
881 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
882 return 0;
885 return 1;
888 static int rest_is_empty(struct strbuf *sb, int start)
890 int i, eol;
891 const char *nl;
893 /* Check if the rest is just whitespace and Signed-of-by's. */
894 for (i = start; i < sb->len; i++) {
895 nl = memchr(sb->buf + i, '\n', sb->len - i);
896 if (nl)
897 eol = nl - sb->buf;
898 else
899 eol = sb->len;
901 if (strlen(sign_off_header) <= eol - i &&
902 !prefixcmp(sb->buf + i, sign_off_header)) {
903 i = eol;
904 continue;
906 while (i < eol)
907 if (!isspace(sb->buf[i++]))
908 return 0;
911 return 1;
915 * Find out if the message in the strbuf contains only whitespace and
916 * Signed-off-by lines.
918 static int message_is_empty(struct strbuf *sb)
920 if (cleanup_mode == CLEANUP_NONE && sb->len)
921 return 0;
922 return rest_is_empty(sb, 0);
926 * See if the user edited the message in the editor or left what
927 * was in the template intact
929 static int template_untouched(struct strbuf *sb)
931 struct strbuf tmpl = STRBUF_INIT;
932 char *start;
934 if (cleanup_mode == CLEANUP_NONE && sb->len)
935 return 0;
937 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
938 return 0;
940 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
941 start = (char *)skip_prefix(sb->buf, tmpl.buf);
942 if (!start)
943 start = sb->buf;
944 strbuf_release(&tmpl);
945 return rest_is_empty(sb, start - sb->buf);
948 static const char *find_author_by_nickname(const char *name)
950 struct rev_info revs;
951 struct commit *commit;
952 struct strbuf buf = STRBUF_INIT;
953 const char *av[20];
954 int ac = 0;
956 init_revisions(&revs, NULL);
957 strbuf_addf(&buf, "--author=%s", name);
958 av[++ac] = "--all";
959 av[++ac] = "-i";
960 av[++ac] = buf.buf;
961 av[++ac] = NULL;
962 setup_revisions(ac, av, &revs, NULL);
963 prepare_revision_walk(&revs);
964 commit = get_revision(&revs);
965 if (commit) {
966 struct pretty_print_context ctx = {0};
967 ctx.date_mode = DATE_NORMAL;
968 strbuf_release(&buf);
969 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
970 return strbuf_detach(&buf, NULL);
972 die(_("No existing author found with '%s'"), name);
976 static void handle_untracked_files_arg(struct wt_status *s)
978 if (!untracked_files_arg)
979 ; /* default already initialized */
980 else if (!strcmp(untracked_files_arg, "no"))
981 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
982 else if (!strcmp(untracked_files_arg, "normal"))
983 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
984 else if (!strcmp(untracked_files_arg, "all"))
985 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
986 else
987 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
990 static const char *read_commit_message(const char *name)
992 const char *out_enc;
993 struct commit *commit;
995 commit = lookup_commit_reference_by_name(name);
996 if (!commit)
997 die(_("could not lookup commit %s"), name);
998 out_enc = get_commit_output_encoding();
999 return logmsg_reencode(commit, NULL, out_enc);
1003 * Enumerate what needs to be propagated when --porcelain
1004 * is not in effect here.
1006 static struct status_deferred_config {
1007 enum status_format status_format;
1008 int show_branch;
1009 } status_deferred_config = {
1010 STATUS_FORMAT_UNSPECIFIED,
1011 -1 /* unspecified */
1014 static void finalize_deferred_config(struct wt_status *s)
1016 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1017 !s->null_termination);
1019 if (s->null_termination) {
1020 if (status_format == STATUS_FORMAT_NONE ||
1021 status_format == STATUS_FORMAT_UNSPECIFIED)
1022 status_format = STATUS_FORMAT_PORCELAIN;
1023 else if (status_format == STATUS_FORMAT_LONG)
1024 die(_("--long and -z are incompatible"));
1027 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1028 status_format = status_deferred_config.status_format;
1029 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1030 status_format = STATUS_FORMAT_NONE;
1032 if (use_deferred_config && s->show_branch < 0)
1033 s->show_branch = status_deferred_config.show_branch;
1034 if (s->show_branch < 0)
1035 s->show_branch = 0;
1038 static int parse_and_validate_options(int argc, const char *argv[],
1039 const struct option *options,
1040 const char * const usage[],
1041 const char *prefix,
1042 struct commit *current_head,
1043 struct wt_status *s)
1045 int f = 0;
1047 argc = parse_options(argc, argv, prefix, options, usage, 0);
1048 finalize_deferred_config(s);
1050 if (force_author && !strchr(force_author, '>'))
1051 force_author = find_author_by_nickname(force_author);
1053 if (force_author && renew_authorship)
1054 die(_("Using both --reset-author and --author does not make sense"));
1056 if (logfile || have_option_m || use_message || fixup_message)
1057 use_editor = 0;
1058 if (0 <= edit_flag)
1059 use_editor = edit_flag;
1060 if (!use_editor)
1061 setenv("GIT_EDITOR", ":", 1);
1063 /* Sanity check options */
1064 if (amend && !current_head)
1065 die(_("You have nothing to amend."));
1066 if (amend && whence != FROM_COMMIT) {
1067 if (whence == FROM_MERGE)
1068 die(_("You are in the middle of a merge -- cannot amend."));
1069 else if (whence == FROM_CHERRY_PICK)
1070 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1072 if (fixup_message && squash_message)
1073 die(_("Options --squash and --fixup cannot be used together"));
1074 if (use_message)
1075 f++;
1076 if (edit_message)
1077 f++;
1078 if (fixup_message)
1079 f++;
1080 if (logfile)
1081 f++;
1082 if (f > 1)
1083 die(_("Only one of -c/-C/-F/--fixup can be used."));
1084 if (message.len && f > 0)
1085 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1086 if (f || message.len)
1087 template_file = NULL;
1088 if (edit_message)
1089 use_message = edit_message;
1090 if (amend && !use_message && !fixup_message)
1091 use_message = "HEAD";
1092 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1093 die(_("--reset-author can be used only with -C, -c or --amend."));
1094 if (use_message) {
1095 use_message_buffer = read_commit_message(use_message);
1096 if (!renew_authorship) {
1097 author_message = use_message;
1098 author_message_buffer = use_message_buffer;
1101 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1102 author_message = "CHERRY_PICK_HEAD";
1103 author_message_buffer = read_commit_message(author_message);
1106 if (patch_interactive)
1107 interactive = 1;
1109 if (!!also + !!only + !!all + !!interactive > 1)
1110 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1111 if (argc == 0 && (also || (only && !amend)))
1112 die(_("No paths with --include/--only does not make sense."));
1113 if (argc == 0 && only && amend)
1114 only_include_assumed = _("Clever... amending the last one with dirty index.");
1115 if (argc > 0 && !also && !only)
1116 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1117 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1118 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1119 else if (!strcmp(cleanup_arg, "verbatim"))
1120 cleanup_mode = CLEANUP_NONE;
1121 else if (!strcmp(cleanup_arg, "whitespace"))
1122 cleanup_mode = CLEANUP_SPACE;
1123 else if (!strcmp(cleanup_arg, "strip"))
1124 cleanup_mode = CLEANUP_ALL;
1125 else
1126 die(_("Invalid cleanup mode %s"), cleanup_arg);
1128 handle_untracked_files_arg(s);
1130 if (all && argc > 0)
1131 die(_("Paths with -a does not make sense."));
1133 if (status_format != STATUS_FORMAT_NONE)
1134 dry_run = 1;
1136 return argc;
1139 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1140 const struct commit *current_head, struct wt_status *s)
1142 int commitable;
1143 const char *index_file;
1145 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1146 commitable = run_status(stdout, index_file, prefix, 0, s);
1147 rollback_index_files();
1149 return commitable ? 0 : 1;
1152 static int parse_status_slot(const char *var, int offset)
1154 if (!strcasecmp(var+offset, "header"))
1155 return WT_STATUS_HEADER;
1156 if (!strcasecmp(var+offset, "branch"))
1157 return WT_STATUS_ONBRANCH;
1158 if (!strcasecmp(var+offset, "updated")
1159 || !strcasecmp(var+offset, "added"))
1160 return WT_STATUS_UPDATED;
1161 if (!strcasecmp(var+offset, "changed"))
1162 return WT_STATUS_CHANGED;
1163 if (!strcasecmp(var+offset, "untracked"))
1164 return WT_STATUS_UNTRACKED;
1165 if (!strcasecmp(var+offset, "nobranch"))
1166 return WT_STATUS_NOBRANCH;
1167 if (!strcasecmp(var+offset, "unmerged"))
1168 return WT_STATUS_UNMERGED;
1169 return -1;
1172 static int git_status_config(const char *k, const char *v, void *cb)
1174 struct wt_status *s = cb;
1176 if (!prefixcmp(k, "column."))
1177 return git_column_config(k, v, "status", &s->colopts);
1178 if (!strcmp(k, "status.submodulesummary")) {
1179 int is_bool;
1180 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1181 if (is_bool && s->submodule_summary)
1182 s->submodule_summary = -1;
1183 return 0;
1185 if (!strcmp(k, "status.short")) {
1186 if (git_config_bool(k, v))
1187 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1188 else
1189 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1190 return 0;
1192 if (!strcmp(k, "status.branch")) {
1193 status_deferred_config.show_branch = git_config_bool(k, v);
1194 return 0;
1196 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1197 s->use_color = git_config_colorbool(k, v);
1198 return 0;
1200 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1201 int slot = parse_status_slot(k, 13);
1202 if (slot < 0)
1203 return 0;
1204 if (!v)
1205 return config_error_nonbool(k);
1206 color_parse(v, k, s->color_palette[slot]);
1207 return 0;
1209 if (!strcmp(k, "status.relativepaths")) {
1210 s->relative_paths = git_config_bool(k, v);
1211 return 0;
1213 if (!strcmp(k, "status.showuntrackedfiles")) {
1214 if (!v)
1215 return config_error_nonbool(k);
1216 else if (!strcmp(v, "no"))
1217 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1218 else if (!strcmp(v, "normal"))
1219 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1220 else if (!strcmp(v, "all"))
1221 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1222 else
1223 return error(_("Invalid untracked files mode '%s'"), v);
1224 return 0;
1226 return git_diff_ui_config(k, v, NULL);
1229 int cmd_status(int argc, const char **argv, const char *prefix)
1231 static struct wt_status s;
1232 int fd;
1233 unsigned char sha1[20];
1234 static struct option builtin_status_options[] = {
1235 OPT__VERBOSE(&verbose, N_("be verbose")),
1236 OPT_SET_INT('s', "short", &status_format,
1237 N_("show status concisely"), STATUS_FORMAT_SHORT),
1238 OPT_BOOL('b', "branch", &s.show_branch,
1239 N_("show branch information")),
1240 OPT_SET_INT(0, "porcelain", &status_format,
1241 N_("machine-readable output"),
1242 STATUS_FORMAT_PORCELAIN),
1243 OPT_SET_INT(0, "long", &status_format,
1244 N_("show status in long format (default)"),
1245 STATUS_FORMAT_LONG),
1246 OPT_BOOLEAN('z', "null", &s.null_termination,
1247 N_("terminate entries with NUL")),
1248 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1249 N_("mode"),
1250 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1251 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1252 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1253 N_("show ignored files")),
1254 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1255 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1256 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1257 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1258 OPT_END(),
1261 if (argc == 2 && !strcmp(argv[1], "-h"))
1262 usage_with_options(builtin_status_usage, builtin_status_options);
1264 status_init_config(&s, git_status_config);
1265 argc = parse_options(argc, argv, prefix,
1266 builtin_status_options,
1267 builtin_status_usage, 0);
1268 finalize_colopts(&s.colopts, -1);
1269 finalize_deferred_config(&s);
1271 handle_untracked_files_arg(&s);
1272 if (show_ignored_in_status)
1273 s.show_ignored_files = 1;
1274 if (*argv)
1275 s.pathspec = get_pathspec(prefix, argv);
1277 read_cache_preload(s.pathspec);
1278 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1280 fd = hold_locked_index(&index_lock, 0);
1281 if (0 <= fd)
1282 update_index_if_able(&the_index, &index_lock);
1284 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1285 s.ignore_submodule_arg = ignore_submodule_arg;
1286 wt_status_collect(&s);
1288 if (s.relative_paths)
1289 s.prefix = prefix;
1291 switch (status_format) {
1292 case STATUS_FORMAT_SHORT:
1293 wt_shortstatus_print(&s);
1294 break;
1295 case STATUS_FORMAT_PORCELAIN:
1296 wt_porcelain_print(&s);
1297 break;
1298 case STATUS_FORMAT_UNSPECIFIED:
1299 die("BUG: finalize_deferred_config() should have been called");
1300 break;
1301 case STATUS_FORMAT_NONE:
1302 case STATUS_FORMAT_LONG:
1303 s.verbose = verbose;
1304 s.ignore_submodule_arg = ignore_submodule_arg;
1305 wt_status_print(&s);
1306 break;
1308 return 0;
1311 static void print_summary(const char *prefix, const unsigned char *sha1,
1312 int initial_commit)
1314 struct rev_info rev;
1315 struct commit *commit;
1316 struct strbuf format = STRBUF_INIT;
1317 unsigned char junk_sha1[20];
1318 const char *head;
1319 struct pretty_print_context pctx = {0};
1320 struct strbuf author_ident = STRBUF_INIT;
1321 struct strbuf committer_ident = STRBUF_INIT;
1323 commit = lookup_commit(sha1);
1324 if (!commit)
1325 die(_("couldn't look up newly created commit"));
1326 if (!commit || parse_commit(commit))
1327 die(_("could not parse newly created commit"));
1329 strbuf_addstr(&format, "format:%h] %s");
1331 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1332 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1333 if (strbuf_cmp(&author_ident, &committer_ident)) {
1334 strbuf_addstr(&format, "\n Author: ");
1335 strbuf_addbuf_percentquote(&format, &author_ident);
1337 if (!committer_ident_sufficiently_given()) {
1338 strbuf_addstr(&format, "\n Committer: ");
1339 strbuf_addbuf_percentquote(&format, &committer_ident);
1340 if (advice_implicit_identity) {
1341 strbuf_addch(&format, '\n');
1342 strbuf_addstr(&format, _(implicit_ident_advice));
1345 strbuf_release(&author_ident);
1346 strbuf_release(&committer_ident);
1348 init_revisions(&rev, prefix);
1349 setup_revisions(0, NULL, &rev, NULL);
1351 rev.diff = 1;
1352 rev.diffopt.output_format =
1353 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1355 rev.verbose_header = 1;
1356 rev.show_root_diff = 1;
1357 get_commit_format(format.buf, &rev);
1358 rev.always_show_header = 0;
1359 rev.diffopt.detect_rename = 1;
1360 rev.diffopt.break_opt = 0;
1361 diff_setup_done(&rev.diffopt);
1363 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1364 printf("[%s%s ",
1365 !prefixcmp(head, "refs/heads/") ?
1366 head + 11 :
1367 !strcmp(head, "HEAD") ?
1368 _("detached HEAD") :
1369 head,
1370 initial_commit ? _(" (root-commit)") : "");
1372 if (!log_tree_commit(&rev, commit)) {
1373 rev.always_show_header = 1;
1374 rev.use_terminator = 1;
1375 log_tree_commit(&rev, commit);
1378 strbuf_release(&format);
1381 static int git_commit_config(const char *k, const char *v, void *cb)
1383 struct wt_status *s = cb;
1384 int status;
1386 if (!strcmp(k, "commit.template"))
1387 return git_config_pathname(&template_file, k, v);
1388 if (!strcmp(k, "commit.status")) {
1389 include_status = git_config_bool(k, v);
1390 return 0;
1392 if (!strcmp(k, "commit.cleanup"))
1393 return git_config_string(&cleanup_arg, k, v);
1395 status = git_gpg_config(k, v, NULL);
1396 if (status)
1397 return status;
1398 return git_status_config(k, v, s);
1401 static int run_rewrite_hook(const unsigned char *oldsha1,
1402 const unsigned char *newsha1)
1404 /* oldsha1 SP newsha1 LF NUL */
1405 static char buf[2*40 + 3];
1406 struct child_process proc;
1407 const char *argv[3];
1408 int code;
1409 size_t n;
1411 argv[0] = find_hook("post-rewrite");
1412 if (!argv[0])
1413 return 0;
1415 argv[1] = "amend";
1416 argv[2] = NULL;
1418 memset(&proc, 0, sizeof(proc));
1419 proc.argv = argv;
1420 proc.in = -1;
1421 proc.stdout_to_stderr = 1;
1423 code = start_command(&proc);
1424 if (code)
1425 return code;
1426 n = snprintf(buf, sizeof(buf), "%s %s\n",
1427 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1428 write_in_full(proc.in, buf, n);
1429 close(proc.in);
1430 return finish_command(&proc);
1433 int cmd_commit(int argc, const char **argv, const char *prefix)
1435 static struct wt_status s;
1436 static struct option builtin_commit_options[] = {
1437 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1438 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1440 OPT_GROUP(N_("Commit message options")),
1441 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1442 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1443 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1444 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1445 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1446 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1447 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1448 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1449 OPT_BOOLEAN(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1450 OPT_BOOLEAN('s', "signoff", &signoff, N_("add Signed-off-by:")),
1451 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1452 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1453 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1454 OPT_BOOLEAN(0, "status", &include_status, N_("include status in commit message template")),
1455 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1456 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1457 /* end commit message options */
1459 OPT_GROUP(N_("Commit contents options")),
1460 OPT_BOOLEAN('a', "all", &all, N_("commit all changed files")),
1461 OPT_BOOLEAN('i', "include", &also, N_("add specified files to index for commit")),
1462 OPT_BOOLEAN(0, "interactive", &interactive, N_("interactively add files")),
1463 OPT_BOOLEAN('p', "patch", &patch_interactive, N_("interactively add changes")),
1464 OPT_BOOLEAN('o', "only", &only, N_("commit only specified files")),
1465 OPT_BOOLEAN('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1466 OPT_BOOLEAN(0, "dry-run", &dry_run, N_("show what would be committed")),
1467 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1468 STATUS_FORMAT_SHORT),
1469 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1470 OPT_SET_INT(0, "porcelain", &status_format,
1471 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1472 OPT_SET_INT(0, "long", &status_format,
1473 N_("show status in long format (default)"),
1474 STATUS_FORMAT_LONG),
1475 OPT_BOOLEAN('z', "null", &s.null_termination,
1476 N_("terminate entries with NUL")),
1477 OPT_BOOLEAN(0, "amend", &amend, N_("amend previous commit")),
1478 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1479 { 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" },
1480 /* end commit contents options */
1482 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
1483 N_("ok to record an empty change"),
1484 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1485 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
1486 N_("ok to record a change with an empty message"),
1487 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1489 OPT_END()
1492 struct strbuf sb = STRBUF_INIT;
1493 struct strbuf author_ident = STRBUF_INIT;
1494 const char *index_file, *reflog_msg;
1495 char *nl, *p;
1496 unsigned char sha1[20];
1497 struct ref_lock *ref_lock;
1498 struct commit_list *parents = NULL, **pptr = &parents;
1499 struct stat statbuf;
1500 int allow_fast_forward = 1;
1501 struct commit *current_head = NULL;
1502 struct commit_extra_header *extra = NULL;
1504 if (argc == 2 && !strcmp(argv[1], "-h"))
1505 usage_with_options(builtin_commit_usage, builtin_commit_options);
1507 status_init_config(&s, git_commit_config);
1508 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1509 s.colopts = 0;
1511 if (get_sha1("HEAD", sha1))
1512 current_head = NULL;
1513 else {
1514 current_head = lookup_commit_or_die(sha1, "HEAD");
1515 if (!current_head || parse_commit(current_head))
1516 die(_("could not parse HEAD commit"));
1518 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1519 builtin_commit_usage,
1520 prefix, current_head, &s);
1521 if (dry_run)
1522 return dry_run_commit(argc, argv, prefix, current_head, &s);
1523 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1525 /* Set up everything for writing the commit object. This includes
1526 running hooks, writing the trees, and interacting with the user. */
1527 if (!prepare_to_commit(index_file, prefix,
1528 current_head, &s, &author_ident)) {
1529 rollback_index_files();
1530 return 1;
1533 /* Determine parents */
1534 reflog_msg = getenv("GIT_REFLOG_ACTION");
1535 if (!current_head) {
1536 if (!reflog_msg)
1537 reflog_msg = "commit (initial)";
1538 } else if (amend) {
1539 struct commit_list *c;
1541 if (!reflog_msg)
1542 reflog_msg = "commit (amend)";
1543 for (c = current_head->parents; c; c = c->next)
1544 pptr = &commit_list_insert(c->item, pptr)->next;
1545 } else if (whence == FROM_MERGE) {
1546 struct strbuf m = STRBUF_INIT;
1547 FILE *fp;
1549 if (!reflog_msg)
1550 reflog_msg = "commit (merge)";
1551 pptr = &commit_list_insert(current_head, pptr)->next;
1552 fp = fopen(git_path("MERGE_HEAD"), "r");
1553 if (fp == NULL)
1554 die_errno(_("could not open '%s' for reading"),
1555 git_path("MERGE_HEAD"));
1556 while (strbuf_getline(&m, fp, '\n') != EOF) {
1557 struct commit *parent;
1559 parent = get_merge_parent(m.buf);
1560 if (!parent)
1561 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1562 pptr = &commit_list_insert(parent, pptr)->next;
1564 fclose(fp);
1565 strbuf_release(&m);
1566 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1567 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1568 die_errno(_("could not read MERGE_MODE"));
1569 if (!strcmp(sb.buf, "no-ff"))
1570 allow_fast_forward = 0;
1572 if (allow_fast_forward)
1573 parents = reduce_heads(parents);
1574 } else {
1575 if (!reflog_msg)
1576 reflog_msg = (whence == FROM_CHERRY_PICK)
1577 ? "commit (cherry-pick)"
1578 : "commit";
1579 pptr = &commit_list_insert(current_head, pptr)->next;
1582 /* Finally, get the commit message */
1583 strbuf_reset(&sb);
1584 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1585 int saved_errno = errno;
1586 rollback_index_files();
1587 die(_("could not read commit message: %s"), strerror(saved_errno));
1590 /* Truncate the message just before the diff, if any. */
1591 if (verbose) {
1592 p = strstr(sb.buf, "\ndiff --git ");
1593 if (p != NULL)
1594 strbuf_setlen(&sb, p - sb.buf + 1);
1597 if (cleanup_mode != CLEANUP_NONE)
1598 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1599 if (template_untouched(&sb) && !allow_empty_message) {
1600 rollback_index_files();
1601 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1602 exit(1);
1604 if (message_is_empty(&sb) && !allow_empty_message) {
1605 rollback_index_files();
1606 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1607 exit(1);
1610 if (amend) {
1611 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1612 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1613 } else {
1614 struct commit_extra_header **tail = &extra;
1615 append_merge_tag_headers(parents, &tail);
1618 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1619 author_ident.buf, sign_commit, extra)) {
1620 rollback_index_files();
1621 die(_("failed to write commit object"));
1623 strbuf_release(&author_ident);
1624 free_commit_extra_headers(extra);
1626 ref_lock = lock_any_ref_for_update("HEAD",
1627 !current_head
1628 ? NULL
1629 : current_head->object.sha1,
1632 nl = strchr(sb.buf, '\n');
1633 if (nl)
1634 strbuf_setlen(&sb, nl + 1 - sb.buf);
1635 else
1636 strbuf_addch(&sb, '\n');
1637 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1638 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1640 if (!ref_lock) {
1641 rollback_index_files();
1642 die(_("cannot lock HEAD ref"));
1644 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1645 rollback_index_files();
1646 die(_("cannot update HEAD ref"));
1649 unlink(git_path("CHERRY_PICK_HEAD"));
1650 unlink(git_path("REVERT_HEAD"));
1651 unlink(git_path("MERGE_HEAD"));
1652 unlink(git_path("MERGE_MSG"));
1653 unlink(git_path("MERGE_MODE"));
1654 unlink(git_path("SQUASH_MSG"));
1656 if (commit_index_files())
1657 die (_("Repository has been updated, but unable to write\n"
1658 "new_index file. Check that disk is not full or quota is\n"
1659 "not exceeded, and then \"git reset HEAD\" to recover."));
1661 rerere(0);
1662 run_hook(get_index_file(), "post-commit", NULL);
1663 if (amend && !no_post_rewrite) {
1664 struct notes_rewrite_cfg *cfg;
1665 cfg = init_copy_notes_for_rewrite("amend");
1666 if (cfg) {
1667 /* we are amending, so current_head is not NULL */
1668 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1669 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1671 run_rewrite_hook(current_head->object.sha1, sha1);
1673 if (!quiet)
1674 print_summary(prefix, sha1, !current_head);
1676 return 0;