Replace filepattern with pathspec for consistency
[git/jnareb-git.git] / builtin / commit.c
blob96684108e7437537536c42fafa7a84ddef848520
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"
33 static const char * const builtin_commit_usage[] = {
34 N_("git commit [options] [--] <pathspec>..."),
35 NULL
38 static const char * const builtin_status_usage[] = {
39 N_("git status [options] [--] <pathspec>..."),
40 NULL
43 static const char implicit_ident_advice[] =
44 N_("Your name and email address were configured automatically based\n"
45 "on your username and hostname. Please check that they are accurate.\n"
46 "You can suppress this message by setting them explicitly:\n"
47 "\n"
48 " git config --global user.name \"Your Name\"\n"
49 " git config --global user.email you@example.com\n"
50 "\n"
51 "After doing this, you may fix the identity used for this commit with:\n"
52 "\n"
53 " git commit --amend --reset-author\n");
55 static const char empty_amend_advice[] =
56 N_("You asked to amend the most recent commit, but doing so would make\n"
57 "it empty. You can repeat your command with --allow-empty, or you can\n"
58 "remove the commit entirely with \"git reset HEAD^\".\n");
60 static const char empty_cherry_pick_advice[] =
61 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
62 "If you wish to commit it anyway, use:\n"
63 "\n"
64 " git commit --allow-empty\n"
65 "\n"
66 "Otherwise, please use 'git reset'\n");
68 static const char *use_message_buffer;
69 static const char commit_editmsg[] = "COMMIT_EDITMSG";
70 static struct lock_file index_lock; /* real index */
71 static struct lock_file false_lock; /* used only for partial commits */
72 static enum {
73 COMMIT_AS_IS = 1,
74 COMMIT_NORMAL,
75 COMMIT_PARTIAL
76 } commit_style;
78 static const char *logfile, *force_author;
79 static const char *template_file;
81 * The _message variables are commit names from which to take
82 * the commit message and/or authorship.
84 static const char *author_message, *author_message_buffer;
85 static char *edit_message, *use_message;
86 static char *fixup_message, *squash_message;
87 static int all, also, interactive, patch_interactive, only, amend, signoff;
88 static int edit_flag = -1; /* unspecified */
89 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
90 static int no_post_rewrite, allow_empty_message;
91 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
92 static char *sign_commit;
95 * The default commit message cleanup mode will remove the lines
96 * beginning with # (shell comments) and leading and trailing
97 * whitespaces (empty lines or containing only whitespaces)
98 * if editor is used, and only the whitespaces if the message
99 * is specified explicitly.
101 static enum {
102 CLEANUP_SPACE,
103 CLEANUP_NONE,
104 CLEANUP_ALL
105 } cleanup_mode;
106 static char *cleanup_arg;
108 static enum commit_whence whence;
109 static int use_editor = 1, include_status = 1;
110 static int show_ignored_in_status;
111 static const char *only_include_assumed;
112 static struct strbuf message = STRBUF_INIT;
114 static enum {
115 STATUS_FORMAT_NONE = 0,
116 STATUS_FORMAT_LONG,
117 STATUS_FORMAT_SHORT,
118 STATUS_FORMAT_PORCELAIN
119 } status_format;
121 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
123 struct strbuf *buf = opt->value;
124 if (unset)
125 strbuf_setlen(buf, 0);
126 else {
127 strbuf_addstr(buf, arg);
128 strbuf_addstr(buf, "\n\n");
130 return 0;
133 static void determine_whence(struct wt_status *s)
135 if (file_exists(git_path("MERGE_HEAD")))
136 whence = FROM_MERGE;
137 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
138 whence = FROM_CHERRY_PICK;
139 else
140 whence = FROM_COMMIT;
141 if (s)
142 s->whence = whence;
145 static void rollback_index_files(void)
147 switch (commit_style) {
148 case COMMIT_AS_IS:
149 break; /* nothing to do */
150 case COMMIT_NORMAL:
151 rollback_lock_file(&index_lock);
152 break;
153 case COMMIT_PARTIAL:
154 rollback_lock_file(&index_lock);
155 rollback_lock_file(&false_lock);
156 break;
160 static int commit_index_files(void)
162 int err = 0;
164 switch (commit_style) {
165 case COMMIT_AS_IS:
166 break; /* nothing to do */
167 case COMMIT_NORMAL:
168 err = commit_lock_file(&index_lock);
169 break;
170 case COMMIT_PARTIAL:
171 err = commit_lock_file(&index_lock);
172 rollback_lock_file(&false_lock);
173 break;
176 return err;
180 * Take a union of paths in the index and the named tree (typically, "HEAD"),
181 * and return the paths that match the given pattern in list.
183 static int list_paths(struct string_list *list, const char *with_tree,
184 const char *prefix, const char **pattern)
186 int i;
187 char *m;
189 if (!pattern)
190 return 0;
192 for (i = 0; pattern[i]; i++)
194 m = xcalloc(1, i);
196 if (with_tree) {
197 char *max_prefix = common_prefix(pattern);
198 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
199 free(max_prefix);
202 for (i = 0; i < active_nr; i++) {
203 struct cache_entry *ce = active_cache[i];
204 struct string_list_item *item;
206 if (ce->ce_flags & CE_UPDATE)
207 continue;
208 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
209 continue;
210 item = string_list_insert(list, ce->name);
211 if (ce_skip_worktree(ce))
212 item->util = item; /* better a valid pointer than a fake one */
215 return report_path_error(m, pattern, prefix);
218 static void add_remove_files(struct string_list *list)
220 int i;
221 for (i = 0; i < list->nr; i++) {
222 struct stat st;
223 struct string_list_item *p = &(list->items[i]);
225 /* p->util is skip-worktree */
226 if (p->util)
227 continue;
229 if (!lstat(p->string, &st)) {
230 if (add_to_cache(p->string, &st, 0))
231 die(_("updating files failed"));
232 } else
233 remove_file_from_cache(p->string);
237 static void create_base_index(const struct commit *current_head)
239 struct tree *tree;
240 struct unpack_trees_options opts;
241 struct tree_desc t;
243 if (!current_head) {
244 discard_cache();
245 return;
248 memset(&opts, 0, sizeof(opts));
249 opts.head_idx = 1;
250 opts.index_only = 1;
251 opts.merge = 1;
252 opts.src_index = &the_index;
253 opts.dst_index = &the_index;
255 opts.fn = oneway_merge;
256 tree = parse_tree_indirect(current_head->object.sha1);
257 if (!tree)
258 die(_("failed to unpack HEAD tree object"));
259 parse_tree(tree);
260 init_tree_desc(&t, tree->buffer, tree->size);
261 if (unpack_trees(1, &t, &opts))
262 exit(128); /* We've already reported the error, finish dying */
265 static void refresh_cache_or_die(int refresh_flags)
268 * refresh_flags contains REFRESH_QUIET, so the only errors
269 * are for unmerged entries.
271 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
272 die_resolve_conflict("commit");
275 static char *prepare_index(int argc, const char **argv, const char *prefix,
276 const struct commit *current_head, int is_status)
278 int fd;
279 struct string_list partial;
280 const char **pathspec = NULL;
281 char *old_index_env = NULL;
282 int refresh_flags = REFRESH_QUIET;
284 if (is_status)
285 refresh_flags |= REFRESH_UNMERGED;
287 if (*argv)
288 pathspec = get_pathspec(prefix, argv);
290 if (read_cache_preload(pathspec) < 0)
291 die(_("index file corrupt"));
293 if (interactive) {
294 fd = hold_locked_index(&index_lock, 1);
296 refresh_cache_or_die(refresh_flags);
298 if (write_cache(fd, active_cache, active_nr) ||
299 close_lock_file(&index_lock))
300 die(_("unable to create temporary index"));
302 old_index_env = getenv(INDEX_ENVIRONMENT);
303 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
305 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
306 die(_("interactive add failed"));
308 if (old_index_env && *old_index_env)
309 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
310 else
311 unsetenv(INDEX_ENVIRONMENT);
313 discard_cache();
314 read_cache_from(index_lock.filename);
316 commit_style = COMMIT_NORMAL;
317 return index_lock.filename;
321 * Non partial, non as-is commit.
323 * (1) get the real index;
324 * (2) update the_index as necessary;
325 * (3) write the_index out to the real index (still locked);
326 * (4) return the name of the locked index file.
328 * The caller should run hooks on the locked real index, and
329 * (A) if all goes well, commit the real index;
330 * (B) on failure, rollback the real index.
332 if (all || (also && pathspec && *pathspec)) {
333 fd = hold_locked_index(&index_lock, 1);
334 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
335 refresh_cache_or_die(refresh_flags);
336 update_main_cache_tree(WRITE_TREE_SILENT);
337 if (write_cache(fd, active_cache, active_nr) ||
338 close_lock_file(&index_lock))
339 die(_("unable to write new_index file"));
340 commit_style = COMMIT_NORMAL;
341 return index_lock.filename;
345 * As-is commit.
347 * (1) return the name of the real index file.
349 * The caller should run hooks on the real index,
350 * and create commit from the_index.
351 * We still need to refresh the index here.
353 if (!only && (!pathspec || !*pathspec)) {
354 fd = hold_locked_index(&index_lock, 1);
355 refresh_cache_or_die(refresh_flags);
356 if (active_cache_changed) {
357 update_main_cache_tree(WRITE_TREE_SILENT);
358 if (write_cache(fd, active_cache, active_nr) ||
359 commit_locked_index(&index_lock))
360 die(_("unable to write new_index file"));
361 } else {
362 rollback_lock_file(&index_lock);
364 commit_style = COMMIT_AS_IS;
365 return get_index_file();
369 * A partial commit.
371 * (0) find the set of affected paths;
372 * (1) get lock on the real index file;
373 * (2) update the_index with the given paths;
374 * (3) write the_index out to the real index (still locked);
375 * (4) get lock on the false index file;
376 * (5) reset the_index from HEAD;
377 * (6) update the_index the same way as (2);
378 * (7) write the_index out to the false index file;
379 * (8) return the name of the false index file (still locked);
381 * The caller should run hooks on the locked false index, and
382 * create commit from it. Then
383 * (A) if all goes well, commit the real index;
384 * (B) on failure, rollback the real index;
385 * In either case, rollback the false index.
387 commit_style = COMMIT_PARTIAL;
389 if (whence != FROM_COMMIT) {
390 if (whence == FROM_MERGE)
391 die(_("cannot do a partial commit during a merge."));
392 else if (whence == FROM_CHERRY_PICK)
393 die(_("cannot do a partial commit during a cherry-pick."));
396 memset(&partial, 0, sizeof(partial));
397 partial.strdup_strings = 1;
398 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
399 exit(1);
401 discard_cache();
402 if (read_cache() < 0)
403 die(_("cannot read the index"));
405 fd = hold_locked_index(&index_lock, 1);
406 add_remove_files(&partial);
407 refresh_cache(REFRESH_QUIET);
408 if (write_cache(fd, active_cache, active_nr) ||
409 close_lock_file(&index_lock))
410 die(_("unable to write new_index file"));
412 fd = hold_lock_file_for_update(&false_lock,
413 git_path("next-index-%"PRIuMAX,
414 (uintmax_t) getpid()),
415 LOCK_DIE_ON_ERROR);
417 create_base_index(current_head);
418 add_remove_files(&partial);
419 refresh_cache(REFRESH_QUIET);
421 if (write_cache(fd, active_cache, active_nr) ||
422 close_lock_file(&false_lock))
423 die(_("unable to write temporary index file"));
425 discard_cache();
426 read_cache_from(false_lock.filename);
428 return false_lock.filename;
431 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
432 struct wt_status *s)
434 unsigned char sha1[20];
436 if (s->relative_paths)
437 s->prefix = prefix;
439 if (amend) {
440 s->amend = 1;
441 s->reference = "HEAD^1";
443 s->verbose = verbose;
444 s->index_file = index_file;
445 s->fp = fp;
446 s->nowarn = nowarn;
447 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
449 wt_status_collect(s);
451 switch (status_format) {
452 case STATUS_FORMAT_SHORT:
453 wt_shortstatus_print(s);
454 break;
455 case STATUS_FORMAT_PORCELAIN:
456 wt_porcelain_print(s);
457 break;
458 case STATUS_FORMAT_NONE:
459 case STATUS_FORMAT_LONG:
460 wt_status_print(s);
461 break;
464 return s->commitable;
467 static int is_a_merge(const struct commit *current_head)
469 return !!(current_head->parents && current_head->parents->next);
472 static void export_one(const char *var, const char *s, const char *e, int hack)
474 struct strbuf buf = STRBUF_INIT;
475 if (hack)
476 strbuf_addch(&buf, hack);
477 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
478 setenv(var, buf.buf, 1);
479 strbuf_release(&buf);
482 static int sane_ident_split(struct ident_split *person)
484 if (!person->name_begin || !person->name_end ||
485 person->name_begin == person->name_end)
486 return 0; /* no human readable name */
487 if (!person->mail_begin || !person->mail_end ||
488 person->mail_begin == person->mail_end)
489 return 0; /* no usable mail */
490 if (!person->date_begin || !person->date_end ||
491 !person->tz_begin || !person->tz_end)
492 return 0;
493 return 1;
496 static void determine_author_info(struct strbuf *author_ident)
498 char *name, *email, *date;
499 struct ident_split author;
501 name = getenv("GIT_AUTHOR_NAME");
502 email = getenv("GIT_AUTHOR_EMAIL");
503 date = getenv("GIT_AUTHOR_DATE");
505 if (author_message) {
506 const char *a, *lb, *rb, *eol;
507 size_t len;
509 a = strstr(author_message_buffer, "\nauthor ");
510 if (!a)
511 die(_("invalid commit: %s"), author_message);
513 lb = strchrnul(a + strlen("\nauthor "), '<');
514 rb = strchrnul(lb, '>');
515 eol = strchrnul(rb, '\n');
516 if (!*lb || !*rb || !*eol)
517 die(_("invalid commit: %s"), author_message);
519 if (lb == a + strlen("\nauthor "))
520 /* \nauthor <foo@example.com> */
521 name = xcalloc(1, 1);
522 else
523 name = xmemdupz(a + strlen("\nauthor "),
524 (lb - strlen(" ") -
525 (a + strlen("\nauthor "))));
526 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
527 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
528 len = eol - (rb + strlen("> "));
529 date = xmalloc(len + 2);
530 *date = '@';
531 memcpy(date + 1, rb + strlen("> "), len);
532 date[len + 1] = '\0';
535 if (force_author) {
536 const char *lb = strstr(force_author, " <");
537 const char *rb = strchr(force_author, '>');
539 if (!lb || !rb)
540 die(_("malformed --author parameter"));
541 name = xstrndup(force_author, lb - force_author);
542 email = xstrndup(lb + 2, rb - (lb + 2));
545 if (force_date)
546 date = force_date;
547 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
548 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
549 sane_ident_split(&author)) {
550 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
551 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
552 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
556 static char *cut_ident_timestamp_part(char *string)
558 char *ket = strrchr(string, '>');
559 if (!ket || ket[1] != ' ')
560 die(_("Malformed ident string: '%s'"), string);
561 *++ket = '\0';
562 return ket;
565 static int prepare_to_commit(const char *index_file, const char *prefix,
566 struct commit *current_head,
567 struct wt_status *s,
568 struct strbuf *author_ident)
570 struct stat statbuf;
571 struct strbuf committer_ident = STRBUF_INIT;
572 int commitable, saved_color_setting;
573 struct strbuf sb = STRBUF_INIT;
574 char *buffer;
575 const char *hook_arg1 = NULL;
576 const char *hook_arg2 = NULL;
577 int ident_shown = 0;
578 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
580 /* This checks and barfs if author is badly specified */
581 determine_author_info(author_ident);
583 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
584 return 0;
586 if (squash_message) {
588 * Insert the proper subject line before other commit
589 * message options add their content.
591 if (use_message && !strcmp(use_message, squash_message))
592 strbuf_addstr(&sb, "squash! ");
593 else {
594 struct pretty_print_context ctx = {0};
595 struct commit *c;
596 c = lookup_commit_reference_by_name(squash_message);
597 if (!c)
598 die(_("could not lookup commit %s"), squash_message);
599 ctx.output_encoding = get_commit_output_encoding();
600 format_commit_message(c, "squash! %s\n\n", &sb,
601 &ctx);
605 if (message.len) {
606 strbuf_addbuf(&sb, &message);
607 hook_arg1 = "message";
608 } else if (logfile && !strcmp(logfile, "-")) {
609 if (isatty(0))
610 fprintf(stderr, _("(reading log message from standard input)\n"));
611 if (strbuf_read(&sb, 0, 0) < 0)
612 die_errno(_("could not read log from standard input"));
613 hook_arg1 = "message";
614 } else if (logfile) {
615 if (strbuf_read_file(&sb, logfile, 0) < 0)
616 die_errno(_("could not read log file '%s'"),
617 logfile);
618 hook_arg1 = "message";
619 } else if (use_message) {
620 buffer = strstr(use_message_buffer, "\n\n");
621 if (!use_editor && (!buffer || buffer[2] == '\0'))
622 die(_("commit has empty message"));
623 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
624 hook_arg1 = "commit";
625 hook_arg2 = use_message;
626 } else if (fixup_message) {
627 struct pretty_print_context ctx = {0};
628 struct commit *commit;
629 commit = lookup_commit_reference_by_name(fixup_message);
630 if (!commit)
631 die(_("could not lookup commit %s"), fixup_message);
632 ctx.output_encoding = get_commit_output_encoding();
633 format_commit_message(commit, "fixup! %s\n\n",
634 &sb, &ctx);
635 hook_arg1 = "message";
636 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
637 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
638 die_errno(_("could not read MERGE_MSG"));
639 hook_arg1 = "merge";
640 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
641 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
642 die_errno(_("could not read SQUASH_MSG"));
643 hook_arg1 = "squash";
644 } else if (template_file) {
645 if (strbuf_read_file(&sb, template_file, 0) < 0)
646 die_errno(_("could not read '%s'"), template_file);
647 hook_arg1 = "template";
648 clean_message_contents = 0;
652 * The remaining cases don't modify the template message, but
653 * just set the argument(s) to the prepare-commit-msg hook.
655 else if (whence == FROM_MERGE)
656 hook_arg1 = "merge";
657 else if (whence == FROM_CHERRY_PICK) {
658 hook_arg1 = "commit";
659 hook_arg2 = "CHERRY_PICK_HEAD";
662 if (squash_message) {
664 * If squash_commit was used for the commit subject,
665 * then we're possibly hijacking other commit log options.
666 * Reset the hook args to tell the real story.
668 hook_arg1 = "message";
669 hook_arg2 = "";
672 s->fp = fopen(git_path(commit_editmsg), "w");
673 if (s->fp == NULL)
674 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
676 if (clean_message_contents)
677 stripspace(&sb, 0);
679 if (signoff) {
681 * See if we have a Conflicts: block at the end. If yes, count
682 * its size, so we can ignore it.
684 int ignore_footer = 0;
685 int i, eol, previous = 0;
686 const char *nl;
688 for (i = 0; i < sb.len; i++) {
689 nl = memchr(sb.buf + i, '\n', sb.len - i);
690 if (nl)
691 eol = nl - sb.buf;
692 else
693 eol = sb.len;
694 if (!prefixcmp(sb.buf + previous, "\nConflicts:\n")) {
695 ignore_footer = sb.len - previous;
696 break;
698 while (i < eol)
699 i++;
700 previous = eol;
703 append_signoff(&sb, ignore_footer);
706 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
707 die_errno(_("could not write commit template"));
709 strbuf_release(&sb);
711 /* This checks if committer ident is explicitly given */
712 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
713 if (use_editor && include_status) {
714 char *ai_tmp, *ci_tmp;
715 if (whence != FROM_COMMIT)
716 status_printf_ln(s, GIT_COLOR_NORMAL,
717 whence == FROM_MERGE
718 ? _("\n"
719 "It looks like you may be committing a merge.\n"
720 "If this is not correct, please remove the file\n"
721 " %s\n"
722 "and try again.\n")
723 : _("\n"
724 "It looks like you may be committing a cherry-pick.\n"
725 "If this is not correct, please remove the file\n"
726 " %s\n"
727 "and try again.\n"),
728 git_path(whence == FROM_MERGE
729 ? "MERGE_HEAD"
730 : "CHERRY_PICK_HEAD"));
732 fprintf(s->fp, "\n");
733 if (cleanup_mode == CLEANUP_ALL)
734 status_printf(s, GIT_COLOR_NORMAL,
735 _("Please enter the commit message for your changes."
736 " Lines starting\nwith '#' will be ignored, and an empty"
737 " message aborts the commit.\n"));
738 else /* CLEANUP_SPACE, that is. */
739 status_printf(s, GIT_COLOR_NORMAL,
740 _("Please enter the commit message for your changes."
741 " Lines starting\n"
742 "with '#' will be kept; you may remove them"
743 " yourself if you want to.\n"
744 "An empty message aborts the commit.\n"));
745 if (only_include_assumed)
746 status_printf_ln(s, GIT_COLOR_NORMAL,
747 "%s", only_include_assumed);
749 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
750 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
751 if (strcmp(author_ident->buf, committer_ident.buf))
752 status_printf_ln(s, GIT_COLOR_NORMAL,
753 _("%s"
754 "Author: %s"),
755 ident_shown++ ? "" : "\n",
756 author_ident->buf);
758 if (!committer_ident_sufficiently_given())
759 status_printf_ln(s, GIT_COLOR_NORMAL,
760 _("%s"
761 "Committer: %s"),
762 ident_shown++ ? "" : "\n",
763 committer_ident.buf);
765 if (ident_shown)
766 status_printf_ln(s, GIT_COLOR_NORMAL, "");
768 saved_color_setting = s->use_color;
769 s->use_color = 0;
770 commitable = run_status(s->fp, index_file, prefix, 1, s);
771 s->use_color = saved_color_setting;
773 *ai_tmp = ' ';
774 *ci_tmp = ' ';
775 } else {
776 unsigned char sha1[20];
777 const char *parent = "HEAD";
779 if (!active_nr && read_cache() < 0)
780 die(_("Cannot read index"));
782 if (amend)
783 parent = "HEAD^1";
785 if (get_sha1(parent, sha1))
786 commitable = !!active_nr;
787 else
788 commitable = index_differs_from(parent, 0);
790 strbuf_release(&committer_ident);
792 fclose(s->fp);
795 * Reject an attempt to record a non-merge empty commit without
796 * explicit --allow-empty. In the cherry-pick case, it may be
797 * empty due to conflict resolution, which the user should okay.
799 if (!commitable && whence != FROM_MERGE && !allow_empty &&
800 !(amend && is_a_merge(current_head))) {
801 run_status(stdout, index_file, prefix, 0, s);
802 if (amend)
803 fputs(_(empty_amend_advice), stderr);
804 else if (whence == FROM_CHERRY_PICK)
805 fputs(_(empty_cherry_pick_advice), stderr);
806 return 0;
810 * Re-read the index as pre-commit hook could have updated it,
811 * and write it out as a tree. We must do this before we invoke
812 * the editor and after we invoke run_status above.
814 discard_cache();
815 read_cache_from(index_file);
816 if (update_main_cache_tree(0)) {
817 error(_("Error building trees"));
818 return 0;
821 if (run_hook(index_file, "prepare-commit-msg",
822 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
823 return 0;
825 if (use_editor) {
826 char index[PATH_MAX];
827 const char *env[2] = { NULL };
828 env[0] = index;
829 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
830 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
831 fprintf(stderr,
832 _("Please supply the message using either -m or -F option.\n"));
833 exit(1);
837 if (!no_verify &&
838 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
839 return 0;
842 return 1;
845 static int rest_is_empty(struct strbuf *sb, int start)
847 int i, eol;
848 const char *nl;
850 /* Check if the rest is just whitespace and Signed-of-by's. */
851 for (i = start; i < sb->len; i++) {
852 nl = memchr(sb->buf + i, '\n', sb->len - i);
853 if (nl)
854 eol = nl - sb->buf;
855 else
856 eol = sb->len;
858 if (strlen(sign_off_header) <= eol - i &&
859 !prefixcmp(sb->buf + i, sign_off_header)) {
860 i = eol;
861 continue;
863 while (i < eol)
864 if (!isspace(sb->buf[i++]))
865 return 0;
868 return 1;
872 * Find out if the message in the strbuf contains only whitespace and
873 * Signed-off-by lines.
875 static int message_is_empty(struct strbuf *sb)
877 if (cleanup_mode == CLEANUP_NONE && sb->len)
878 return 0;
879 return rest_is_empty(sb, 0);
883 * See if the user edited the message in the editor or left what
884 * was in the template intact
886 static int template_untouched(struct strbuf *sb)
888 struct strbuf tmpl = STRBUF_INIT;
889 char *start;
891 if (cleanup_mode == CLEANUP_NONE && sb->len)
892 return 0;
894 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
895 return 0;
897 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
898 start = (char *)skip_prefix(sb->buf, tmpl.buf);
899 if (!start)
900 start = sb->buf;
901 strbuf_release(&tmpl);
902 return rest_is_empty(sb, start - sb->buf);
905 static const char *find_author_by_nickname(const char *name)
907 struct rev_info revs;
908 struct commit *commit;
909 struct strbuf buf = STRBUF_INIT;
910 const char *av[20];
911 int ac = 0;
913 init_revisions(&revs, NULL);
914 strbuf_addf(&buf, "--author=%s", name);
915 av[++ac] = "--all";
916 av[++ac] = "-i";
917 av[++ac] = buf.buf;
918 av[++ac] = NULL;
919 setup_revisions(ac, av, &revs, NULL);
920 prepare_revision_walk(&revs);
921 commit = get_revision(&revs);
922 if (commit) {
923 struct pretty_print_context ctx = {0};
924 ctx.date_mode = DATE_NORMAL;
925 strbuf_release(&buf);
926 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
927 return strbuf_detach(&buf, NULL);
929 die(_("No existing author found with '%s'"), name);
933 static void handle_untracked_files_arg(struct wt_status *s)
935 if (!untracked_files_arg)
936 ; /* default already initialized */
937 else if (!strcmp(untracked_files_arg, "no"))
938 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
939 else if (!strcmp(untracked_files_arg, "normal"))
940 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
941 else if (!strcmp(untracked_files_arg, "all"))
942 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
943 else
944 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
947 static const char *read_commit_message(const char *name)
949 const char *out_enc, *out;
950 struct commit *commit;
952 commit = lookup_commit_reference_by_name(name);
953 if (!commit)
954 die(_("could not lookup commit %s"), name);
955 out_enc = get_commit_output_encoding();
956 out = logmsg_reencode(commit, out_enc);
959 * If we failed to reencode the buffer, just copy it
960 * byte for byte so the user can try to fix it up.
961 * This also handles the case where input and output
962 * encodings are identical.
964 if (out == NULL)
965 out = xstrdup(commit->buffer);
966 return out;
969 static int parse_and_validate_options(int argc, const char *argv[],
970 const struct option *options,
971 const char * const usage[],
972 const char *prefix,
973 struct commit *current_head,
974 struct wt_status *s)
976 int f = 0;
978 argc = parse_options(argc, argv, prefix, options, usage, 0);
980 if (force_author && !strchr(force_author, '>'))
981 force_author = find_author_by_nickname(force_author);
983 if (force_author && renew_authorship)
984 die(_("Using both --reset-author and --author does not make sense"));
986 if (logfile || message.len || use_message || fixup_message)
987 use_editor = 0;
988 if (0 <= edit_flag)
989 use_editor = edit_flag;
990 if (!use_editor)
991 setenv("GIT_EDITOR", ":", 1);
993 /* Sanity check options */
994 if (amend && !current_head)
995 die(_("You have nothing to amend."));
996 if (amend && whence != FROM_COMMIT) {
997 if (whence == FROM_MERGE)
998 die(_("You are in the middle of a merge -- cannot amend."));
999 else if (whence == FROM_CHERRY_PICK)
1000 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1002 if (fixup_message && squash_message)
1003 die(_("Options --squash and --fixup cannot be used together"));
1004 if (use_message)
1005 f++;
1006 if (edit_message)
1007 f++;
1008 if (fixup_message)
1009 f++;
1010 if (logfile)
1011 f++;
1012 if (f > 1)
1013 die(_("Only one of -c/-C/-F/--fixup can be used."));
1014 if (message.len && f > 0)
1015 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1016 if (f || message.len)
1017 template_file = NULL;
1018 if (edit_message)
1019 use_message = edit_message;
1020 if (amend && !use_message && !fixup_message)
1021 use_message = "HEAD";
1022 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1023 die(_("--reset-author can be used only with -C, -c or --amend."));
1024 if (use_message) {
1025 use_message_buffer = read_commit_message(use_message);
1026 if (!renew_authorship) {
1027 author_message = use_message;
1028 author_message_buffer = use_message_buffer;
1031 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1032 author_message = "CHERRY_PICK_HEAD";
1033 author_message_buffer = read_commit_message(author_message);
1036 if (patch_interactive)
1037 interactive = 1;
1039 if (!!also + !!only + !!all + !!interactive > 1)
1040 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1041 if (argc == 0 && (also || (only && !amend)))
1042 die(_("No paths with --include/--only does not make sense."));
1043 if (argc == 0 && only && amend)
1044 only_include_assumed = _("Clever... amending the last one with dirty index.");
1045 if (argc > 0 && !also && !only)
1046 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1047 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1048 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1049 else if (!strcmp(cleanup_arg, "verbatim"))
1050 cleanup_mode = CLEANUP_NONE;
1051 else if (!strcmp(cleanup_arg, "whitespace"))
1052 cleanup_mode = CLEANUP_SPACE;
1053 else if (!strcmp(cleanup_arg, "strip"))
1054 cleanup_mode = CLEANUP_ALL;
1055 else
1056 die(_("Invalid cleanup mode %s"), cleanup_arg);
1058 handle_untracked_files_arg(s);
1060 if (all && argc > 0)
1061 die(_("Paths with -a does not make sense."));
1063 if (s->null_termination) {
1064 if (status_format == STATUS_FORMAT_NONE)
1065 status_format = STATUS_FORMAT_PORCELAIN;
1066 else if (status_format == STATUS_FORMAT_LONG)
1067 die(_("--long and -z are incompatible"));
1069 if (status_format != STATUS_FORMAT_NONE)
1070 dry_run = 1;
1072 return argc;
1075 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1076 const struct commit *current_head, struct wt_status *s)
1078 int commitable;
1079 const char *index_file;
1081 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1082 commitable = run_status(stdout, index_file, prefix, 0, s);
1083 rollback_index_files();
1085 return commitable ? 0 : 1;
1088 static int parse_status_slot(const char *var, int offset)
1090 if (!strcasecmp(var+offset, "header"))
1091 return WT_STATUS_HEADER;
1092 if (!strcasecmp(var+offset, "branch"))
1093 return WT_STATUS_ONBRANCH;
1094 if (!strcasecmp(var+offset, "updated")
1095 || !strcasecmp(var+offset, "added"))
1096 return WT_STATUS_UPDATED;
1097 if (!strcasecmp(var+offset, "changed"))
1098 return WT_STATUS_CHANGED;
1099 if (!strcasecmp(var+offset, "untracked"))
1100 return WT_STATUS_UNTRACKED;
1101 if (!strcasecmp(var+offset, "nobranch"))
1102 return WT_STATUS_NOBRANCH;
1103 if (!strcasecmp(var+offset, "unmerged"))
1104 return WT_STATUS_UNMERGED;
1105 return -1;
1108 static int git_status_config(const char *k, const char *v, void *cb)
1110 struct wt_status *s = cb;
1112 if (!prefixcmp(k, "column."))
1113 return git_column_config(k, v, "status", &s->colopts);
1114 if (!strcmp(k, "status.submodulesummary")) {
1115 int is_bool;
1116 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1117 if (is_bool && s->submodule_summary)
1118 s->submodule_summary = -1;
1119 return 0;
1121 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1122 s->use_color = git_config_colorbool(k, v);
1123 return 0;
1125 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1126 int slot = parse_status_slot(k, 13);
1127 if (slot < 0)
1128 return 0;
1129 if (!v)
1130 return config_error_nonbool(k);
1131 color_parse(v, k, s->color_palette[slot]);
1132 return 0;
1134 if (!strcmp(k, "status.relativepaths")) {
1135 s->relative_paths = git_config_bool(k, v);
1136 return 0;
1138 if (!strcmp(k, "status.showuntrackedfiles")) {
1139 if (!v)
1140 return config_error_nonbool(k);
1141 else if (!strcmp(v, "no"))
1142 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1143 else if (!strcmp(v, "normal"))
1144 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1145 else if (!strcmp(v, "all"))
1146 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1147 else
1148 return error(_("Invalid untracked files mode '%s'"), v);
1149 return 0;
1151 return git_diff_ui_config(k, v, NULL);
1154 int cmd_status(int argc, const char **argv, const char *prefix)
1156 static struct wt_status s;
1157 int fd;
1158 unsigned char sha1[20];
1159 static struct option builtin_status_options[] = {
1160 OPT__VERBOSE(&verbose, N_("be verbose")),
1161 OPT_SET_INT('s', "short", &status_format,
1162 N_("show status concisely"), STATUS_FORMAT_SHORT),
1163 OPT_BOOLEAN('b', "branch", &s.show_branch,
1164 N_("show branch information")),
1165 OPT_SET_INT(0, "porcelain", &status_format,
1166 N_("machine-readable output"),
1167 STATUS_FORMAT_PORCELAIN),
1168 OPT_SET_INT(0, "long", &status_format,
1169 N_("show status in long format (default)"),
1170 STATUS_FORMAT_LONG),
1171 OPT_BOOLEAN('z', "null", &s.null_termination,
1172 N_("terminate entries with NUL")),
1173 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1174 N_("mode"),
1175 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1176 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1177 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1178 N_("show ignored files")),
1179 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1180 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1181 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1182 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1183 OPT_END(),
1186 if (argc == 2 && !strcmp(argv[1], "-h"))
1187 usage_with_options(builtin_status_usage, builtin_status_options);
1189 wt_status_prepare(&s);
1190 gitmodules_config();
1191 git_config(git_status_config, &s);
1192 determine_whence(&s);
1193 argc = parse_options(argc, argv, prefix,
1194 builtin_status_options,
1195 builtin_status_usage, 0);
1196 finalize_colopts(&s.colopts, -1);
1198 if (s.null_termination) {
1199 if (status_format == STATUS_FORMAT_NONE)
1200 status_format = STATUS_FORMAT_PORCELAIN;
1201 else if (status_format == STATUS_FORMAT_LONG)
1202 die(_("--long and -z are incompatible"));
1205 handle_untracked_files_arg(&s);
1206 if (show_ignored_in_status)
1207 s.show_ignored_files = 1;
1208 if (*argv)
1209 s.pathspec = get_pathspec(prefix, argv);
1211 read_cache_preload(s.pathspec);
1212 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1214 fd = hold_locked_index(&index_lock, 0);
1215 if (0 <= fd)
1216 update_index_if_able(&the_index, &index_lock);
1218 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1219 s.ignore_submodule_arg = ignore_submodule_arg;
1220 wt_status_collect(&s);
1222 if (s.relative_paths)
1223 s.prefix = prefix;
1225 switch (status_format) {
1226 case STATUS_FORMAT_SHORT:
1227 wt_shortstatus_print(&s);
1228 break;
1229 case STATUS_FORMAT_PORCELAIN:
1230 wt_porcelain_print(&s);
1231 break;
1232 case STATUS_FORMAT_NONE:
1233 case STATUS_FORMAT_LONG:
1234 s.verbose = verbose;
1235 s.ignore_submodule_arg = ignore_submodule_arg;
1236 wt_status_print(&s);
1237 break;
1239 return 0;
1242 static void print_summary(const char *prefix, const unsigned char *sha1,
1243 int initial_commit)
1245 struct rev_info rev;
1246 struct commit *commit;
1247 struct strbuf format = STRBUF_INIT;
1248 unsigned char junk_sha1[20];
1249 const char *head;
1250 struct pretty_print_context pctx = {0};
1251 struct strbuf author_ident = STRBUF_INIT;
1252 struct strbuf committer_ident = STRBUF_INIT;
1254 commit = lookup_commit(sha1);
1255 if (!commit)
1256 die(_("couldn't look up newly created commit"));
1257 if (!commit || parse_commit(commit))
1258 die(_("could not parse newly created commit"));
1260 strbuf_addstr(&format, "format:%h] %s");
1262 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1263 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1264 if (strbuf_cmp(&author_ident, &committer_ident)) {
1265 strbuf_addstr(&format, "\n Author: ");
1266 strbuf_addbuf_percentquote(&format, &author_ident);
1268 if (!committer_ident_sufficiently_given()) {
1269 strbuf_addstr(&format, "\n Committer: ");
1270 strbuf_addbuf_percentquote(&format, &committer_ident);
1271 if (advice_implicit_identity) {
1272 strbuf_addch(&format, '\n');
1273 strbuf_addstr(&format, _(implicit_ident_advice));
1276 strbuf_release(&author_ident);
1277 strbuf_release(&committer_ident);
1279 init_revisions(&rev, prefix);
1280 setup_revisions(0, NULL, &rev, NULL);
1282 rev.diff = 1;
1283 rev.diffopt.output_format =
1284 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1286 rev.verbose_header = 1;
1287 rev.show_root_diff = 1;
1288 get_commit_format(format.buf, &rev);
1289 rev.always_show_header = 0;
1290 rev.diffopt.detect_rename = 1;
1291 rev.diffopt.break_opt = 0;
1292 diff_setup_done(&rev.diffopt);
1294 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1295 printf("[%s%s ",
1296 !prefixcmp(head, "refs/heads/") ?
1297 head + 11 :
1298 !strcmp(head, "HEAD") ?
1299 _("detached HEAD") :
1300 head,
1301 initial_commit ? _(" (root-commit)") : "");
1303 if (!log_tree_commit(&rev, commit)) {
1304 rev.always_show_header = 1;
1305 rev.use_terminator = 1;
1306 log_tree_commit(&rev, commit);
1309 strbuf_release(&format);
1312 static int git_commit_config(const char *k, const char *v, void *cb)
1314 struct wt_status *s = cb;
1315 int status;
1317 if (!strcmp(k, "commit.template"))
1318 return git_config_pathname(&template_file, k, v);
1319 if (!strcmp(k, "commit.status")) {
1320 include_status = git_config_bool(k, v);
1321 return 0;
1324 status = git_gpg_config(k, v, NULL);
1325 if (status)
1326 return status;
1327 return git_status_config(k, v, s);
1330 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1332 static int run_rewrite_hook(const unsigned char *oldsha1,
1333 const unsigned char *newsha1)
1335 /* oldsha1 SP newsha1 LF NUL */
1336 static char buf[2*40 + 3];
1337 struct child_process proc;
1338 const char *argv[3];
1339 int code;
1340 size_t n;
1342 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1343 return 0;
1345 argv[0] = git_path(post_rewrite_hook);
1346 argv[1] = "amend";
1347 argv[2] = NULL;
1349 memset(&proc, 0, sizeof(proc));
1350 proc.argv = argv;
1351 proc.in = -1;
1352 proc.stdout_to_stderr = 1;
1354 code = start_command(&proc);
1355 if (code)
1356 return code;
1357 n = snprintf(buf, sizeof(buf), "%s %s\n",
1358 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1359 write_in_full(proc.in, buf, n);
1360 close(proc.in);
1361 return finish_command(&proc);
1364 int cmd_commit(int argc, const char **argv, const char *prefix)
1366 static struct wt_status s;
1367 static struct option builtin_commit_options[] = {
1368 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1369 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1371 OPT_GROUP(N_("Commit message options")),
1372 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1373 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1374 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1375 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1376 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1377 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1378 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1379 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1380 OPT_BOOLEAN(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1381 OPT_BOOLEAN('s', "signoff", &signoff, N_("add Signed-off-by:")),
1382 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1383 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1384 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1385 OPT_BOOLEAN(0, "status", &include_status, N_("include status in commit message template")),
1386 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1387 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1388 /* end commit message options */
1390 OPT_GROUP(N_("Commit contents options")),
1391 OPT_BOOLEAN('a', "all", &all, N_("commit all changed files")),
1392 OPT_BOOLEAN('i', "include", &also, N_("add specified files to index for commit")),
1393 OPT_BOOLEAN(0, "interactive", &interactive, N_("interactively add files")),
1394 OPT_BOOLEAN('p', "patch", &patch_interactive, N_("interactively add changes")),
1395 OPT_BOOLEAN('o', "only", &only, N_("commit only specified files")),
1396 OPT_BOOLEAN('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1397 OPT_BOOLEAN(0, "dry-run", &dry_run, N_("show what would be committed")),
1398 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1399 STATUS_FORMAT_SHORT),
1400 OPT_BOOLEAN(0, "branch", &s.show_branch, N_("show branch information")),
1401 OPT_SET_INT(0, "porcelain", &status_format,
1402 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1403 OPT_SET_INT(0, "long", &status_format,
1404 N_("show status in long format (default)"),
1405 STATUS_FORMAT_LONG),
1406 OPT_BOOLEAN('z', "null", &s.null_termination,
1407 N_("terminate entries with NUL")),
1408 OPT_BOOLEAN(0, "amend", &amend, N_("amend previous commit")),
1409 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1410 { 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" },
1411 /* end commit contents options */
1413 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
1414 N_("ok to record an empty change"),
1415 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1416 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
1417 N_("ok to record a change with an empty message"),
1418 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1420 OPT_END()
1423 struct strbuf sb = STRBUF_INIT;
1424 struct strbuf author_ident = STRBUF_INIT;
1425 const char *index_file, *reflog_msg;
1426 char *nl, *p;
1427 unsigned char sha1[20];
1428 struct ref_lock *ref_lock;
1429 struct commit_list *parents = NULL, **pptr = &parents;
1430 struct stat statbuf;
1431 int allow_fast_forward = 1;
1432 struct commit *current_head = NULL;
1433 struct commit_extra_header *extra = NULL;
1435 if (argc == 2 && !strcmp(argv[1], "-h"))
1436 usage_with_options(builtin_commit_usage, builtin_commit_options);
1438 wt_status_prepare(&s);
1439 gitmodules_config();
1440 git_config(git_commit_config, &s);
1441 determine_whence(&s);
1442 s.colopts = 0;
1444 if (get_sha1("HEAD", sha1))
1445 current_head = NULL;
1446 else {
1447 current_head = lookup_commit_or_die(sha1, "HEAD");
1448 if (!current_head || parse_commit(current_head))
1449 die(_("could not parse HEAD commit"));
1451 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1452 builtin_commit_usage,
1453 prefix, current_head, &s);
1454 if (dry_run)
1455 return dry_run_commit(argc, argv, prefix, current_head, &s);
1456 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1458 /* Set up everything for writing the commit object. This includes
1459 running hooks, writing the trees, and interacting with the user. */
1460 if (!prepare_to_commit(index_file, prefix,
1461 current_head, &s, &author_ident)) {
1462 rollback_index_files();
1463 return 1;
1466 /* Determine parents */
1467 reflog_msg = getenv("GIT_REFLOG_ACTION");
1468 if (!current_head) {
1469 if (!reflog_msg)
1470 reflog_msg = "commit (initial)";
1471 } else if (amend) {
1472 struct commit_list *c;
1474 if (!reflog_msg)
1475 reflog_msg = "commit (amend)";
1476 for (c = current_head->parents; c; c = c->next)
1477 pptr = &commit_list_insert(c->item, pptr)->next;
1478 } else if (whence == FROM_MERGE) {
1479 struct strbuf m = STRBUF_INIT;
1480 FILE *fp;
1482 if (!reflog_msg)
1483 reflog_msg = "commit (merge)";
1484 pptr = &commit_list_insert(current_head, pptr)->next;
1485 fp = fopen(git_path("MERGE_HEAD"), "r");
1486 if (fp == NULL)
1487 die_errno(_("could not open '%s' for reading"),
1488 git_path("MERGE_HEAD"));
1489 while (strbuf_getline(&m, fp, '\n') != EOF) {
1490 struct commit *parent;
1492 parent = get_merge_parent(m.buf);
1493 if (!parent)
1494 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1495 pptr = &commit_list_insert(parent, pptr)->next;
1497 fclose(fp);
1498 strbuf_release(&m);
1499 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1500 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1501 die_errno(_("could not read MERGE_MODE"));
1502 if (!strcmp(sb.buf, "no-ff"))
1503 allow_fast_forward = 0;
1505 if (allow_fast_forward)
1506 parents = reduce_heads(parents);
1507 } else {
1508 if (!reflog_msg)
1509 reflog_msg = (whence == FROM_CHERRY_PICK)
1510 ? "commit (cherry-pick)"
1511 : "commit";
1512 pptr = &commit_list_insert(current_head, pptr)->next;
1515 /* Finally, get the commit message */
1516 strbuf_reset(&sb);
1517 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1518 int saved_errno = errno;
1519 rollback_index_files();
1520 die(_("could not read commit message: %s"), strerror(saved_errno));
1523 /* Truncate the message just before the diff, if any. */
1524 if (verbose) {
1525 p = strstr(sb.buf, "\ndiff --git ");
1526 if (p != NULL)
1527 strbuf_setlen(&sb, p - sb.buf + 1);
1530 if (cleanup_mode != CLEANUP_NONE)
1531 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1532 if (template_untouched(&sb) && !allow_empty_message) {
1533 rollback_index_files();
1534 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1535 exit(1);
1537 if (message_is_empty(&sb) && !allow_empty_message) {
1538 rollback_index_files();
1539 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1540 exit(1);
1543 if (amend) {
1544 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1545 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1546 } else {
1547 struct commit_extra_header **tail = &extra;
1548 append_merge_tag_headers(parents, &tail);
1551 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1552 author_ident.buf, sign_commit, extra)) {
1553 rollback_index_files();
1554 die(_("failed to write commit object"));
1556 strbuf_release(&author_ident);
1557 free_commit_extra_headers(extra);
1559 ref_lock = lock_any_ref_for_update("HEAD",
1560 !current_head
1561 ? NULL
1562 : current_head->object.sha1,
1565 nl = strchr(sb.buf, '\n');
1566 if (nl)
1567 strbuf_setlen(&sb, nl + 1 - sb.buf);
1568 else
1569 strbuf_addch(&sb, '\n');
1570 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1571 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1573 if (!ref_lock) {
1574 rollback_index_files();
1575 die(_("cannot lock HEAD ref"));
1577 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1578 rollback_index_files();
1579 die(_("cannot update HEAD ref"));
1582 unlink(git_path("CHERRY_PICK_HEAD"));
1583 unlink(git_path("REVERT_HEAD"));
1584 unlink(git_path("MERGE_HEAD"));
1585 unlink(git_path("MERGE_MSG"));
1586 unlink(git_path("MERGE_MODE"));
1587 unlink(git_path("SQUASH_MSG"));
1589 if (commit_index_files())
1590 die (_("Repository has been updated, but unable to write\n"
1591 "new_index file. Check that disk is not full or quota is\n"
1592 "not exceeded, and then \"git reset HEAD\" to recover."));
1594 rerere(0);
1595 run_hook(get_index_file(), "post-commit", NULL);
1596 if (amend && !no_post_rewrite) {
1597 struct notes_rewrite_cfg *cfg;
1598 cfg = init_copy_notes_for_rewrite("amend");
1599 if (cfg) {
1600 /* we are amending, so current_head is not NULL */
1601 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1602 finish_copy_notes_for_rewrite(cfg);
1604 run_rewrite_hook(current_head->object.sha1, sha1);
1606 if (!quiet)
1607 print_summary(prefix, sha1, !current_head);
1609 return 0;