1/*
2 * Builtin "git commit"
3 *
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
7
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"
37
38static const char * const builtin_commit_usage[] = {
39 N_("git commit [<options>] [--] <pathspec>..."),
40 NULL
41};
42
43static const char * const builtin_status_usage[] = {
44 N_("git status [<options>] [--] <pathspec>..."),
45 NULL
46};
47
48static const char implicit_ident_advice_noconfig[] =
49N_("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");
60
61static const char implicit_ident_advice_config[] =
62N_("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");
72
73static const char empty_amend_advice[] =
74N_("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");
77
78static const char empty_cherry_pick_advice[] =
79N_("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");
84
85static const char empty_cherry_pick_advice_single[] =
86N_("Otherwise, please use 'git reset'\n");
87
88static const char empty_cherry_pick_advice_multi[] =
89N_("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");
95
96static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
97
98static const char *use_message_buffer;
99static struct lock_file index_lock; /* real index */
100static struct lock_file false_lock; /* used only for partial commits */
101static enum {
102 COMMIT_AS_IS = 1,
103 COMMIT_NORMAL,
104 COMMIT_PARTIAL
105} commit_style;
106
107static const char *logfile, *force_author;
108static const char *template_file;
109/*
110 * The _message variables are commit names from which to take
111 * the commit message and/or authorship.
112 */
113static const char *author_message, *author_message_buffer;
114static char *edit_message, *use_message;
115static char *fixup_message, *squash_message;
116static int all, also, interactive, patch_interactive, only, amend, signoff;
117static int edit_flag = -1; /* unspecified */
118static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
119static int config_commit_verbose = -1; /* unspecified */
120static int no_post_rewrite, allow_empty_message;
121static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
122static char *sign_commit;
123
124/*
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.
130 */
131static enum {
132 CLEANUP_SPACE,
133 CLEANUP_NONE,
134 CLEANUP_SCISSORS,
135 CLEANUP_ALL
136} cleanup_mode;
137static const char *cleanup_arg;
138
139static enum commit_whence whence;
140static int sequencer_in_use;
141static int use_editor = 1, include_status = 1;
142static int show_ignored_in_status, have_option_m;
143static struct strbuf message = STRBUF_INIT;
144
145static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
146
147static int opt_parse_porcelain(const struct option *opt, const char *arg, int unset)
148{
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);
160
161 return 0;
162}
163
164static int opt_parse_m(const struct option *opt, const char *arg, int unset)
165{
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);
176 }
177 return 0;
178}
179
180static void determine_whence(struct wt_status *s)
181{
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;
188 }
189 else
190 whence = FROM_COMMIT;
191 if (s)
192 s->whence = whence;
193}
194
195static void status_init_config(struct wt_status *s, config_fn_t fn)
196{
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() */
202}
203
204static void rollback_index_files(void)
205{
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;
216 }
217}
218
219static int commit_index_files(void)
220{
221 int err = 0;
222
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;
233 }
234
235 return err;
236}
237
238/*
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.
241 */
242static int list_paths(struct string_list *list, const char *with_tree,
243 const char *prefix, const struct pathspec *pattern)
244{
245 int i, ret;
246 char *m;
247
248 if (!pattern->nr)
249 return 0;
250
251 m = xcalloc(1, pattern->nr);
252
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);
258 }
259
260 for (i = 0; i < active_nr; i++) {
261 const struct cache_entry *ce = active_cache[i];
262 struct string_list_item *item;
263
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 */
271 }
272
273 ret = report_path_error(m, pattern, prefix);
274 free(m);
275 return ret;
276}
277
278static void add_remove_files(struct string_list *list)
279{
280 int i;
281 for (i = 0; i < list->nr; i++) {
282 struct stat st;
283 struct string_list_item *p = &(list->items[i]);
284
285 /* p->util is skip-worktree */
286 if (p->util)
287 continue;
288
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);
294 }
295}
296
297static void create_base_index(const struct commit *current_head)
298{
299 struct tree *tree;
300 struct unpack_trees_options opts;
301 struct tree_desc t;
302
303 if (!current_head) {
304 discard_cache();
305 return;
306 }
307
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;
314
315 opts.fn = oneway_merge;
316 tree = parse_tree_indirect(¤t_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 */
323}
324
325static void refresh_cache_or_die(int refresh_flags)
326{
327 /*
328 * refresh_flags contains REFRESH_QUIET, so the only errors
329 * are for unmerged entries.
330 */
331 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
332 die_resolve_conflict("commit");
333}
334
335static const char *prepare_index(int argc, const char **argv, const char *prefix,
336 const struct commit *current_head, int is_status)
337{
338 struct string_list partial;
339 struct pathspec pathspec;
340 int refresh_flags = REFRESH_QUIET;
341 const char *ret;
342
343 if (is_status)
344 refresh_flags |= REFRESH_UNMERGED;
345 parse_pathspec(&pathspec, 0,
346 PATHSPEC_PREFER_FULL,
347 prefix, argv);
348
349 if (read_cache_preload(&pathspec) < 0)
350 die(_("index file corrupt"));
351
352 if (interactive) {
353 char *old_index_env = NULL;
354 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
355
356 refresh_cache_or_die(refresh_flags);
357
358 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
359 die(_("unable to create temporary index"));
360
361 old_index_env = getenv(INDEX_ENVIRONMENT);
362 setenv(INDEX_ENVIRONMENT, get_lock_file_path(&index_lock), 1);
363
364 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
365 die(_("interactive add failed"));
366
367 if (old_index_env && *old_index_env)
368 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
369 else
370 unsetenv(INDEX_ENVIRONMENT);
371
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"));
381
382 commit_style = COMMIT_NORMAL;
383 return get_lock_file_path(&index_lock);
384 }
385
386 /*
387 * Non partial, non as-is commit.
388 *
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.
393 *
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.
397 */
398 if (all || (also && pathspec.nr)) {
399 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
400 add_files_to_cache(also ? prefix : NULL, &pathspec, 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);
407 }
408
409 /*
410 * As-is commit.
411 *
412 * (1) return the name of the real index file.
413 *
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.
417 */
418 if (!only && !pathspec.nr) {
419 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
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);
430 }
431 commit_style = COMMIT_AS_IS;
432 return get_index_file();
433 }
434
435 /*
436 * A partial commit.
437 *
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);
447 *
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.
453 */
454 commit_style = COMMIT_PARTIAL;
455
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."));
461 }
462
463 string_list_init(&partial, 1);
464 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
465 exit(1);
466
467 discard_cache();
468 if (read_cache() < 0)
469 die(_("cannot read the index"));
470
471 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
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"));
477
478 hold_lock_file_for_update(&false_lock,
479 git_path("next-index-%"PRIuMAX,
480 (uintmax_t) getpid()),
481 LOCK_DIE_ON_ERROR);
482
483 create_base_index(current_head);
484 add_remove_files(&partial);
485 refresh_cache(REFRESH_QUIET);
486
487 if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))
488 die(_("unable to write temporary index file"));
489
490 discard_cache();
491 ret = get_lock_file_path(&false_lock);
492 read_cache_from(ret);
493 return ret;
494}
495
496static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
497 struct wt_status *s)
498{
499 struct object_id oid;
500
501 if (s->relative_paths)
502 s->prefix = prefix;
503
504 if (amend) {
505 s->amend = 1;
506 s->reference = "HEAD^1";
507 }
508 s->verbose = verbose;
509 s->index_file = index_file;
510 s->fp = fp;
511 s->nowarn = nowarn;
512 s->is_initial = get_oid(s->reference, &oid) ? 1 : 0;
513 if (!s->is_initial)
514 hashcpy(s->sha1_commit, oid.hash);
515 s->status_format = status_format;
516 s->ignore_submodule_arg = ignore_submodule_arg;
517
518 wt_status_collect(s);
519 wt_status_print(s);
520
521 return s->commitable;
522}
523
524static int is_a_merge(const struct commit *current_head)
525{
526 return !!(current_head->parents && current_head->parents->next);
527}
528
529static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
530{
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);
533}
534
535static void export_one(const char *var, const char *s, const char *e, int hack)
536{
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);
543}
544
545static int parse_force_date(const char *in, struct strbuf *out)
546{
547 strbuf_addch(out, '@');
548
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);
555 }
556
557 return 0;
558}
559
560static void set_ident_var(char **buf, char *val)
561{
562 free(*buf);
563 *buf = val;
564}
565
566static void determine_author_info(struct strbuf *author_ident)
567{
568 char *name, *email, *date;
569 struct ident_split author;
570
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"));
574
575 if (author_message) {
576 struct ident_split ident;
577 size_t len;
578 const char *a;
579
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);
585
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));
588
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));
596 }
597 }
598
599 if (force_author) {
600 struct ident_split ident;
601
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));
606 }
607
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));
613 }
614
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);
623}
624
625static int author_date_is_interesting(void)
626{
627 return author_message || force_date;
628}
629
630static void adjust_comment_line_char(const struct strbuf *sb)
631{
632 char candidates[] = "#;@!$%^&|:";
633 char *candidate;
634 const char *p;
635
636 comment_line_char = candidates[0];
637 if (!memchr(sb->buf, comment_line_char, sb->len))
638 return;
639
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 = ' ';
649 }
650 }
651
652 for (p = candidates; *p == ' '; p++)
653 ;
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;
658}
659
660static 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)
664{
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;
673
674 /* This checks and barfs if author is badly specified */
675 determine_author_info(author_ident);
676
677 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
678 return 0;
679
680 if (squash_message) {
681 /*
682 * Insert the proper subject line before other commit
683 * message options add their content.
684 */
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);
696 }
697 }
698
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)) {
731 /*
732 * prepend SQUASH_MSG here if it exists and a
733 * "merge --squash" was originally performed
734 */
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;
752 }
753
754 /*
755 * The remaining cases don't modify the template message, but
756 * just set the argument(s) to the prepare-commit-msg hook.
757 */
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";
763 }
764
765 if (squash_message) {
766 /*
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.
770 */
771 hook_arg1 = "message";
772 hook_arg2 = "";
773 }
774
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());
778
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;
782
783 /*
784 * Most hints are counter-productive when the commit has
785 * already started.
786 */
787 s->hints = 0;
788
789 if (clean_message_contents)
790 strbuf_stripspace(&sb, 0);
791
792 if (signoff)
793 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
794
795 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
796 die_errno(_("could not write commit template"));
797
798 if (auto_comment_line_char)
799 adjust_comment_line_char(&sb);
800 strbuf_release(&sb);
801
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;
808
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 whence == FROM_MERGE ?
825 git_path_merge_head() :
826 git_path_cherry_pick_head());
827 }
828
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
845 /*
846 * These should never fail because they come from our own
847 * fmt_ident. They may fail the sane_ident test, but we know
848 * that the name and mail pointers will at least be valid,
849 * which is enough for our tests and printing here.
850 */
851 assert_split_ident(&ai, author_ident);
852 assert_split_ident(&ci, &committer_ident);
853
854 if (ident_cmp(&ai, &ci))
855 status_printf_ln(s, GIT_COLOR_NORMAL,
856 _("%s"
857 "Author: %.*s <%.*s>"),
858 ident_shown++ ? "" : "\n",
859 (int)(ai.name_end - ai.name_begin), ai.name_begin,
860 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
861
862 if (author_date_is_interesting())
863 status_printf_ln(s, GIT_COLOR_NORMAL,
864 _("%s"
865 "Date: %s"),
866 ident_shown++ ? "" : "\n",
867 show_ident_date(&ai, DATE_MODE(NORMAL)));
868
869 if (!committer_ident_sufficiently_given())
870 status_printf_ln(s, GIT_COLOR_NORMAL,
871 _("%s"
872 "Committer: %.*s <%.*s>"),
873 ident_shown++ ? "" : "\n",
874 (int)(ci.name_end - ci.name_begin), ci.name_begin,
875 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
876
877 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); /* Add new line for clarity */
878
879 saved_color_setting = s->use_color;
880 s->use_color = 0;
881 commitable = run_status(s->fp, index_file, prefix, 1, s);
882 s->use_color = saved_color_setting;
883 } else {
884 struct object_id oid;
885 const char *parent = "HEAD";
886
887 if (!active_nr && read_cache() < 0)
888 die(_("Cannot read index"));
889
890 if (amend)
891 parent = "HEAD^1";
892
893 if (get_oid(parent, &oid)) {
894 int i, ita_nr = 0;
895
896 for (i = 0; i < active_nr; i++)
897 if (ce_intent_to_add(active_cache[i]))
898 ita_nr++;
899 commitable = active_nr - ita_nr > 0;
900 } else {
901 /*
902 * Unless the user did explicitly request a submodule
903 * ignore mode by passing a command line option we do
904 * not ignore any changed submodule SHA-1s when
905 * comparing index and parent, no matter what is
906 * configured. Otherwise we won't commit any
907 * submodules which were manually staged, which would
908 * be really confusing.
909 */
910 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
911 if (ignore_submodule_arg &&
912 !strcmp(ignore_submodule_arg, "all"))
913 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
914 commitable = index_differs_from(parent, diff_flags, 1);
915 }
916 }
917 strbuf_release(&committer_ident);
918
919 fclose(s->fp);
920
921 /*
922 * Reject an attempt to record a non-merge empty commit without
923 * explicit --allow-empty. In the cherry-pick case, it may be
924 * empty due to conflict resolution, which the user should okay.
925 */
926 if (!commitable && whence != FROM_MERGE && !allow_empty &&
927 !(amend && is_a_merge(current_head))) {
928 s->display_comment_prefix = old_display_comment_prefix;
929 run_status(stdout, index_file, prefix, 0, s);
930 if (amend)
931 fputs(_(empty_amend_advice), stderr);
932 else if (whence == FROM_CHERRY_PICK) {
933 fputs(_(empty_cherry_pick_advice), stderr);
934 if (!sequencer_in_use)
935 fputs(_(empty_cherry_pick_advice_single), stderr);
936 else
937 fputs(_(empty_cherry_pick_advice_multi), stderr);
938 }
939 return 0;
940 }
941
942 /*
943 * Re-read the index as pre-commit hook could have updated it,
944 * and write it out as a tree. We must do this before we invoke
945 * the editor and after we invoke run_status above.
946 */
947 discard_cache();
948 read_cache_from(index_file);
949 if (update_main_cache_tree(0)) {
950 error(_("Error building trees"));
951 return 0;
952 }
953
954 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
955 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
956 return 0;
957
958 if (use_editor) {
959 struct argv_array env = ARGV_ARRAY_INIT;
960
961 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
962 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
963 fprintf(stderr,
964 _("Please supply the message using either -m or -F option.\n"));
965 exit(1);
966 }
967 argv_array_clear(&env);
968 }
969
970 if (!no_verify &&
971 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
972 return 0;
973 }
974
975 return 1;
976}
977
978static int rest_is_empty(struct strbuf *sb, int start)
979{
980 int i, eol;
981 const char *nl;
982
983 /* Check if the rest is just whitespace and Signed-off-by's. */
984 for (i = start; i < sb->len; i++) {
985 nl = memchr(sb->buf + i, '\n', sb->len - i);
986 if (nl)
987 eol = nl - sb->buf;
988 else
989 eol = sb->len;
990
991 if (strlen(sign_off_header) <= eol - i &&
992 starts_with(sb->buf + i, sign_off_header)) {
993 i = eol;
994 continue;
995 }
996 while (i < eol)
997 if (!isspace(sb->buf[i++]))
998 return 0;
999 }
1000
1001 return 1;
1002}
1003
1004/*
1005 * Find out if the message in the strbuf contains only whitespace and
1006 * Signed-off-by lines.
1007 */
1008static int message_is_empty(struct strbuf *sb)
1009{
1010 if (cleanup_mode == CLEANUP_NONE && sb->len)
1011 return 0;
1012 return rest_is_empty(sb, 0);
1013}
1014
1015/*
1016 * See if the user edited the message in the editor or left what
1017 * was in the template intact
1018 */
1019static int template_untouched(struct strbuf *sb)
1020{
1021 struct strbuf tmpl = STRBUF_INIT;
1022 const char *start;
1023
1024 if (cleanup_mode == CLEANUP_NONE && sb->len)
1025 return 0;
1026
1027 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1028 return 0;
1029
1030 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1031 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1032 start = sb->buf;
1033 strbuf_release(&tmpl);
1034 return rest_is_empty(sb, start - sb->buf);
1035}
1036
1037static const char *find_author_by_nickname(const char *name)
1038{
1039 struct rev_info revs;
1040 struct commit *commit;
1041 struct strbuf buf = STRBUF_INIT;
1042 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1043 const char *av[20];
1044 int ac = 0;
1045
1046 init_revisions(&revs, NULL);
1047 strbuf_addf(&buf, "--author=%s", name);
1048 av[++ac] = "--all";
1049 av[++ac] = "-i";
1050 av[++ac] = buf.buf;
1051 av[++ac] = NULL;
1052 setup_revisions(ac, av, &revs, NULL);
1053 revs.mailmap = &mailmap;
1054 read_mailmap(revs.mailmap, NULL);
1055
1056 if (prepare_revision_walk(&revs))
1057 die(_("revision walk setup failed"));
1058 commit = get_revision(&revs);
1059 if (commit) {
1060 struct pretty_print_context ctx = {0};
1061 ctx.date_mode.type = DATE_NORMAL;
1062 strbuf_release(&buf);
1063 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1064 clear_mailmap(&mailmap);
1065 return strbuf_detach(&buf, NULL);
1066 }
1067 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1068}
1069
1070
1071static void handle_untracked_files_arg(struct wt_status *s)
1072{
1073 if (!untracked_files_arg)
1074 ; /* default already initialized */
1075 else if (!strcmp(untracked_files_arg, "no"))
1076 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1077 else if (!strcmp(untracked_files_arg, "normal"))
1078 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1079 else if (!strcmp(untracked_files_arg, "all"))
1080 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1081 else
1082 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1083}
1084
1085static const char *read_commit_message(const char *name)
1086{
1087 const char *out_enc;
1088 struct commit *commit;
1089
1090 commit = lookup_commit_reference_by_name(name);
1091 if (!commit)
1092 die(_("could not lookup commit %s"), name);
1093 out_enc = get_commit_output_encoding();
1094 return logmsg_reencode(commit, NULL, out_enc);
1095}
1096
1097/*
1098 * Enumerate what needs to be propagated when --porcelain
1099 * is not in effect here.
1100 */
1101static struct status_deferred_config {
1102 enum wt_status_format status_format;
1103 int show_branch;
1104} status_deferred_config = {
1105 STATUS_FORMAT_UNSPECIFIED,
1106 -1 /* unspecified */
1107};
1108
1109static void finalize_deferred_config(struct wt_status *s)
1110{
1111 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1112 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1113 !s->null_termination);
1114
1115 if (s->null_termination) {
1116 if (status_format == STATUS_FORMAT_NONE ||
1117 status_format == STATUS_FORMAT_UNSPECIFIED)
1118 status_format = STATUS_FORMAT_PORCELAIN;
1119 else if (status_format == STATUS_FORMAT_LONG)
1120 die(_("--long and -z are incompatible"));
1121 }
1122
1123 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1124 status_format = status_deferred_config.status_format;
1125 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1126 status_format = STATUS_FORMAT_NONE;
1127
1128 if (use_deferred_config && s->show_branch < 0)
1129 s->show_branch = status_deferred_config.show_branch;
1130 if (s->show_branch < 0)
1131 s->show_branch = 0;
1132}
1133
1134static int parse_and_validate_options(int argc, const char *argv[],
1135 const struct option *options,
1136 const char * const usage[],
1137 const char *prefix,
1138 struct commit *current_head,
1139 struct wt_status *s)
1140{
1141 int f = 0;
1142
1143 argc = parse_options(argc, argv, prefix, options, usage, 0);
1144 finalize_deferred_config(s);
1145
1146 if (force_author && !strchr(force_author, '>'))
1147 force_author = find_author_by_nickname(force_author);
1148
1149 if (force_author && renew_authorship)
1150 die(_("Using both --reset-author and --author does not make sense"));
1151
1152 if (logfile || have_option_m || use_message || fixup_message)
1153 use_editor = 0;
1154 if (0 <= edit_flag)
1155 use_editor = edit_flag;
1156
1157 /* Sanity check options */
1158 if (amend && !current_head)
1159 die(_("You have nothing to amend."));
1160 if (amend && whence != FROM_COMMIT) {
1161 if (whence == FROM_MERGE)
1162 die(_("You are in the middle of a merge -- cannot amend."));
1163 else if (whence == FROM_CHERRY_PICK)
1164 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1165 }
1166 if (fixup_message && squash_message)
1167 die(_("Options --squash and --fixup cannot be used together"));
1168 if (use_message)
1169 f++;
1170 if (edit_message)
1171 f++;
1172 if (fixup_message)
1173 f++;
1174 if (logfile)
1175 f++;
1176 if (f > 1)
1177 die(_("Only one of -c/-C/-F/--fixup can be used."));
1178 if (have_option_m && f > 0)
1179 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1180 if (f || have_option_m)
1181 template_file = NULL;
1182 if (edit_message)
1183 use_message = edit_message;
1184 if (amend && !use_message && !fixup_message)
1185 use_message = "HEAD";
1186 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1187 die(_("--reset-author can be used only with -C, -c or --amend."));
1188 if (use_message) {
1189 use_message_buffer = read_commit_message(use_message);
1190 if (!renew_authorship) {
1191 author_message = use_message;
1192 author_message_buffer = use_message_buffer;
1193 }
1194 }
1195 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1196 author_message = "CHERRY_PICK_HEAD";
1197 author_message_buffer = read_commit_message(author_message);
1198 }
1199
1200 if (patch_interactive)
1201 interactive = 1;
1202
1203 if (also + only + all + interactive > 1)
1204 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1205 if (argc == 0 && (also || (only && !amend && !allow_empty)))
1206 die(_("No paths with --include/--only does not make sense."));
1207 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1208 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1209 else if (!strcmp(cleanup_arg, "verbatim"))
1210 cleanup_mode = CLEANUP_NONE;
1211 else if (!strcmp(cleanup_arg, "whitespace"))
1212 cleanup_mode = CLEANUP_SPACE;
1213 else if (!strcmp(cleanup_arg, "strip"))
1214 cleanup_mode = CLEANUP_ALL;
1215 else if (!strcmp(cleanup_arg, "scissors"))
1216 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1217 else
1218 die(_("Invalid cleanup mode %s"), cleanup_arg);
1219
1220 handle_untracked_files_arg(s);
1221
1222 if (all && argc > 0)
1223 die(_("Paths with -a does not make sense."));
1224
1225 if (status_format != STATUS_FORMAT_NONE)
1226 dry_run = 1;
1227
1228 return argc;
1229}
1230
1231static int dry_run_commit(int argc, const char **argv, const char *prefix,
1232 const struct commit *current_head, struct wt_status *s)
1233{
1234 int commitable;
1235 const char *index_file;
1236
1237 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1238 commitable = run_status(stdout, index_file, prefix, 0, s);
1239 rollback_index_files();
1240
1241 return commitable ? 0 : 1;
1242}
1243
1244static int parse_status_slot(const char *slot)
1245{
1246 if (!strcasecmp(slot, "header"))
1247 return WT_STATUS_HEADER;
1248 if (!strcasecmp(slot, "branch"))
1249 return WT_STATUS_ONBRANCH;
1250 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1251 return WT_STATUS_UPDATED;
1252 if (!strcasecmp(slot, "changed"))
1253 return WT_STATUS_CHANGED;
1254 if (!strcasecmp(slot, "untracked"))
1255 return WT_STATUS_UNTRACKED;
1256 if (!strcasecmp(slot, "nobranch"))
1257 return WT_STATUS_NOBRANCH;
1258 if (!strcasecmp(slot, "unmerged"))
1259 return WT_STATUS_UNMERGED;
1260 if (!strcasecmp(slot, "localBranch"))
1261 return WT_STATUS_LOCAL_BRANCH;
1262 if (!strcasecmp(slot, "remoteBranch"))
1263 return WT_STATUS_REMOTE_BRANCH;
1264 return -1;
1265}
1266
1267static int git_status_config(const char *k, const char *v, void *cb)
1268{
1269 struct wt_status *s = cb;
1270 const char *slot_name;
1271
1272 if (starts_with(k, "column."))
1273 return git_column_config(k, v, "status", &s->colopts);
1274 if (!strcmp(k, "status.submodulesummary")) {
1275 int is_bool;
1276 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1277 if (is_bool && s->submodule_summary)
1278 s->submodule_summary = -1;
1279 return 0;
1280 }
1281 if (!strcmp(k, "status.short")) {
1282 if (git_config_bool(k, v))
1283 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1284 else
1285 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1286 return 0;
1287 }
1288 if (!strcmp(k, "status.branch")) {
1289 status_deferred_config.show_branch = git_config_bool(k, v);
1290 return 0;
1291 }
1292 if (!strcmp(k, "status.showstash")) {
1293 s->show_stash = git_config_bool(k, v);
1294 return 0;
1295 }
1296 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1297 s->use_color = git_config_colorbool(k, v);
1298 return 0;
1299 }
1300 if (!strcmp(k, "status.displaycommentprefix")) {
1301 s->display_comment_prefix = git_config_bool(k, v);
1302 return 0;
1303 }
1304 if (skip_prefix(k, "status.color.", &slot_name) ||
1305 skip_prefix(k, "color.status.", &slot_name)) {
1306 int slot = parse_status_slot(slot_name);
1307 if (slot < 0)
1308 return 0;
1309 if (!v)
1310 return config_error_nonbool(k);
1311 return color_parse(v, s->color_palette[slot]);
1312 }
1313 if (!strcmp(k, "status.relativepaths")) {
1314 s->relative_paths = git_config_bool(k, v);
1315 return 0;
1316 }
1317 if (!strcmp(k, "status.showuntrackedfiles")) {
1318 if (!v)
1319 return config_error_nonbool(k);
1320 else if (!strcmp(v, "no"))
1321 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1322 else if (!strcmp(v, "normal"))
1323 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1324 else if (!strcmp(v, "all"))
1325 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1326 else
1327 return error(_("Invalid untracked files mode '%s'"), v);
1328 return 0;
1329 }
1330 return git_diff_ui_config(k, v, NULL);
1331}
1332
1333int cmd_status(int argc, const char **argv, const char *prefix)
1334{
1335 static struct wt_status s;
1336 int fd;
1337 struct object_id oid;
1338 static struct option builtin_status_options[] = {
1339 OPT__VERBOSE(&verbose, N_("be verbose")),
1340 OPT_SET_INT('s', "short", &status_format,
1341 N_("show status concisely"), STATUS_FORMAT_SHORT),
1342 OPT_BOOL('b', "branch", &s.show_branch,
1343 N_("show branch information")),
1344 OPT_BOOL(0, "show-stash", &s.show_stash,
1345 N_("show stash information")),
1346 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1347 N_("version"), N_("machine-readable output"),
1348 PARSE_OPT_OPTARG, opt_parse_porcelain },
1349 OPT_SET_INT(0, "long", &status_format,
1350 N_("show status in long format (default)"),
1351 STATUS_FORMAT_LONG),
1352 OPT_BOOL('z', "null", &s.null_termination,
1353 N_("terminate entries with NUL")),
1354 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1355 N_("mode"),
1356 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1357 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1358 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1359 N_("show ignored files")),
1360 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1361 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1362 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1363 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1364 OPT_END(),
1365 };
1366
1367 if (argc == 2 && !strcmp(argv[1], "-h"))
1368 usage_with_options(builtin_status_usage, builtin_status_options);
1369
1370 status_init_config(&s, git_status_config);
1371 argc = parse_options(argc, argv, prefix,
1372 builtin_status_options,
1373 builtin_status_usage, 0);
1374 finalize_colopts(&s.colopts, -1);
1375 finalize_deferred_config(&s);
1376
1377 handle_untracked_files_arg(&s);
1378 if (show_ignored_in_status)
1379 s.show_ignored_files = 1;
1380 parse_pathspec(&s.pathspec, 0,
1381 PATHSPEC_PREFER_FULL,
1382 prefix, argv);
1383
1384 read_cache_preload(&s.pathspec);
1385 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1386
1387 fd = hold_locked_index(&index_lock, 0);
1388
1389 s.is_initial = get_oid(s.reference, &oid) ? 1 : 0;
1390 if (!s.is_initial)
1391 hashcpy(s.sha1_commit, oid.hash);
1392
1393 s.ignore_submodule_arg = ignore_submodule_arg;
1394 s.status_format = status_format;
1395 s.verbose = verbose;
1396
1397 wt_status_collect(&s);
1398
1399 if (0 <= fd)
1400 update_index_if_able(&the_index, &index_lock);
1401
1402 if (s.relative_paths)
1403 s.prefix = prefix;
1404
1405 wt_status_print(&s);
1406 return 0;
1407}
1408
1409static const char *implicit_ident_advice(void)
1410{
1411 char *user_config = expand_user_path("~/.gitconfig", 0);
1412 char *xdg_config = xdg_config_home("config");
1413 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1414
1415 free(user_config);
1416 free(xdg_config);
1417
1418 if (config_exists)
1419 return _(implicit_ident_advice_config);
1420 else
1421 return _(implicit_ident_advice_noconfig);
1422
1423}
1424
1425static void print_summary(const char *prefix, const struct object_id *oid,
1426 int initial_commit)
1427{
1428 struct rev_info rev;
1429 struct commit *commit;
1430 struct strbuf format = STRBUF_INIT;
1431 struct object_id junk_oid;
1432 const char *head;
1433 struct pretty_print_context pctx = {0};
1434 struct strbuf author_ident = STRBUF_INIT;
1435 struct strbuf committer_ident = STRBUF_INIT;
1436
1437 commit = lookup_commit(oid);
1438 if (!commit)
1439 die(_("couldn't look up newly created commit"));
1440 if (parse_commit(commit))
1441 die(_("could not parse newly created commit"));
1442
1443 strbuf_addstr(&format, "format:%h] %s");
1444
1445 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1446 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1447 if (strbuf_cmp(&author_ident, &committer_ident)) {
1448 strbuf_addstr(&format, "\n Author: ");
1449 strbuf_addbuf_percentquote(&format, &author_ident);
1450 }
1451 if (author_date_is_interesting()) {
1452 struct strbuf date = STRBUF_INIT;
1453 format_commit_message(commit, "%ad", &date, &pctx);
1454 strbuf_addstr(&format, "\n Date: ");
1455 strbuf_addbuf_percentquote(&format, &date);
1456 strbuf_release(&date);
1457 }
1458 if (!committer_ident_sufficiently_given()) {
1459 strbuf_addstr(&format, "\n Committer: ");
1460 strbuf_addbuf_percentquote(&format, &committer_ident);
1461 if (advice_implicit_identity) {
1462 strbuf_addch(&format, '\n');
1463 strbuf_addstr(&format, implicit_ident_advice());
1464 }
1465 }
1466 strbuf_release(&author_ident);
1467 strbuf_release(&committer_ident);
1468
1469 init_revisions(&rev, prefix);
1470 setup_revisions(0, NULL, &rev, NULL);
1471
1472 rev.diff = 1;
1473 rev.diffopt.output_format =
1474 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1475
1476 rev.verbose_header = 1;
1477 rev.show_root_diff = 1;
1478 get_commit_format(format.buf, &rev);
1479 rev.always_show_header = 0;
1480 rev.diffopt.detect_rename = 1;
1481 rev.diffopt.break_opt = 0;
1482 diff_setup_done(&rev.diffopt);
1483
1484 head = resolve_ref_unsafe("HEAD", 0, junk_oid.hash, NULL);
1485 if (!strcmp(head, "HEAD"))
1486 head = _("detached HEAD");
1487 else
1488 skip_prefix(head, "refs/heads/", &head);
1489 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1490
1491 if (!log_tree_commit(&rev, commit)) {
1492 rev.always_show_header = 1;
1493 rev.use_terminator = 1;
1494 log_tree_commit(&rev, commit);
1495 }
1496
1497 strbuf_release(&format);
1498}
1499
1500static int git_commit_config(const char *k, const char *v, void *cb)
1501{
1502 struct wt_status *s = cb;
1503 int status;
1504
1505 if (!strcmp(k, "commit.template"))
1506 return git_config_pathname(&template_file, k, v);
1507 if (!strcmp(k, "commit.status")) {
1508 include_status = git_config_bool(k, v);
1509 return 0;
1510 }
1511 if (!strcmp(k, "commit.cleanup"))
1512 return git_config_string(&cleanup_arg, k, v);
1513 if (!strcmp(k, "commit.gpgsign")) {
1514 sign_commit = git_config_bool(k, v) ? "" : NULL;
1515 return 0;
1516 }
1517 if (!strcmp(k, "commit.verbose")) {
1518 int is_bool;
1519 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1520 return 0;
1521 }
1522
1523 status = git_gpg_config(k, v, NULL);
1524 if (status)
1525 return status;
1526 return git_status_config(k, v, s);
1527}
1528
1529static int run_rewrite_hook(const struct object_id *oldoid,
1530 const struct object_id *newoid)
1531{
1532 struct child_process proc = CHILD_PROCESS_INIT;
1533 const char *argv[3];
1534 int code;
1535 struct strbuf sb = STRBUF_INIT;
1536
1537 argv[0] = find_hook("post-rewrite");
1538 if (!argv[0])
1539 return 0;
1540
1541 argv[1] = "amend";
1542 argv[2] = NULL;
1543
1544 proc.argv = argv;
1545 proc.in = -1;
1546 proc.stdout_to_stderr = 1;
1547
1548 code = start_command(&proc);
1549 if (code)
1550 return code;
1551 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1552 sigchain_push(SIGPIPE, SIG_IGN);
1553 write_in_full(proc.in, sb.buf, sb.len);
1554 close(proc.in);
1555 strbuf_release(&sb);
1556 sigchain_pop(SIGPIPE);
1557 return finish_command(&proc);
1558}
1559
1560int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1561{
1562 struct argv_array hook_env = ARGV_ARRAY_INIT;
1563 va_list args;
1564 int ret;
1565
1566 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1567
1568 /*
1569 * Let the hook know that no editor will be launched.
1570 */
1571 if (!editor_is_used)
1572 argv_array_push(&hook_env, "GIT_EDITOR=:");
1573
1574 va_start(args, name);
1575 ret = run_hook_ve(hook_env.argv,name, args);
1576 va_end(args);
1577 argv_array_clear(&hook_env);
1578
1579 return ret;
1580}
1581
1582int cmd_commit(int argc, const char **argv, const char *prefix)
1583{
1584 static struct wt_status s;
1585 static struct option builtin_commit_options[] = {
1586 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1587 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1588
1589 OPT_GROUP(N_("Commit message options")),
1590 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1591 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1592 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1593 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1594 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1595 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1596 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1597 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1598 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1599 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1600 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1601 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1602 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1603 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1604 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1605 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1606 /* end commit message options */
1607
1608 OPT_GROUP(N_("Commit contents options")),
1609 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1610 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1611 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1612 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1613 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1614 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1615 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1616 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1617 STATUS_FORMAT_SHORT),
1618 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1619 OPT_SET_INT(0, "porcelain", &status_format,
1620 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1621 OPT_SET_INT(0, "long", &status_format,
1622 N_("show status in long format (default)"),
1623 STATUS_FORMAT_LONG),
1624 OPT_BOOL('z', "null", &s.null_termination,
1625 N_("terminate entries with NUL")),
1626 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1627 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1628 { 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" },
1629 /* end commit contents options */
1630
1631 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1632 N_("ok to record an empty change")),
1633 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1634 N_("ok to record a change with an empty message")),
1635
1636 OPT_END()
1637 };
1638
1639 struct strbuf sb = STRBUF_INIT;
1640 struct strbuf author_ident = STRBUF_INIT;
1641 const char *index_file, *reflog_msg;
1642 char *nl;
1643 struct object_id oid;
1644 struct commit_list *parents = NULL;
1645 struct stat statbuf;
1646 struct commit *current_head = NULL;
1647 struct commit_extra_header *extra = NULL;
1648 struct ref_transaction *transaction;
1649 struct strbuf err = STRBUF_INIT;
1650
1651 if (argc == 2 && !strcmp(argv[1], "-h"))
1652 usage_with_options(builtin_commit_usage, builtin_commit_options);
1653
1654 status_init_config(&s, git_commit_config);
1655 s.commit_template = 1;
1656 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1657 s.colopts = 0;
1658
1659 if (get_oid("HEAD", &oid))
1660 current_head = NULL;
1661 else {
1662 current_head = lookup_commit_or_die(&oid, "HEAD");
1663 if (parse_commit(current_head))
1664 die(_("could not parse HEAD commit"));
1665 }
1666 verbose = -1; /* unspecified */
1667 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1668 builtin_commit_usage,
1669 prefix, current_head, &s);
1670 if (verbose == -1)
1671 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1672
1673 if (dry_run)
1674 return dry_run_commit(argc, argv, prefix, current_head, &s);
1675 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1676
1677 /* Set up everything for writing the commit object. This includes
1678 running hooks, writing the trees, and interacting with the user. */
1679 if (!prepare_to_commit(index_file, prefix,
1680 current_head, &s, &author_ident)) {
1681 rollback_index_files();
1682 return 1;
1683 }
1684
1685 /* Determine parents */
1686 reflog_msg = getenv("GIT_REFLOG_ACTION");
1687 if (!current_head) {
1688 if (!reflog_msg)
1689 reflog_msg = "commit (initial)";
1690 } else if (amend) {
1691 if (!reflog_msg)
1692 reflog_msg = "commit (amend)";
1693 parents = copy_commit_list(current_head->parents);
1694 } else if (whence == FROM_MERGE) {
1695 struct strbuf m = STRBUF_INIT;
1696 FILE *fp;
1697 int allow_fast_forward = 1;
1698 struct commit_list **pptr = &parents;
1699
1700 if (!reflog_msg)
1701 reflog_msg = "commit (merge)";
1702 pptr = commit_list_append(current_head, pptr);
1703 fp = xfopen(git_path_merge_head(), "r");
1704 while (strbuf_getline_lf(&m, fp) != EOF) {
1705 struct commit *parent;
1706
1707 parent = get_merge_parent(m.buf);
1708 if (!parent)
1709 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1710 pptr = commit_list_append(parent, pptr);
1711 }
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;
1719 }
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 commit_list_insert(current_head, &parents);
1728 }
1729
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));
1736 }
1737
1738 if (verbose || /* Truncate the message just before the diff, if any. */
1739 cleanup_mode == CLEANUP_SCISSORS)
1740 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
1741
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);
1748 }
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);
1753 }
1754
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);
1761 }
1762
1763 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
1764 parents, oid.hash, author_ident.buf, sign_commit, extra)) {
1765 rollback_index_files();
1766 die(_("failed to write commit object"));
1767 }
1768 strbuf_release(&author_ident);
1769 free_commit_extra_headers(extra);
1770
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);
1778
1779 transaction = ref_transaction_begin(&err);
1780 if (!transaction ||
1781 ref_transaction_update(transaction, "HEAD", oid.hash,
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);
1788 }
1789 ref_transaction_free(transaction);
1790
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());
1797
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."));
1802
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, ¤t_head->object.oid, &oid);
1811 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1812 }
1813 run_rewrite_hook(¤t_head->object.oid, &oid);
1814 }
1815 if (!quiet)
1816 print_summary(prefix, &oid, !current_head);
1817
1818 strbuf_release(&err);
1819 return 0;
1820}