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