Merge branch 'jt/http-redact-cookies' into maint
[git.git] / builtin / commit.c
blob4610e3d8e3e04a70678a102cc3e0e7472089a3cf
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 "config.h"
10 #include "lockfile.h"
11 #include "cache-tree.h"
12 #include "color.h"
13 #include "dir.h"
14 #include "builtin.h"
15 #include "diff.h"
16 #include "diffcore.h"
17 #include "commit.h"
18 #include "revision.h"
19 #include "wt-status.h"
20 #include "run-command.h"
21 #include "refs.h"
22 #include "log-tree.h"
23 #include "strbuf.h"
24 #include "utf8.h"
25 #include "parse-options.h"
26 #include "string-list.h"
27 #include "rerere.h"
28 #include "unpack-trees.h"
29 #include "quote.h"
30 #include "submodule.h"
31 #include "gpg-interface.h"
32 #include "column.h"
33 #include "sequencer.h"
34 #include "notes-utils.h"
35 #include "mailmap.h"
36 #include "sigchain.h"
38 static const char * const builtin_commit_usage[] = {
39 N_("git commit [<options>] [--] <pathspec>..."),
40 NULL
43 static const char * const builtin_status_usage[] = {
44 N_("git status [<options>] [--] <pathspec>..."),
45 NULL
48 static const char implicit_ident_advice_noconfig[] =
49 N_("Your name and email address were configured automatically based\n"
50 "on your username and hostname. Please check that they are accurate.\n"
51 "You can suppress this message by setting them explicitly. Run the\n"
52 "following command and follow the instructions in your editor to edit\n"
53 "your configuration file:\n"
54 "\n"
55 " git config --global --edit\n"
56 "\n"
57 "After doing this, you may fix the identity used for this commit with:\n"
58 "\n"
59 " git commit --amend --reset-author\n");
61 static const char implicit_ident_advice_config[] =
62 N_("Your name and email address were configured automatically based\n"
63 "on your username and hostname. Please check that they are accurate.\n"
64 "You can suppress this message by setting them explicitly:\n"
65 "\n"
66 " git config --global user.name \"Your Name\"\n"
67 " git config --global user.email you@example.com\n"
68 "\n"
69 "After doing this, you may fix the identity used for this commit with:\n"
70 "\n"
71 " git commit --amend --reset-author\n");
73 static const char empty_amend_advice[] =
74 N_("You asked to amend the most recent commit, but doing so would make\n"
75 "it empty. You can repeat your command with --allow-empty, or you can\n"
76 "remove the commit entirely with \"git reset HEAD^\".\n");
78 static const char empty_cherry_pick_advice[] =
79 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
80 "If you wish to commit it anyway, use:\n"
81 "\n"
82 " git commit --allow-empty\n"
83 "\n");
85 static const char empty_cherry_pick_advice_single[] =
86 N_("Otherwise, please use 'git reset'\n");
88 static const char empty_cherry_pick_advice_multi[] =
89 N_("If you wish to skip this commit, use:\n"
90 "\n"
91 " git reset\n"
92 "\n"
93 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
94 "the remaining commits.\n");
96 static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
98 static const char *use_message_buffer;
99 static struct lock_file index_lock; /* real index */
100 static struct lock_file false_lock; /* used only for partial commits */
101 static enum {
102 COMMIT_AS_IS = 1,
103 COMMIT_NORMAL,
104 COMMIT_PARTIAL
105 } commit_style;
107 static const char *logfile, *force_author;
108 static const char *template_file;
110 * The _message variables are commit names from which to take
111 * the commit message and/or authorship.
113 static const char *author_message, *author_message_buffer;
114 static char *edit_message, *use_message;
115 static char *fixup_message, *squash_message;
116 static int all, also, interactive, patch_interactive, only, amend, signoff;
117 static int edit_flag = -1; /* unspecified */
118 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
119 static int config_commit_verbose = -1; /* unspecified */
120 static int no_post_rewrite, allow_empty_message;
121 static char *untracked_files_arg, *force_date, *ignore_submodule_arg, *ignored_arg;
122 static char *sign_commit;
125 * The default commit message cleanup mode will remove the lines
126 * beginning with # (shell comments) and leading and trailing
127 * whitespaces (empty lines or containing only whitespaces)
128 * if editor is used, and only the whitespaces if the message
129 * is specified explicitly.
131 static enum {
132 CLEANUP_SPACE,
133 CLEANUP_NONE,
134 CLEANUP_SCISSORS,
135 CLEANUP_ALL
136 } cleanup_mode;
137 static const char *cleanup_arg;
139 static enum commit_whence whence;
140 static int sequencer_in_use;
141 static int use_editor = 1, include_status = 1;
142 static int have_option_m;
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 git_config(fn, s);
199 determine_whence(s);
200 init_diff_ui_defaults();
201 s->hints = advice_status_hints; /* must come after git_config() */
204 static void rollback_index_files(void)
206 switch (commit_style) {
207 case COMMIT_AS_IS:
208 break; /* nothing to do */
209 case COMMIT_NORMAL:
210 rollback_lock_file(&index_lock);
211 break;
212 case COMMIT_PARTIAL:
213 rollback_lock_file(&index_lock);
214 rollback_lock_file(&false_lock);
215 break;
219 static int commit_index_files(void)
221 int err = 0;
223 switch (commit_style) {
224 case COMMIT_AS_IS:
225 break; /* nothing to do */
226 case COMMIT_NORMAL:
227 err = commit_lock_file(&index_lock);
228 break;
229 case COMMIT_PARTIAL:
230 err = commit_lock_file(&index_lock);
231 rollback_lock_file(&false_lock);
232 break;
235 return err;
239 * Take a union of paths in the index and the named tree (typically, "HEAD"),
240 * and return the paths that match the given pattern in list.
242 static int list_paths(struct string_list *list, const char *with_tree,
243 const char *prefix, const struct pathspec *pattern)
245 int i, ret;
246 char *m;
248 if (!pattern->nr)
249 return 0;
251 m = xcalloc(1, pattern->nr);
253 if (with_tree) {
254 char *max_prefix = common_prefix(pattern);
255 overlay_tree_on_index(&the_index, with_tree,
256 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);
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 = STRING_LIST_INIT_DUP;
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, LOCK_DIE_ON_ERROR);
356 refresh_cache_or_die(refresh_flags);
358 if (write_locked_index(&the_index, &index_lock, 0))
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, 0))
378 die(_("unable to update temporary index"));
379 } else
380 warning(_("Failed to update main cache tree"));
382 commit_style = COMMIT_NORMAL;
383 ret = get_lock_file_path(&index_lock);
384 goto out;
388 * Non partial, non as-is commit.
390 * (1) get the real index;
391 * (2) update the_index as necessary;
392 * (3) write the_index out to the real index (still locked);
393 * (4) return the name of the locked index file.
395 * The caller should run hooks on the locked real index, and
396 * (A) if all goes well, commit the real index;
397 * (B) on failure, rollback the real index.
399 if (all || (also && pathspec.nr)) {
400 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
401 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
402 refresh_cache_or_die(refresh_flags);
403 update_main_cache_tree(WRITE_TREE_SILENT);
404 if (write_locked_index(&the_index, &index_lock, 0))
405 die(_("unable to write new_index file"));
406 commit_style = COMMIT_NORMAL;
407 ret = get_lock_file_path(&index_lock);
408 goto out;
412 * As-is commit.
414 * (1) return the name of the real index file.
416 * The caller should run hooks on the real index,
417 * and create commit from the_index.
418 * We still need to refresh the index here.
420 if (!only && !pathspec.nr) {
421 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
422 refresh_cache_or_die(refresh_flags);
423 if (active_cache_changed
424 || !cache_tree_fully_valid(active_cache_tree))
425 update_main_cache_tree(WRITE_TREE_SILENT);
426 if (active_cache_changed) {
427 if (write_locked_index(&the_index, &index_lock,
428 COMMIT_LOCK))
429 die(_("unable to write new_index file"));
430 } else {
431 rollback_lock_file(&index_lock);
433 commit_style = COMMIT_AS_IS;
434 ret = get_index_file();
435 goto out;
439 * A partial commit.
441 * (0) find the set of affected paths;
442 * (1) get lock on the real index file;
443 * (2) update the_index with the given paths;
444 * (3) write the_index out to the real index (still locked);
445 * (4) get lock on the false index file;
446 * (5) reset the_index from HEAD;
447 * (6) update the_index the same way as (2);
448 * (7) write the_index out to the false index file;
449 * (8) return the name of the false index file (still locked);
451 * The caller should run hooks on the locked false index, and
452 * create commit from it. Then
453 * (A) if all goes well, commit the real index;
454 * (B) on failure, rollback the real index;
455 * In either case, rollback the false index.
457 commit_style = COMMIT_PARTIAL;
459 if (whence != FROM_COMMIT) {
460 if (whence == FROM_MERGE)
461 die(_("cannot do a partial commit during a merge."));
462 else if (whence == FROM_CHERRY_PICK)
463 die(_("cannot do a partial commit during a cherry-pick."));
466 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
467 exit(1);
469 discard_cache();
470 if (read_cache() < 0)
471 die(_("cannot read the index"));
473 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
474 add_remove_files(&partial);
475 refresh_cache(REFRESH_QUIET);
476 update_main_cache_tree(WRITE_TREE_SILENT);
477 if (write_locked_index(&the_index, &index_lock, 0))
478 die(_("unable to write new_index file"));
480 hold_lock_file_for_update(&false_lock,
481 git_path("next-index-%"PRIuMAX,
482 (uintmax_t) getpid()),
483 LOCK_DIE_ON_ERROR);
485 create_base_index(current_head);
486 add_remove_files(&partial);
487 refresh_cache(REFRESH_QUIET);
489 if (write_locked_index(&the_index, &false_lock, 0))
490 die(_("unable to write temporary index file"));
492 discard_cache();
493 ret = get_lock_file_path(&false_lock);
494 read_cache_from(ret);
495 out:
496 string_list_clear(&partial, 0);
497 clear_pathspec(&pathspec);
498 return ret;
501 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
502 struct wt_status *s)
504 struct object_id oid;
506 if (s->relative_paths)
507 s->prefix = prefix;
509 if (amend) {
510 s->amend = 1;
511 s->reference = "HEAD^1";
513 s->verbose = verbose;
514 s->index_file = index_file;
515 s->fp = fp;
516 s->nowarn = nowarn;
517 s->is_initial = get_oid(s->reference, &oid) ? 1 : 0;
518 if (!s->is_initial)
519 hashcpy(s->sha1_commit, oid.hash);
520 s->status_format = status_format;
521 s->ignore_submodule_arg = ignore_submodule_arg;
523 wt_status_collect(s);
524 wt_status_print(s);
526 return s->commitable;
529 static int is_a_merge(const struct commit *current_head)
531 return !!(current_head->parents && current_head->parents->next);
534 static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
536 if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)
537 die("BUG: unable to parse our own ident: %s", buf->buf);
540 static void export_one(const char *var, const char *s, const char *e, int hack)
542 struct strbuf buf = STRBUF_INIT;
543 if (hack)
544 strbuf_addch(&buf, hack);
545 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
546 setenv(var, buf.buf, 1);
547 strbuf_release(&buf);
550 static int parse_force_date(const char *in, struct strbuf *out)
552 strbuf_addch(out, '@');
554 if (parse_date(in, out) < 0) {
555 int errors = 0;
556 unsigned long t = approxidate_careful(in, &errors);
557 if (errors)
558 return -1;
559 strbuf_addf(out, "%lu", t);
562 return 0;
565 static void set_ident_var(char **buf, char *val)
567 free(*buf);
568 *buf = val;
571 static void determine_author_info(struct strbuf *author_ident)
573 char *name, *email, *date;
574 struct ident_split author;
576 name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
577 email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
578 date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
580 if (author_message) {
581 struct ident_split ident;
582 size_t len;
583 const char *a;
585 a = find_commit_header(author_message_buffer, "author", &len);
586 if (!a)
587 die(_("commit '%s' lacks author header"), author_message);
588 if (split_ident_line(&ident, a, len) < 0)
589 die(_("commit '%s' has malformed author line"), author_message);
591 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
592 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
594 if (ident.date_begin) {
595 struct strbuf date_buf = STRBUF_INIT;
596 strbuf_addch(&date_buf, '@');
597 strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);
598 strbuf_addch(&date_buf, ' ');
599 strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);
600 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
604 if (force_author) {
605 struct ident_split ident;
607 if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)
608 die(_("malformed --author parameter"));
609 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
610 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
613 if (force_date) {
614 struct strbuf date_buf = STRBUF_INIT;
615 if (parse_force_date(force_date, &date_buf))
616 die(_("invalid date format: %s"), force_date);
617 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
620 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
621 assert_split_ident(&author, author_ident);
622 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
623 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
624 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
625 free(name);
626 free(email);
627 free(date);
630 static int author_date_is_interesting(void)
632 return author_message || force_date;
635 static void adjust_comment_line_char(const struct strbuf *sb)
637 char candidates[] = "#;@!$%^&|:";
638 char *candidate;
639 const char *p;
641 comment_line_char = candidates[0];
642 if (!memchr(sb->buf, comment_line_char, sb->len))
643 return;
645 p = sb->buf;
646 candidate = strchr(candidates, *p);
647 if (candidate)
648 *candidate = ' ';
649 for (p = sb->buf; *p; p++) {
650 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
651 candidate = strchr(candidates, p[1]);
652 if (candidate)
653 *candidate = ' ';
657 for (p = candidates; *p == ' '; p++)
659 if (!*p)
660 die(_("unable to select a comment character that is not used\n"
661 "in the current commit message"));
662 comment_line_char = *p;
665 static int prepare_to_commit(const char *index_file, const char *prefix,
666 struct commit *current_head,
667 struct wt_status *s,
668 struct strbuf *author_ident)
670 struct stat statbuf;
671 struct strbuf committer_ident = STRBUF_INIT;
672 int commitable;
673 struct strbuf sb = STRBUF_INIT;
674 const char *hook_arg1 = NULL;
675 const char *hook_arg2 = NULL;
676 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
677 int old_display_comment_prefix;
679 /* This checks and barfs if author is badly specified */
680 determine_author_info(author_ident);
682 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
683 return 0;
685 if (squash_message) {
687 * Insert the proper subject line before other commit
688 * message options add their content.
690 if (use_message && !strcmp(use_message, squash_message))
691 strbuf_addstr(&sb, "squash! ");
692 else {
693 struct pretty_print_context ctx = {0};
694 struct commit *c;
695 c = lookup_commit_reference_by_name(squash_message);
696 if (!c)
697 die(_("could not lookup commit %s"), squash_message);
698 ctx.output_encoding = get_commit_output_encoding();
699 format_commit_message(c, "squash! %s\n\n", &sb,
700 &ctx);
704 if (have_option_m && !fixup_message) {
705 strbuf_addbuf(&sb, &message);
706 hook_arg1 = "message";
707 } else if (logfile && !strcmp(logfile, "-")) {
708 if (isatty(0))
709 fprintf(stderr, _("(reading log message from standard input)\n"));
710 if (strbuf_read(&sb, 0, 0) < 0)
711 die_errno(_("could not read log from standard input"));
712 hook_arg1 = "message";
713 } else if (logfile) {
714 if (strbuf_read_file(&sb, logfile, 0) < 0)
715 die_errno(_("could not read log file '%s'"),
716 logfile);
717 hook_arg1 = "message";
718 } else if (use_message) {
719 char *buffer;
720 buffer = strstr(use_message_buffer, "\n\n");
721 if (buffer)
722 strbuf_addstr(&sb, skip_blank_lines(buffer + 2));
723 hook_arg1 = "commit";
724 hook_arg2 = use_message;
725 } else if (fixup_message) {
726 struct pretty_print_context ctx = {0};
727 struct commit *commit;
728 commit = lookup_commit_reference_by_name(fixup_message);
729 if (!commit)
730 die(_("could not lookup commit %s"), fixup_message);
731 ctx.output_encoding = get_commit_output_encoding();
732 format_commit_message(commit, "fixup! %s\n\n",
733 &sb, &ctx);
734 if (have_option_m)
735 strbuf_addbuf(&sb, &message);
736 hook_arg1 = "message";
737 } else if (!stat(git_path_merge_msg(), &statbuf)) {
739 * prepend SQUASH_MSG here if it exists and a
740 * "merge --squash" was originally performed
742 if (!stat(git_path_squash_msg(), &statbuf)) {
743 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
744 die_errno(_("could not read SQUASH_MSG"));
745 hook_arg1 = "squash";
746 } else
747 hook_arg1 = "merge";
748 if (strbuf_read_file(&sb, git_path_merge_msg(), 0) < 0)
749 die_errno(_("could not read MERGE_MSG"));
750 } else if (!stat(git_path_squash_msg(), &statbuf)) {
751 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
752 die_errno(_("could not read SQUASH_MSG"));
753 hook_arg1 = "squash";
754 } else if (template_file) {
755 if (strbuf_read_file(&sb, template_file, 0) < 0)
756 die_errno(_("could not read '%s'"), template_file);
757 hook_arg1 = "template";
758 clean_message_contents = 0;
762 * The remaining cases don't modify the template message, but
763 * just set the argument(s) to the prepare-commit-msg hook.
765 else if (whence == FROM_MERGE)
766 hook_arg1 = "merge";
767 else if (whence == FROM_CHERRY_PICK) {
768 hook_arg1 = "commit";
769 hook_arg2 = "CHERRY_PICK_HEAD";
772 if (squash_message) {
774 * If squash_commit was used for the commit subject,
775 * then we're possibly hijacking other commit log options.
776 * Reset the hook args to tell the real story.
778 hook_arg1 = "message";
779 hook_arg2 = "";
782 s->fp = fopen_for_writing(git_path_commit_editmsg());
783 if (s->fp == NULL)
784 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
786 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
787 old_display_comment_prefix = s->display_comment_prefix;
788 s->display_comment_prefix = 1;
791 * Most hints are counter-productive when the commit has
792 * already started.
794 s->hints = 0;
796 if (clean_message_contents)
797 strbuf_stripspace(&sb, 0);
799 if (signoff)
800 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
802 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
803 die_errno(_("could not write commit template"));
805 if (auto_comment_line_char)
806 adjust_comment_line_char(&sb);
807 strbuf_release(&sb);
809 /* This checks if committer ident is explicitly given */
810 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
811 if (use_editor && include_status) {
812 int ident_shown = 0;
813 int saved_color_setting;
814 struct ident_split ci, ai;
816 if (whence != FROM_COMMIT) {
817 if (cleanup_mode == CLEANUP_SCISSORS)
818 wt_status_add_cut_line(s->fp);
819 status_printf_ln(s, GIT_COLOR_NORMAL,
820 whence == FROM_MERGE
821 ? _("\n"
822 "It looks like you may be committing a merge.\n"
823 "If this is not correct, please remove the file\n"
824 " %s\n"
825 "and try again.\n")
826 : _("\n"
827 "It looks like you may be committing a cherry-pick.\n"
828 "If this is not correct, please remove the file\n"
829 " %s\n"
830 "and try again.\n"),
831 whence == FROM_MERGE ?
832 git_path_merge_head() :
833 git_path_cherry_pick_head());
836 fprintf(s->fp, "\n");
837 if (cleanup_mode == CLEANUP_ALL)
838 status_printf(s, GIT_COLOR_NORMAL,
839 _("Please enter the commit message for your changes."
840 " Lines starting\nwith '%c' will be ignored, and an empty"
841 " message aborts the commit.\n"), comment_line_char);
842 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
843 wt_status_add_cut_line(s->fp);
844 else /* CLEANUP_SPACE, that is. */
845 status_printf(s, GIT_COLOR_NORMAL,
846 _("Please enter the commit message for your changes."
847 " Lines starting\n"
848 "with '%c' will be kept; you may remove them"
849 " yourself if you want to.\n"
850 "An empty message aborts the commit.\n"), comment_line_char);
853 * These should never fail because they come from our own
854 * fmt_ident. They may fail the sane_ident test, but we know
855 * that the name and mail pointers will at least be valid,
856 * which is enough for our tests and printing here.
858 assert_split_ident(&ai, author_ident);
859 assert_split_ident(&ci, &committer_ident);
861 if (ident_cmp(&ai, &ci))
862 status_printf_ln(s, GIT_COLOR_NORMAL,
863 _("%s"
864 "Author: %.*s <%.*s>"),
865 ident_shown++ ? "" : "\n",
866 (int)(ai.name_end - ai.name_begin), ai.name_begin,
867 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
869 if (author_date_is_interesting())
870 status_printf_ln(s, GIT_COLOR_NORMAL,
871 _("%s"
872 "Date: %s"),
873 ident_shown++ ? "" : "\n",
874 show_ident_date(&ai, DATE_MODE(NORMAL)));
876 if (!committer_ident_sufficiently_given())
877 status_printf_ln(s, GIT_COLOR_NORMAL,
878 _("%s"
879 "Committer: %.*s <%.*s>"),
880 ident_shown++ ? "" : "\n",
881 (int)(ci.name_end - ci.name_begin), ci.name_begin,
882 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
884 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); /* Add new line for clarity */
886 saved_color_setting = s->use_color;
887 s->use_color = 0;
888 commitable = run_status(s->fp, index_file, prefix, 1, s);
889 s->use_color = saved_color_setting;
890 } else {
891 struct object_id oid;
892 const char *parent = "HEAD";
894 if (!active_nr && read_cache() < 0)
895 die(_("Cannot read index"));
897 if (amend)
898 parent = "HEAD^1";
900 if (get_oid(parent, &oid)) {
901 int i, ita_nr = 0;
903 for (i = 0; i < active_nr; i++)
904 if (ce_intent_to_add(active_cache[i]))
905 ita_nr++;
906 commitable = active_nr - ita_nr > 0;
907 } else {
909 * Unless the user did explicitly request a submodule
910 * ignore mode by passing a command line option we do
911 * not ignore any changed submodule SHA-1s when
912 * comparing index and parent, no matter what is
913 * configured. Otherwise we won't commit any
914 * submodules which were manually staged, which would
915 * be really confusing.
917 struct diff_flags flags = DIFF_FLAGS_INIT;
918 flags.override_submodule_config = 1;
919 if (ignore_submodule_arg &&
920 !strcmp(ignore_submodule_arg, "all"))
921 flags.ignore_submodules = 1;
922 commitable = index_differs_from(parent, &flags, 1);
925 strbuf_release(&committer_ident);
927 fclose(s->fp);
930 * Reject an attempt to record a non-merge empty commit without
931 * explicit --allow-empty. In the cherry-pick case, it may be
932 * empty due to conflict resolution, which the user should okay.
934 if (!commitable && whence != FROM_MERGE && !allow_empty &&
935 !(amend && is_a_merge(current_head))) {
936 s->display_comment_prefix = old_display_comment_prefix;
937 run_status(stdout, index_file, prefix, 0, s);
938 if (amend)
939 fputs(_(empty_amend_advice), stderr);
940 else if (whence == FROM_CHERRY_PICK) {
941 fputs(_(empty_cherry_pick_advice), stderr);
942 if (!sequencer_in_use)
943 fputs(_(empty_cherry_pick_advice_single), stderr);
944 else
945 fputs(_(empty_cherry_pick_advice_multi), stderr);
947 return 0;
950 if (!no_verify && find_hook("pre-commit")) {
952 * Re-read the index as pre-commit hook could have updated it,
953 * and write it out as a tree. We must do this before we invoke
954 * the editor and after we invoke run_status above.
956 discard_cache();
958 read_cache_from(index_file);
960 if (update_main_cache_tree(0)) {
961 error(_("Error building trees"));
962 return 0;
965 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
966 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
967 return 0;
969 if (use_editor) {
970 struct argv_array env = ARGV_ARRAY_INIT;
972 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
973 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
974 fprintf(stderr,
975 _("Please supply the message using either -m or -F option.\n"));
976 exit(1);
978 argv_array_clear(&env);
981 if (!no_verify &&
982 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
983 return 0;
986 return 1;
989 static int rest_is_empty(struct strbuf *sb, int start)
991 int i, eol;
992 const char *nl;
994 /* Check if the rest is just whitespace and Signed-off-by's. */
995 for (i = start; i < sb->len; i++) {
996 nl = memchr(sb->buf + i, '\n', sb->len - i);
997 if (nl)
998 eol = nl - sb->buf;
999 else
1000 eol = sb->len;
1002 if (strlen(sign_off_header) <= eol - i &&
1003 starts_with(sb->buf + i, sign_off_header)) {
1004 i = eol;
1005 continue;
1007 while (i < eol)
1008 if (!isspace(sb->buf[i++]))
1009 return 0;
1012 return 1;
1016 * Find out if the message in the strbuf contains only whitespace and
1017 * Signed-off-by lines.
1019 static int message_is_empty(struct strbuf *sb)
1021 if (cleanup_mode == CLEANUP_NONE && sb->len)
1022 return 0;
1023 return rest_is_empty(sb, 0);
1027 * See if the user edited the message in the editor or left what
1028 * was in the template intact
1030 static int template_untouched(struct strbuf *sb)
1032 struct strbuf tmpl = STRBUF_INIT;
1033 const char *start;
1035 if (cleanup_mode == CLEANUP_NONE && sb->len)
1036 return 0;
1038 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1039 return 0;
1041 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1042 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1043 start = sb->buf;
1044 strbuf_release(&tmpl);
1045 return rest_is_empty(sb, start - sb->buf);
1048 static const char *find_author_by_nickname(const char *name)
1050 struct rev_info revs;
1051 struct commit *commit;
1052 struct strbuf buf = STRBUF_INIT;
1053 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1054 const char *av[20];
1055 int ac = 0;
1057 init_revisions(&revs, NULL);
1058 strbuf_addf(&buf, "--author=%s", name);
1059 av[++ac] = "--all";
1060 av[++ac] = "-i";
1061 av[++ac] = buf.buf;
1062 av[++ac] = NULL;
1063 setup_revisions(ac, av, &revs, NULL);
1064 revs.mailmap = &mailmap;
1065 read_mailmap(revs.mailmap, NULL);
1067 if (prepare_revision_walk(&revs))
1068 die(_("revision walk setup failed"));
1069 commit = get_revision(&revs);
1070 if (commit) {
1071 struct pretty_print_context ctx = {0};
1072 ctx.date_mode.type = DATE_NORMAL;
1073 strbuf_release(&buf);
1074 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1075 clear_mailmap(&mailmap);
1076 return strbuf_detach(&buf, NULL);
1078 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1081 static void handle_ignored_arg(struct wt_status *s)
1083 if (!ignored_arg)
1084 ; /* default already initialized */
1085 else if (!strcmp(ignored_arg, "traditional"))
1086 s->show_ignored_mode = SHOW_TRADITIONAL_IGNORED;
1087 else if (!strcmp(ignored_arg, "no"))
1088 s->show_ignored_mode = SHOW_NO_IGNORED;
1089 else if (!strcmp(ignored_arg, "matching"))
1090 s->show_ignored_mode = SHOW_MATCHING_IGNORED;
1091 else
1092 die(_("Invalid ignored mode '%s'"), ignored_arg);
1095 static void handle_untracked_files_arg(struct wt_status *s)
1097 if (!untracked_files_arg)
1098 ; /* default already initialized */
1099 else if (!strcmp(untracked_files_arg, "no"))
1100 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1101 else if (!strcmp(untracked_files_arg, "normal"))
1102 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1103 else if (!strcmp(untracked_files_arg, "all"))
1104 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1105 else
1106 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1109 static const char *read_commit_message(const char *name)
1111 const char *out_enc;
1112 struct commit *commit;
1114 commit = lookup_commit_reference_by_name(name);
1115 if (!commit)
1116 die(_("could not lookup commit %s"), name);
1117 out_enc = get_commit_output_encoding();
1118 return logmsg_reencode(commit, NULL, out_enc);
1122 * Enumerate what needs to be propagated when --porcelain
1123 * is not in effect here.
1125 static struct status_deferred_config {
1126 enum wt_status_format status_format;
1127 int show_branch;
1128 } status_deferred_config = {
1129 STATUS_FORMAT_UNSPECIFIED,
1130 -1 /* unspecified */
1133 static void finalize_deferred_config(struct wt_status *s)
1135 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1136 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1137 !s->null_termination);
1139 if (s->null_termination) {
1140 if (status_format == STATUS_FORMAT_NONE ||
1141 status_format == STATUS_FORMAT_UNSPECIFIED)
1142 status_format = STATUS_FORMAT_PORCELAIN;
1143 else if (status_format == STATUS_FORMAT_LONG)
1144 die(_("--long and -z are incompatible"));
1147 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1148 status_format = status_deferred_config.status_format;
1149 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1150 status_format = STATUS_FORMAT_NONE;
1152 if (use_deferred_config && s->show_branch < 0)
1153 s->show_branch = status_deferred_config.show_branch;
1154 if (s->show_branch < 0)
1155 s->show_branch = 0;
1158 static int parse_and_validate_options(int argc, const char *argv[],
1159 const struct option *options,
1160 const char * const usage[],
1161 const char *prefix,
1162 struct commit *current_head,
1163 struct wt_status *s)
1165 int f = 0;
1167 argc = parse_options(argc, argv, prefix, options, usage, 0);
1168 finalize_deferred_config(s);
1170 if (force_author && !strchr(force_author, '>'))
1171 force_author = find_author_by_nickname(force_author);
1173 if (force_author && renew_authorship)
1174 die(_("Using both --reset-author and --author does not make sense"));
1176 if (logfile || have_option_m || use_message || fixup_message)
1177 use_editor = 0;
1178 if (0 <= edit_flag)
1179 use_editor = edit_flag;
1181 /* Sanity check options */
1182 if (amend && !current_head)
1183 die(_("You have nothing to amend."));
1184 if (amend && whence != FROM_COMMIT) {
1185 if (whence == FROM_MERGE)
1186 die(_("You are in the middle of a merge -- cannot amend."));
1187 else if (whence == FROM_CHERRY_PICK)
1188 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1190 if (fixup_message && squash_message)
1191 die(_("Options --squash and --fixup cannot be used together"));
1192 if (use_message)
1193 f++;
1194 if (edit_message)
1195 f++;
1196 if (fixup_message)
1197 f++;
1198 if (logfile)
1199 f++;
1200 if (f > 1)
1201 die(_("Only one of -c/-C/-F/--fixup can be used."));
1202 if (have_option_m && (edit_message || use_message || logfile))
1203 die((_("Option -m cannot be combined with -c/-C/-F.")));
1204 if (f || have_option_m)
1205 template_file = NULL;
1206 if (edit_message)
1207 use_message = edit_message;
1208 if (amend && !use_message && !fixup_message)
1209 use_message = "HEAD";
1210 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1211 die(_("--reset-author can be used only with -C, -c or --amend."));
1212 if (use_message) {
1213 use_message_buffer = read_commit_message(use_message);
1214 if (!renew_authorship) {
1215 author_message = use_message;
1216 author_message_buffer = use_message_buffer;
1219 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1220 author_message = "CHERRY_PICK_HEAD";
1221 author_message_buffer = read_commit_message(author_message);
1224 if (patch_interactive)
1225 interactive = 1;
1227 if (also + only + all + interactive > 1)
1228 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1229 if (argc == 0 && (also || (only && !amend && !allow_empty)))
1230 die(_("No paths with --include/--only does not make sense."));
1231 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1232 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1233 else if (!strcmp(cleanup_arg, "verbatim"))
1234 cleanup_mode = CLEANUP_NONE;
1235 else if (!strcmp(cleanup_arg, "whitespace"))
1236 cleanup_mode = CLEANUP_SPACE;
1237 else if (!strcmp(cleanup_arg, "strip"))
1238 cleanup_mode = CLEANUP_ALL;
1239 else if (!strcmp(cleanup_arg, "scissors"))
1240 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1241 else
1242 die(_("Invalid cleanup mode %s"), cleanup_arg);
1244 handle_untracked_files_arg(s);
1246 if (all && argc > 0)
1247 die(_("Paths with -a does not make sense."));
1249 if (status_format != STATUS_FORMAT_NONE)
1250 dry_run = 1;
1252 return argc;
1255 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1256 const struct commit *current_head, struct wt_status *s)
1258 int commitable;
1259 const char *index_file;
1261 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1262 commitable = run_status(stdout, index_file, prefix, 0, s);
1263 rollback_index_files();
1265 return commitable ? 0 : 1;
1268 static int parse_status_slot(const char *slot)
1270 if (!strcasecmp(slot, "header"))
1271 return WT_STATUS_HEADER;
1272 if (!strcasecmp(slot, "branch"))
1273 return WT_STATUS_ONBRANCH;
1274 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1275 return WT_STATUS_UPDATED;
1276 if (!strcasecmp(slot, "changed"))
1277 return WT_STATUS_CHANGED;
1278 if (!strcasecmp(slot, "untracked"))
1279 return WT_STATUS_UNTRACKED;
1280 if (!strcasecmp(slot, "nobranch"))
1281 return WT_STATUS_NOBRANCH;
1282 if (!strcasecmp(slot, "unmerged"))
1283 return WT_STATUS_UNMERGED;
1284 if (!strcasecmp(slot, "localBranch"))
1285 return WT_STATUS_LOCAL_BRANCH;
1286 if (!strcasecmp(slot, "remoteBranch"))
1287 return WT_STATUS_REMOTE_BRANCH;
1288 return -1;
1291 static int git_status_config(const char *k, const char *v, void *cb)
1293 struct wt_status *s = cb;
1294 const char *slot_name;
1296 if (starts_with(k, "column."))
1297 return git_column_config(k, v, "status", &s->colopts);
1298 if (!strcmp(k, "status.submodulesummary")) {
1299 int is_bool;
1300 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1301 if (is_bool && s->submodule_summary)
1302 s->submodule_summary = -1;
1303 return 0;
1305 if (!strcmp(k, "status.short")) {
1306 if (git_config_bool(k, v))
1307 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1308 else
1309 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1310 return 0;
1312 if (!strcmp(k, "status.branch")) {
1313 status_deferred_config.show_branch = git_config_bool(k, v);
1314 return 0;
1316 if (!strcmp(k, "status.showstash")) {
1317 s->show_stash = git_config_bool(k, v);
1318 return 0;
1320 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1321 s->use_color = git_config_colorbool(k, v);
1322 return 0;
1324 if (!strcmp(k, "status.displaycommentprefix")) {
1325 s->display_comment_prefix = git_config_bool(k, v);
1326 return 0;
1328 if (skip_prefix(k, "status.color.", &slot_name) ||
1329 skip_prefix(k, "color.status.", &slot_name)) {
1330 int slot = parse_status_slot(slot_name);
1331 if (slot < 0)
1332 return 0;
1333 if (!v)
1334 return config_error_nonbool(k);
1335 return color_parse(v, s->color_palette[slot]);
1337 if (!strcmp(k, "status.relativepaths")) {
1338 s->relative_paths = git_config_bool(k, v);
1339 return 0;
1341 if (!strcmp(k, "status.showuntrackedfiles")) {
1342 if (!v)
1343 return config_error_nonbool(k);
1344 else if (!strcmp(v, "no"))
1345 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1346 else if (!strcmp(v, "normal"))
1347 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1348 else if (!strcmp(v, "all"))
1349 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1350 else
1351 return error(_("Invalid untracked files mode '%s'"), v);
1352 return 0;
1354 return git_diff_ui_config(k, v, NULL);
1357 int cmd_status(int argc, const char **argv, const char *prefix)
1359 static struct wt_status s;
1360 int fd;
1361 struct object_id oid;
1362 static struct option builtin_status_options[] = {
1363 OPT__VERBOSE(&verbose, N_("be verbose")),
1364 OPT_SET_INT('s', "short", &status_format,
1365 N_("show status concisely"), STATUS_FORMAT_SHORT),
1366 OPT_BOOL('b', "branch", &s.show_branch,
1367 N_("show branch information")),
1368 OPT_BOOL(0, "show-stash", &s.show_stash,
1369 N_("show stash information")),
1370 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1371 N_("version"), N_("machine-readable output"),
1372 PARSE_OPT_OPTARG, opt_parse_porcelain },
1373 OPT_SET_INT(0, "long", &status_format,
1374 N_("show status in long format (default)"),
1375 STATUS_FORMAT_LONG),
1376 OPT_BOOL('z', "null", &s.null_termination,
1377 N_("terminate entries with NUL")),
1378 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1379 N_("mode"),
1380 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1381 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1382 { OPTION_STRING, 0, "ignored", &ignored_arg,
1383 N_("mode"),
1384 N_("show ignored files, optional modes: traditional, matching, no. (Default: traditional)"),
1385 PARSE_OPT_OPTARG, NULL, (intptr_t)"traditional" },
1386 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1387 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1388 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1389 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1390 OPT_END(),
1393 if (argc == 2 && !strcmp(argv[1], "-h"))
1394 usage_with_options(builtin_status_usage, builtin_status_options);
1396 status_init_config(&s, git_status_config);
1397 argc = parse_options(argc, argv, prefix,
1398 builtin_status_options,
1399 builtin_status_usage, 0);
1400 finalize_colopts(&s.colopts, -1);
1401 finalize_deferred_config(&s);
1403 handle_untracked_files_arg(&s);
1404 handle_ignored_arg(&s);
1406 if (s.show_ignored_mode == SHOW_MATCHING_IGNORED &&
1407 s.show_untracked_files == SHOW_NO_UNTRACKED_FILES)
1408 die(_("Unsupported combination of ignored and untracked-files arguments"));
1410 parse_pathspec(&s.pathspec, 0,
1411 PATHSPEC_PREFER_FULL,
1412 prefix, argv);
1414 read_cache_preload(&s.pathspec);
1415 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1417 if (use_optional_locks())
1418 fd = hold_locked_index(&index_lock, 0);
1419 else
1420 fd = -1;
1422 s.is_initial = get_oid(s.reference, &oid) ? 1 : 0;
1423 if (!s.is_initial)
1424 hashcpy(s.sha1_commit, oid.hash);
1426 s.ignore_submodule_arg = ignore_submodule_arg;
1427 s.status_format = status_format;
1428 s.verbose = verbose;
1430 wt_status_collect(&s);
1432 if (0 <= fd)
1433 update_index_if_able(&the_index, &index_lock);
1435 if (s.relative_paths)
1436 s.prefix = prefix;
1438 wt_status_print(&s);
1439 return 0;
1442 static const char *implicit_ident_advice(void)
1444 char *user_config = expand_user_path("~/.gitconfig", 0);
1445 char *xdg_config = xdg_config_home("config");
1446 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1448 free(user_config);
1449 free(xdg_config);
1451 if (config_exists)
1452 return _(implicit_ident_advice_config);
1453 else
1454 return _(implicit_ident_advice_noconfig);
1458 static void print_summary(const char *prefix, const struct object_id *oid,
1459 int initial_commit)
1461 struct rev_info rev;
1462 struct commit *commit;
1463 struct strbuf format = STRBUF_INIT;
1464 const char *head;
1465 struct pretty_print_context pctx = {0};
1466 struct strbuf author_ident = STRBUF_INIT;
1467 struct strbuf committer_ident = STRBUF_INIT;
1469 commit = lookup_commit(oid);
1470 if (!commit)
1471 die(_("couldn't look up newly created commit"));
1472 if (parse_commit(commit))
1473 die(_("could not parse newly created commit"));
1475 strbuf_addstr(&format, "format:%h] %s");
1477 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1478 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1479 if (strbuf_cmp(&author_ident, &committer_ident)) {
1480 strbuf_addstr(&format, "\n Author: ");
1481 strbuf_addbuf_percentquote(&format, &author_ident);
1483 if (author_date_is_interesting()) {
1484 struct strbuf date = STRBUF_INIT;
1485 format_commit_message(commit, "%ad", &date, &pctx);
1486 strbuf_addstr(&format, "\n Date: ");
1487 strbuf_addbuf_percentquote(&format, &date);
1488 strbuf_release(&date);
1490 if (!committer_ident_sufficiently_given()) {
1491 strbuf_addstr(&format, "\n Committer: ");
1492 strbuf_addbuf_percentquote(&format, &committer_ident);
1493 if (advice_implicit_identity) {
1494 strbuf_addch(&format, '\n');
1495 strbuf_addstr(&format, implicit_ident_advice());
1498 strbuf_release(&author_ident);
1499 strbuf_release(&committer_ident);
1501 init_revisions(&rev, prefix);
1502 setup_revisions(0, NULL, &rev, NULL);
1504 rev.diff = 1;
1505 rev.diffopt.output_format =
1506 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1508 rev.verbose_header = 1;
1509 rev.show_root_diff = 1;
1510 get_commit_format(format.buf, &rev);
1511 rev.always_show_header = 0;
1512 rev.diffopt.detect_rename = DIFF_DETECT_RENAME;
1513 rev.diffopt.break_opt = 0;
1514 diff_setup_done(&rev.diffopt);
1516 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1517 if (!head)
1518 die_errno(_("unable to resolve HEAD after creating commit"));
1519 if (!strcmp(head, "HEAD"))
1520 head = _("detached HEAD");
1521 else
1522 skip_prefix(head, "refs/heads/", &head);
1523 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1525 if (!log_tree_commit(&rev, commit)) {
1526 rev.always_show_header = 1;
1527 rev.use_terminator = 1;
1528 log_tree_commit(&rev, commit);
1531 strbuf_release(&format);
1534 static int git_commit_config(const char *k, const char *v, void *cb)
1536 struct wt_status *s = cb;
1537 int status;
1539 if (!strcmp(k, "commit.template"))
1540 return git_config_pathname(&template_file, k, v);
1541 if (!strcmp(k, "commit.status")) {
1542 include_status = git_config_bool(k, v);
1543 return 0;
1545 if (!strcmp(k, "commit.cleanup"))
1546 return git_config_string(&cleanup_arg, k, v);
1547 if (!strcmp(k, "commit.gpgsign")) {
1548 sign_commit = git_config_bool(k, v) ? "" : NULL;
1549 return 0;
1551 if (!strcmp(k, "commit.verbose")) {
1552 int is_bool;
1553 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1554 return 0;
1557 status = git_gpg_config(k, v, NULL);
1558 if (status)
1559 return status;
1560 return git_status_config(k, v, s);
1563 static int run_rewrite_hook(const struct object_id *oldoid,
1564 const struct object_id *newoid)
1566 struct child_process proc = CHILD_PROCESS_INIT;
1567 const char *argv[3];
1568 int code;
1569 struct strbuf sb = STRBUF_INIT;
1571 argv[0] = find_hook("post-rewrite");
1572 if (!argv[0])
1573 return 0;
1575 argv[1] = "amend";
1576 argv[2] = NULL;
1578 proc.argv = argv;
1579 proc.in = -1;
1580 proc.stdout_to_stderr = 1;
1582 code = start_command(&proc);
1583 if (code)
1584 return code;
1585 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1586 sigchain_push(SIGPIPE, SIG_IGN);
1587 write_in_full(proc.in, sb.buf, sb.len);
1588 close(proc.in);
1589 strbuf_release(&sb);
1590 sigchain_pop(SIGPIPE);
1591 return finish_command(&proc);
1594 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1596 struct argv_array hook_env = ARGV_ARRAY_INIT;
1597 va_list args;
1598 int ret;
1600 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1603 * Let the hook know that no editor will be launched.
1605 if (!editor_is_used)
1606 argv_array_push(&hook_env, "GIT_EDITOR=:");
1608 va_start(args, name);
1609 ret = run_hook_ve(hook_env.argv,name, args);
1610 va_end(args);
1611 argv_array_clear(&hook_env);
1613 return ret;
1616 int cmd_commit(int argc, const char **argv, const char *prefix)
1618 static struct wt_status s;
1619 static struct option builtin_commit_options[] = {
1620 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1621 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1623 OPT_GROUP(N_("Commit message options")),
1624 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1625 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1626 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1627 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1628 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1629 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1630 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1631 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1632 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1633 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1634 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1635 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1636 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1637 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1638 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1639 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1640 /* end commit message options */
1642 OPT_GROUP(N_("Commit contents options")),
1643 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1644 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1645 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1646 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1647 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1648 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1649 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1650 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1651 STATUS_FORMAT_SHORT),
1652 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1653 OPT_SET_INT(0, "porcelain", &status_format,
1654 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1655 OPT_SET_INT(0, "long", &status_format,
1656 N_("show status in long format (default)"),
1657 STATUS_FORMAT_LONG),
1658 OPT_BOOL('z', "null", &s.null_termination,
1659 N_("terminate entries with NUL")),
1660 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1661 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1662 { 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" },
1663 /* end commit contents options */
1665 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1666 N_("ok to record an empty change")),
1667 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1668 N_("ok to record a change with an empty message")),
1670 OPT_END()
1673 struct strbuf sb = STRBUF_INIT;
1674 struct strbuf author_ident = STRBUF_INIT;
1675 const char *index_file, *reflog_msg;
1676 char *nl;
1677 struct object_id oid;
1678 struct commit_list *parents = NULL;
1679 struct stat statbuf;
1680 struct commit *current_head = NULL;
1681 struct commit_extra_header *extra = NULL;
1682 struct ref_transaction *transaction;
1683 struct strbuf err = STRBUF_INIT;
1685 if (argc == 2 && !strcmp(argv[1], "-h"))
1686 usage_with_options(builtin_commit_usage, builtin_commit_options);
1688 status_init_config(&s, git_commit_config);
1689 s.commit_template = 1;
1690 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1691 s.colopts = 0;
1693 if (get_oid("HEAD", &oid))
1694 current_head = NULL;
1695 else {
1696 current_head = lookup_commit_or_die(&oid, "HEAD");
1697 if (parse_commit(current_head))
1698 die(_("could not parse HEAD commit"));
1700 verbose = -1; /* unspecified */
1701 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1702 builtin_commit_usage,
1703 prefix, current_head, &s);
1704 if (verbose == -1)
1705 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1707 if (dry_run)
1708 return dry_run_commit(argc, argv, prefix, current_head, &s);
1709 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1711 /* Set up everything for writing the commit object. This includes
1712 running hooks, writing the trees, and interacting with the user. */
1713 if (!prepare_to_commit(index_file, prefix,
1714 current_head, &s, &author_ident)) {
1715 rollback_index_files();
1716 return 1;
1719 /* Determine parents */
1720 reflog_msg = getenv("GIT_REFLOG_ACTION");
1721 if (!current_head) {
1722 if (!reflog_msg)
1723 reflog_msg = "commit (initial)";
1724 } else if (amend) {
1725 if (!reflog_msg)
1726 reflog_msg = "commit (amend)";
1727 parents = copy_commit_list(current_head->parents);
1728 } else if (whence == FROM_MERGE) {
1729 struct strbuf m = STRBUF_INIT;
1730 FILE *fp;
1731 int allow_fast_forward = 1;
1732 struct commit_list **pptr = &parents;
1734 if (!reflog_msg)
1735 reflog_msg = "commit (merge)";
1736 pptr = commit_list_append(current_head, pptr);
1737 fp = xfopen(git_path_merge_head(), "r");
1738 while (strbuf_getline_lf(&m, fp) != EOF) {
1739 struct commit *parent;
1741 parent = get_merge_parent(m.buf);
1742 if (!parent)
1743 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1744 pptr = commit_list_append(parent, pptr);
1746 fclose(fp);
1747 strbuf_release(&m);
1748 if (!stat(git_path_merge_mode(), &statbuf)) {
1749 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1750 die_errno(_("could not read MERGE_MODE"));
1751 if (!strcmp(sb.buf, "no-ff"))
1752 allow_fast_forward = 0;
1754 if (allow_fast_forward)
1755 reduce_heads_replace(&parents);
1756 } else {
1757 if (!reflog_msg)
1758 reflog_msg = (whence == FROM_CHERRY_PICK)
1759 ? "commit (cherry-pick)"
1760 : "commit";
1761 commit_list_insert(current_head, &parents);
1764 /* Finally, get the commit message */
1765 strbuf_reset(&sb);
1766 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1767 int saved_errno = errno;
1768 rollback_index_files();
1769 die(_("could not read commit message: %s"), strerror(saved_errno));
1772 if (verbose || /* Truncate the message just before the diff, if any. */
1773 cleanup_mode == CLEANUP_SCISSORS)
1774 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
1775 if (cleanup_mode != CLEANUP_NONE)
1776 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1778 if (message_is_empty(&sb) && !allow_empty_message) {
1779 rollback_index_files();
1780 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1781 exit(1);
1783 if (template_untouched(&sb) && !allow_empty_message) {
1784 rollback_index_files();
1785 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1786 exit(1);
1789 if (amend) {
1790 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1791 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1792 } else {
1793 struct commit_extra_header **tail = &extra;
1794 append_merge_tag_headers(parents, &tail);
1797 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
1798 parents, oid.hash, author_ident.buf, sign_commit, extra)) {
1799 rollback_index_files();
1800 die(_("failed to write commit object"));
1802 strbuf_release(&author_ident);
1803 free_commit_extra_headers(extra);
1805 nl = strchr(sb.buf, '\n');
1806 if (nl)
1807 strbuf_setlen(&sb, nl + 1 - sb.buf);
1808 else
1809 strbuf_addch(&sb, '\n');
1810 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1811 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1813 transaction = ref_transaction_begin(&err);
1814 if (!transaction ||
1815 ref_transaction_update(transaction, "HEAD", &oid,
1816 current_head
1817 ? &current_head->object.oid : &null_oid,
1818 0, sb.buf, &err) ||
1819 ref_transaction_commit(transaction, &err)) {
1820 rollback_index_files();
1821 die("%s", err.buf);
1823 ref_transaction_free(transaction);
1825 unlink(git_path_cherry_pick_head());
1826 unlink(git_path_revert_head());
1827 unlink(git_path_merge_head());
1828 unlink(git_path_merge_msg());
1829 unlink(git_path_merge_mode());
1830 unlink(git_path_squash_msg());
1832 if (commit_index_files())
1833 die (_("Repository has been updated, but unable to write\n"
1834 "new_index file. Check that disk is not full and quota is\n"
1835 "not exceeded, and then \"git reset HEAD\" to recover."));
1837 rerere(0);
1838 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1839 if (amend && !no_post_rewrite) {
1840 struct notes_rewrite_cfg *cfg;
1841 cfg = init_copy_notes_for_rewrite("amend");
1842 if (cfg) {
1843 /* we are amending, so current_head is not NULL */
1844 copy_note_for_rewrite(cfg, &current_head->object.oid, &oid);
1845 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1847 run_rewrite_hook(&current_head->object.oid, &oid);
1849 if (!quiet)
1850 print_summary(prefix, &oid, !current_head);
1852 UNLEAK(err);
1853 UNLEAK(sb);
1854 return 0;