1a0da71a43cfef8818b52a3d27131e340725cef2
[git/git.git] / builtin / commit.c
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
38 static const char * const builtin_commit_usage[] = {
39 N_("git commit [<options>] [--] <pathspec>..."),
40 NULL
41 };
42
43 static const char * const builtin_status_usage[] = {
44 N_("git status [<options>] [--] <pathspec>..."),
45 NULL
46 };
47
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");
60
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");
72
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");
77
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");
84
85 static const char empty_cherry_pick_advice_single[] =
86 N_("Otherwise, please use 'git reset'\n");
87
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");
95
96 static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
97
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;
106
107 static const char *logfile, *force_author;
108 static const char *template_file;
109 /*
110 * The _message variables are commit names from which to take
111 * the commit message and/or authorship.
112 */
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;
122 static 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 */
131 static enum {
132 CLEANUP_SPACE,
133 CLEANUP_NONE,
134 CLEANUP_SCISSORS,
135 CLEANUP_ALL
136 } cleanup_mode;
137 static const char *cleanup_arg;
138
139 static enum commit_whence whence;
140 static int sequencer_in_use;
141 static int use_editor = 1, include_status = 1;
142 static int show_ignored_in_status, have_option_m;
143 static struct strbuf message = STRBUF_INIT;
144
145 static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
146
147 static 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
164 static 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
180 static 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
195 static void status_init_config(struct wt_status *s, config_fn_t fn)
196 {
197 wt_status_prepare(s);
198 gitmodules_config();
199 git_config(fn, s);
200 determine_whence(s);
201 init_diff_ui_defaults();
202 s->hints = advice_status_hints; /* must come after git_config() */
203 }
204
205 static void rollback_index_files(void)
206 {
207 switch (commit_style) {
208 case COMMIT_AS_IS:
209 break; /* nothing to do */
210 case COMMIT_NORMAL:
211 rollback_lock_file(&index_lock);
212 break;
213 case COMMIT_PARTIAL:
214 rollback_lock_file(&index_lock);
215 rollback_lock_file(&false_lock);
216 break;
217 }
218 }
219
220 static int commit_index_files(void)
221 {
222 int err = 0;
223
224 switch (commit_style) {
225 case COMMIT_AS_IS:
226 break; /* nothing to do */
227 case COMMIT_NORMAL:
228 err = commit_lock_file(&index_lock);
229 break;
230 case COMMIT_PARTIAL:
231 err = commit_lock_file(&index_lock);
232 rollback_lock_file(&false_lock);
233 break;
234 }
235
236 return err;
237 }
238
239 /*
240 * Take a union of paths in the index and the named tree (typically, "HEAD"),
241 * and return the paths that match the given pattern in list.
242 */
243 static int list_paths(struct string_list *list, const char *with_tree,
244 const char *prefix, const struct pathspec *pattern)
245 {
246 int i, ret;
247 char *m;
248
249 if (!pattern->nr)
250 return 0;
251
252 m = xcalloc(1, pattern->nr);
253
254 if (with_tree) {
255 char *max_prefix = common_prefix(pattern);
256 overlay_tree_on_index(&the_index, with_tree,
257 max_prefix ? max_prefix : prefix);
258 free(max_prefix);
259 }
260
261 for (i = 0; i < active_nr; i++) {
262 const struct cache_entry *ce = active_cache[i];
263 struct string_list_item *item;
264
265 if (ce->ce_flags & CE_UPDATE)
266 continue;
267 if (!ce_path_match(ce, pattern, m))
268 continue;
269 item = string_list_insert(list, ce->name);
270 if (ce_skip_worktree(ce))
271 item->util = item; /* better a valid pointer than a fake one */
272 }
273
274 ret = report_path_error(m, pattern, prefix);
275 free(m);
276 return ret;
277 }
278
279 static void add_remove_files(struct string_list *list)
280 {
281 int i;
282 for (i = 0; i < list->nr; i++) {
283 struct stat st;
284 struct string_list_item *p = &(list->items[i]);
285
286 /* p->util is skip-worktree */
287 if (p->util)
288 continue;
289
290 if (!lstat(p->string, &st)) {
291 if (add_to_cache(p->string, &st, 0))
292 die(_("updating files failed"));
293 } else
294 remove_file_from_cache(p->string);
295 }
296 }
297
298 static void create_base_index(const struct commit *current_head)
299 {
300 struct tree *tree;
301 struct unpack_trees_options opts;
302 struct tree_desc t;
303
304 if (!current_head) {
305 discard_cache();
306 return;
307 }
308
309 memset(&opts, 0, sizeof(opts));
310 opts.head_idx = 1;
311 opts.index_only = 1;
312 opts.merge = 1;
313 opts.src_index = &the_index;
314 opts.dst_index = &the_index;
315
316 opts.fn = oneway_merge;
317 tree = parse_tree_indirect(&current_head->object.oid);
318 if (!tree)
319 die(_("failed to unpack HEAD tree object"));
320 parse_tree(tree);
321 init_tree_desc(&t, tree->buffer, tree->size);
322 if (unpack_trees(1, &t, &opts))
323 exit(128); /* We've already reported the error, finish dying */
324 }
325
326 static void refresh_cache_or_die(int refresh_flags)
327 {
328 /*
329 * refresh_flags contains REFRESH_QUIET, so the only errors
330 * are for unmerged entries.
331 */
332 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
333 die_resolve_conflict("commit");
334 }
335
336 static const char *prepare_index(int argc, const char **argv, const char *prefix,
337 const struct commit *current_head, int is_status)
338 {
339 struct string_list partial;
340 struct pathspec pathspec;
341 int refresh_flags = REFRESH_QUIET;
342 const char *ret;
343
344 if (is_status)
345 refresh_flags |= REFRESH_UNMERGED;
346 parse_pathspec(&pathspec, 0,
347 PATHSPEC_PREFER_FULL,
348 prefix, argv);
349
350 if (read_cache_preload(&pathspec) < 0)
351 die(_("index file corrupt"));
352
353 if (interactive) {
354 char *old_index_env = NULL;
355 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
356
357 refresh_cache_or_die(refresh_flags);
358
359 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
360 die(_("unable to create temporary index"));
361
362 old_index_env = getenv(INDEX_ENVIRONMENT);
363 setenv(INDEX_ENVIRONMENT, get_lock_file_path(&index_lock), 1);
364
365 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
366 die(_("interactive add failed"));
367
368 if (old_index_env && *old_index_env)
369 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
370 else
371 unsetenv(INDEX_ENVIRONMENT);
372
373 discard_cache();
374 read_cache_from(get_lock_file_path(&index_lock));
375 if (update_main_cache_tree(WRITE_TREE_SILENT) == 0) {
376 if (reopen_lock_file(&index_lock) < 0)
377 die(_("unable to write index file"));
378 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
379 die(_("unable to update temporary index"));
380 } else
381 warning(_("Failed to update main cache tree"));
382
383 commit_style = COMMIT_NORMAL;
384 return get_lock_file_path(&index_lock);
385 }
386
387 /*
388 * Non partial, non as-is commit.
389 *
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.
394 *
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.
398 */
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, CLOSE_LOCK))
405 die(_("unable to write new_index file"));
406 commit_style = COMMIT_NORMAL;
407 return get_lock_file_path(&index_lock);
408 }
409
410 /*
411 * As-is commit.
412 *
413 * (1) return the name of the real index file.
414 *
415 * The caller should run hooks on the real index,
416 * and create commit from the_index.
417 * We still need to refresh the index here.
418 */
419 if (!only && !pathspec.nr) {
420 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
421 refresh_cache_or_die(refresh_flags);
422 if (active_cache_changed
423 || !cache_tree_fully_valid(active_cache_tree))
424 update_main_cache_tree(WRITE_TREE_SILENT);
425 if (active_cache_changed) {
426 if (write_locked_index(&the_index, &index_lock,
427 COMMIT_LOCK))
428 die(_("unable to write new_index file"));
429 } else {
430 rollback_lock_file(&index_lock);
431 }
432 commit_style = COMMIT_AS_IS;
433 return get_index_file();
434 }
435
436 /*
437 * A partial commit.
438 *
439 * (0) find the set of affected paths;
440 * (1) get lock on the real index file;
441 * (2) update the_index with the given paths;
442 * (3) write the_index out to the real index (still locked);
443 * (4) get lock on the false index file;
444 * (5) reset the_index from HEAD;
445 * (6) update the_index the same way as (2);
446 * (7) write the_index out to the false index file;
447 * (8) return the name of the false index file (still locked);
448 *
449 * The caller should run hooks on the locked false index, and
450 * create commit from it. Then
451 * (A) if all goes well, commit the real index;
452 * (B) on failure, rollback the real index;
453 * In either case, rollback the false index.
454 */
455 commit_style = COMMIT_PARTIAL;
456
457 if (whence != FROM_COMMIT) {
458 if (whence == FROM_MERGE)
459 die(_("cannot do a partial commit during a merge."));
460 else if (whence == FROM_CHERRY_PICK)
461 die(_("cannot do a partial commit during a cherry-pick."));
462 }
463
464 string_list_init(&partial, 1);
465 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
466 exit(1);
467
468 discard_cache();
469 if (read_cache() < 0)
470 die(_("cannot read the index"));
471
472 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
473 add_remove_files(&partial);
474 refresh_cache(REFRESH_QUIET);
475 update_main_cache_tree(WRITE_TREE_SILENT);
476 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
477 die(_("unable to write new_index file"));
478
479 hold_lock_file_for_update(&false_lock,
480 git_path("next-index-%"PRIuMAX,
481 (uintmax_t) getpid()),
482 LOCK_DIE_ON_ERROR);
483
484 create_base_index(current_head);
485 add_remove_files(&partial);
486 refresh_cache(REFRESH_QUIET);
487
488 if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))
489 die(_("unable to write temporary index file"));
490
491 discard_cache();
492 ret = get_lock_file_path(&false_lock);
493 read_cache_from(ret);
494 return ret;
495 }
496
497 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
498 struct wt_status *s)
499 {
500 struct object_id oid;
501
502 if (s->relative_paths)
503 s->prefix = prefix;
504
505 if (amend) {
506 s->amend = 1;
507 s->reference = "HEAD^1";
508 }
509 s->verbose = verbose;
510 s->index_file = index_file;
511 s->fp = fp;
512 s->nowarn = nowarn;
513 s->is_initial = get_sha1(s->reference, oid.hash) ? 1 : 0;
514 if (!s->is_initial)
515 hashcpy(s->sha1_commit, oid.hash);
516 s->status_format = status_format;
517 s->ignore_submodule_arg = ignore_submodule_arg;
518
519 wt_status_collect(s);
520 wt_status_print(s);
521
522 return s->commitable;
523 }
524
525 static int is_a_merge(const struct commit *current_head)
526 {
527 return !!(current_head->parents && current_head->parents->next);
528 }
529
530 static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
531 {
532 if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)
533 die("BUG: unable to parse our own ident: %s", buf->buf);
534 }
535
536 static void export_one(const char *var, const char *s, const char *e, int hack)
537 {
538 struct strbuf buf = STRBUF_INIT;
539 if (hack)
540 strbuf_addch(&buf, hack);
541 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
542 setenv(var, buf.buf, 1);
543 strbuf_release(&buf);
544 }
545
546 static int parse_force_date(const char *in, struct strbuf *out)
547 {
548 strbuf_addch(out, '@');
549
550 if (parse_date(in, out) < 0) {
551 int errors = 0;
552 unsigned long t = approxidate_careful(in, &errors);
553 if (errors)
554 return -1;
555 strbuf_addf(out, "%lu", t);
556 }
557
558 return 0;
559 }
560
561 static void set_ident_var(char **buf, char *val)
562 {
563 free(*buf);
564 *buf = val;
565 }
566
567 static void determine_author_info(struct strbuf *author_ident)
568 {
569 char *name, *email, *date;
570 struct ident_split author;
571
572 name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
573 email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
574 date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
575
576 if (author_message) {
577 struct ident_split ident;
578 size_t len;
579 const char *a;
580
581 a = find_commit_header(author_message_buffer, "author", &len);
582 if (!a)
583 die(_("commit '%s' lacks author header"), author_message);
584 if (split_ident_line(&ident, a, len) < 0)
585 die(_("commit '%s' has malformed author line"), author_message);
586
587 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
588 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
589
590 if (ident.date_begin) {
591 struct strbuf date_buf = STRBUF_INIT;
592 strbuf_addch(&date_buf, '@');
593 strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);
594 strbuf_addch(&date_buf, ' ');
595 strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);
596 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
597 }
598 }
599
600 if (force_author) {
601 struct ident_split ident;
602
603 if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)
604 die(_("malformed --author parameter"));
605 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
606 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
607 }
608
609 if (force_date) {
610 struct strbuf date_buf = STRBUF_INIT;
611 if (parse_force_date(force_date, &date_buf))
612 die(_("invalid date format: %s"), force_date);
613 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
614 }
615
616 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
617 assert_split_ident(&author, author_ident);
618 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
619 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
620 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
621 free(name);
622 free(email);
623 free(date);
624 }
625
626 static int author_date_is_interesting(void)
627 {
628 return author_message || force_date;
629 }
630
631 static void adjust_comment_line_char(const struct strbuf *sb)
632 {
633 char candidates[] = "#;@!$%^&|:";
634 char *candidate;
635 const char *p;
636
637 comment_line_char = candidates[0];
638 if (!memchr(sb->buf, comment_line_char, sb->len))
639 return;
640
641 p = sb->buf;
642 candidate = strchr(candidates, *p);
643 if (candidate)
644 *candidate = ' ';
645 for (p = sb->buf; *p; p++) {
646 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
647 candidate = strchr(candidates, p[1]);
648 if (candidate)
649 *candidate = ' ';
650 }
651 }
652
653 for (p = candidates; *p == ' '; p++)
654 ;
655 if (!*p)
656 die(_("unable to select a comment character that is not used\n"
657 "in the current commit message"));
658 comment_line_char = *p;
659 }
660
661 static int prepare_to_commit(const char *index_file, const char *prefix,
662 struct commit *current_head,
663 struct wt_status *s,
664 struct strbuf *author_ident)
665 {
666 struct stat statbuf;
667 struct strbuf committer_ident = STRBUF_INIT;
668 int commitable;
669 struct strbuf sb = STRBUF_INIT;
670 const char *hook_arg1 = NULL;
671 const char *hook_arg2 = NULL;
672 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
673 int old_display_comment_prefix;
674
675 /* This checks and barfs if author is badly specified */
676 determine_author_info(author_ident);
677
678 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
679 return 0;
680
681 if (squash_message) {
682 /*
683 * Insert the proper subject line before other commit
684 * message options add their content.
685 */
686 if (use_message && !strcmp(use_message, squash_message))
687 strbuf_addstr(&sb, "squash! ");
688 else {
689 struct pretty_print_context ctx = {0};
690 struct commit *c;
691 c = lookup_commit_reference_by_name(squash_message);
692 if (!c)
693 die(_("could not lookup commit %s"), squash_message);
694 ctx.output_encoding = get_commit_output_encoding();
695 format_commit_message(c, "squash! %s\n\n", &sb,
696 &ctx);
697 }
698 }
699
700 if (have_option_m) {
701 strbuf_addbuf(&sb, &message);
702 hook_arg1 = "message";
703 } else if (logfile && !strcmp(logfile, "-")) {
704 if (isatty(0))
705 fprintf(stderr, _("(reading log message from standard input)\n"));
706 if (strbuf_read(&sb, 0, 0) < 0)
707 die_errno(_("could not read log from standard input"));
708 hook_arg1 = "message";
709 } else if (logfile) {
710 if (strbuf_read_file(&sb, logfile, 0) < 0)
711 die_errno(_("could not read log file '%s'"),
712 logfile);
713 hook_arg1 = "message";
714 } else if (use_message) {
715 char *buffer;
716 buffer = strstr(use_message_buffer, "\n\n");
717 if (buffer)
718 strbuf_addstr(&sb, skip_blank_lines(buffer + 2));
719 hook_arg1 = "commit";
720 hook_arg2 = use_message;
721 } else if (fixup_message) {
722 struct pretty_print_context ctx = {0};
723 struct commit *commit;
724 commit = lookup_commit_reference_by_name(fixup_message);
725 if (!commit)
726 die(_("could not lookup commit %s"), fixup_message);
727 ctx.output_encoding = get_commit_output_encoding();
728 format_commit_message(commit, "fixup! %s\n\n",
729 &sb, &ctx);
730 hook_arg1 = "message";
731 } else if (!stat(git_path_merge_msg(), &statbuf)) {
732 /*
733 * prepend SQUASH_MSG here if it exists and a
734 * "merge --squash" was originally performed
735 */
736 if (!stat(git_path_squash_msg(), &statbuf)) {
737 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
738 die_errno(_("could not read SQUASH_MSG"));
739 hook_arg1 = "squash";
740 } else
741 hook_arg1 = "merge";
742 if (strbuf_read_file(&sb, git_path_merge_msg(), 0) < 0)
743 die_errno(_("could not read MERGE_MSG"));
744 } else if (!stat(git_path_squash_msg(), &statbuf)) {
745 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
746 die_errno(_("could not read SQUASH_MSG"));
747 hook_arg1 = "squash";
748 } else if (template_file) {
749 if (strbuf_read_file(&sb, template_file, 0) < 0)
750 die_errno(_("could not read '%s'"), template_file);
751 hook_arg1 = "template";
752 clean_message_contents = 0;
753 }
754
755 /*
756 * The remaining cases don't modify the template message, but
757 * just set the argument(s) to the prepare-commit-msg hook.
758 */
759 else if (whence == FROM_MERGE)
760 hook_arg1 = "merge";
761 else if (whence == FROM_CHERRY_PICK) {
762 hook_arg1 = "commit";
763 hook_arg2 = "CHERRY_PICK_HEAD";
764 }
765
766 if (squash_message) {
767 /*
768 * If squash_commit was used for the commit subject,
769 * then we're possibly hijacking other commit log options.
770 * Reset the hook args to tell the real story.
771 */
772 hook_arg1 = "message";
773 hook_arg2 = "";
774 }
775
776 s->fp = fopen_for_writing(git_path_commit_editmsg());
777 if (s->fp == NULL)
778 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
779
780 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
781 old_display_comment_prefix = s->display_comment_prefix;
782 s->display_comment_prefix = 1;
783
784 /*
785 * Most hints are counter-productive when the commit has
786 * already started.
787 */
788 s->hints = 0;
789
790 if (clean_message_contents)
791 strbuf_stripspace(&sb, 0);
792
793 if (signoff)
794 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
795
796 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
797 die_errno(_("could not write commit template"));
798
799 if (auto_comment_line_char)
800 adjust_comment_line_char(&sb);
801 strbuf_release(&sb);
802
803 /* This checks if committer ident is explicitly given */
804 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
805 if (use_editor && include_status) {
806 int ident_shown = 0;
807 int saved_color_setting;
808 struct ident_split ci, ai;
809
810 if (whence != FROM_COMMIT) {
811 if (cleanup_mode == CLEANUP_SCISSORS)
812 wt_status_add_cut_line(s->fp);
813 status_printf_ln(s, GIT_COLOR_NORMAL,
814 whence == FROM_MERGE
815 ? _("\n"
816 "It looks like you may be committing a merge.\n"
817 "If this is not correct, please remove the file\n"
818 " %s\n"
819 "and try again.\n")
820 : _("\n"
821 "It looks like you may be committing a cherry-pick.\n"
822 "If this is not correct, please remove the file\n"
823 " %s\n"
824 "and try again.\n"),
825 whence == FROM_MERGE ?
826 git_path_merge_head() :
827 git_path_cherry_pick_head());
828 }
829
830 fprintf(s->fp, "\n");
831 if (cleanup_mode == CLEANUP_ALL)
832 status_printf(s, GIT_COLOR_NORMAL,
833 _("Please enter the commit message for your changes."
834 " Lines starting\nwith '%c' will be ignored, and an empty"
835 " message aborts the commit.\n"), comment_line_char);
836 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
837 wt_status_add_cut_line(s->fp);
838 else /* CLEANUP_SPACE, that is. */
839 status_printf(s, GIT_COLOR_NORMAL,
840 _("Please enter the commit message for your changes."
841 " Lines starting\n"
842 "with '%c' will be kept; you may remove them"
843 " yourself if you want to.\n"
844 "An empty message aborts the commit.\n"), comment_line_char);
845
846 /*
847 * These should never fail because they come from our own
848 * fmt_ident. They may fail the sane_ident test, but we know
849 * that the name and mail pointers will at least be valid,
850 * which is enough for our tests and printing here.
851 */
852 assert_split_ident(&ai, author_ident);
853 assert_split_ident(&ci, &committer_ident);
854
855 if (ident_cmp(&ai, &ci))
856 status_printf_ln(s, GIT_COLOR_NORMAL,
857 _("%s"
858 "Author: %.*s <%.*s>"),
859 ident_shown++ ? "" : "\n",
860 (int)(ai.name_end - ai.name_begin), ai.name_begin,
861 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
862
863 if (author_date_is_interesting())
864 status_printf_ln(s, GIT_COLOR_NORMAL,
865 _("%s"
866 "Date: %s"),
867 ident_shown++ ? "" : "\n",
868 show_ident_date(&ai, DATE_MODE(NORMAL)));
869
870 if (!committer_ident_sufficiently_given())
871 status_printf_ln(s, GIT_COLOR_NORMAL,
872 _("%s"
873 "Committer: %.*s <%.*s>"),
874 ident_shown++ ? "" : "\n",
875 (int)(ci.name_end - ci.name_begin), ci.name_begin,
876 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
877
878 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); /* Add new line for clarity */
879
880 saved_color_setting = s->use_color;
881 s->use_color = 0;
882 commitable = run_status(s->fp, index_file, prefix, 1, s);
883 s->use_color = saved_color_setting;
884 } else {
885 struct object_id oid;
886 const char *parent = "HEAD";
887
888 if (!active_nr && read_cache() < 0)
889 die(_("Cannot read index"));
890
891 if (amend)
892 parent = "HEAD^1";
893
894 if (get_sha1(parent, oid.hash)) {
895 int i, ita_nr = 0;
896
897 for (i = 0; i < active_nr; i++)
898 if (ce_intent_to_add(active_cache[i]))
899 ita_nr++;
900 commitable = active_nr - ita_nr > 0;
901 } else {
902 /*
903 * Unless the user did explicitly request a submodule
904 * ignore mode by passing a command line option we do
905 * not ignore any changed submodule SHA-1s when
906 * comparing index and parent, no matter what is
907 * configured. Otherwise we won't commit any
908 * submodules which were manually staged, which would
909 * be really confusing.
910 */
911 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
912 if (ignore_submodule_arg &&
913 !strcmp(ignore_submodule_arg, "all"))
914 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
915 commitable = index_differs_from(parent, diff_flags, 1);
916 }
917 }
918 strbuf_release(&committer_ident);
919
920 fclose(s->fp);
921
922 /*
923 * Reject an attempt to record a non-merge empty commit without
924 * explicit --allow-empty. In the cherry-pick case, it may be
925 * empty due to conflict resolution, which the user should okay.
926 */
927 if (!commitable && whence != FROM_MERGE && !allow_empty &&
928 !(amend && is_a_merge(current_head))) {
929 s->display_comment_prefix = old_display_comment_prefix;
930 run_status(stdout, index_file, prefix, 0, s);
931 if (amend)
932 fputs(_(empty_amend_advice), stderr);
933 else if (whence == FROM_CHERRY_PICK) {
934 fputs(_(empty_cherry_pick_advice), stderr);
935 if (!sequencer_in_use)
936 fputs(_(empty_cherry_pick_advice_single), stderr);
937 else
938 fputs(_(empty_cherry_pick_advice_multi), stderr);
939 }
940 return 0;
941 }
942
943 /*
944 * Re-read the index as pre-commit hook could have updated it,
945 * and write it out as a tree. We must do this before we invoke
946 * the editor and after we invoke run_status above.
947 */
948 discard_cache();
949 read_cache_from(index_file);
950 if (update_main_cache_tree(0)) {
951 error(_("Error building trees"));
952 return 0;
953 }
954
955 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
956 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
957 return 0;
958
959 if (use_editor) {
960 struct argv_array env = ARGV_ARRAY_INIT;
961
962 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
963 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
964 fprintf(stderr,
965 _("Please supply the message using either -m or -F option.\n"));
966 exit(1);
967 }
968 argv_array_clear(&env);
969 }
970
971 if (!no_verify &&
972 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
973 return 0;
974 }
975
976 return 1;
977 }
978
979 static int rest_is_empty(struct strbuf *sb, int start)
980 {
981 int i, eol;
982 const char *nl;
983
984 /* Check if the rest is just whitespace and Signed-off-by's. */
985 for (i = start; i < sb->len; i++) {
986 nl = memchr(sb->buf + i, '\n', sb->len - i);
987 if (nl)
988 eol = nl - sb->buf;
989 else
990 eol = sb->len;
991
992 if (strlen(sign_off_header) <= eol - i &&
993 starts_with(sb->buf + i, sign_off_header)) {
994 i = eol;
995 continue;
996 }
997 while (i < eol)
998 if (!isspace(sb->buf[i++]))
999 return 0;
1000 }
1001
1002 return 1;
1003 }
1004
1005 /*
1006 * Find out if the message in the strbuf contains only whitespace and
1007 * Signed-off-by lines.
1008 */
1009 static int message_is_empty(struct strbuf *sb)
1010 {
1011 if (cleanup_mode == CLEANUP_NONE && sb->len)
1012 return 0;
1013 return rest_is_empty(sb, 0);
1014 }
1015
1016 /*
1017 * See if the user edited the message in the editor or left what
1018 * was in the template intact
1019 */
1020 static int template_untouched(struct strbuf *sb)
1021 {
1022 struct strbuf tmpl = STRBUF_INIT;
1023 const char *start;
1024
1025 if (cleanup_mode == CLEANUP_NONE && sb->len)
1026 return 0;
1027
1028 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1029 return 0;
1030
1031 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1032 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1033 start = sb->buf;
1034 strbuf_release(&tmpl);
1035 return rest_is_empty(sb, start - sb->buf);
1036 }
1037
1038 static const char *find_author_by_nickname(const char *name)
1039 {
1040 struct rev_info revs;
1041 struct commit *commit;
1042 struct strbuf buf = STRBUF_INIT;
1043 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1044 const char *av[20];
1045 int ac = 0;
1046
1047 init_revisions(&revs, NULL);
1048 strbuf_addf(&buf, "--author=%s", name);
1049 av[++ac] = "--all";
1050 av[++ac] = "-i";
1051 av[++ac] = buf.buf;
1052 av[++ac] = NULL;
1053 setup_revisions(ac, av, &revs, NULL);
1054 revs.mailmap = &mailmap;
1055 read_mailmap(revs.mailmap, NULL);
1056
1057 if (prepare_revision_walk(&revs))
1058 die(_("revision walk setup failed"));
1059 commit = get_revision(&revs);
1060 if (commit) {
1061 struct pretty_print_context ctx = {0};
1062 ctx.date_mode.type = DATE_NORMAL;
1063 strbuf_release(&buf);
1064 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1065 clear_mailmap(&mailmap);
1066 return strbuf_detach(&buf, NULL);
1067 }
1068 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1069 }
1070
1071
1072 static void handle_untracked_files_arg(struct wt_status *s)
1073 {
1074 if (!untracked_files_arg)
1075 ; /* default already initialized */
1076 else if (!strcmp(untracked_files_arg, "no"))
1077 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1078 else if (!strcmp(untracked_files_arg, "normal"))
1079 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1080 else if (!strcmp(untracked_files_arg, "all"))
1081 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1082 else
1083 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1084 }
1085
1086 static const char *read_commit_message(const char *name)
1087 {
1088 const char *out_enc;
1089 struct commit *commit;
1090
1091 commit = lookup_commit_reference_by_name(name);
1092 if (!commit)
1093 die(_("could not lookup commit %s"), name);
1094 out_enc = get_commit_output_encoding();
1095 return logmsg_reencode(commit, NULL, out_enc);
1096 }
1097
1098 /*
1099 * Enumerate what needs to be propagated when --porcelain
1100 * is not in effect here.
1101 */
1102 static struct status_deferred_config {
1103 enum wt_status_format status_format;
1104 int show_branch;
1105 } status_deferred_config = {
1106 STATUS_FORMAT_UNSPECIFIED,
1107 -1 /* unspecified */
1108 };
1109
1110 static void finalize_deferred_config(struct wt_status *s)
1111 {
1112 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1113 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1114 !s->null_termination);
1115
1116 if (s->null_termination) {
1117 if (status_format == STATUS_FORMAT_NONE ||
1118 status_format == STATUS_FORMAT_UNSPECIFIED)
1119 status_format = STATUS_FORMAT_PORCELAIN;
1120 else if (status_format == STATUS_FORMAT_LONG)
1121 die(_("--long and -z are incompatible"));
1122 }
1123
1124 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1125 status_format = status_deferred_config.status_format;
1126 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1127 status_format = STATUS_FORMAT_NONE;
1128
1129 if (use_deferred_config && s->show_branch < 0)
1130 s->show_branch = status_deferred_config.show_branch;
1131 if (s->show_branch < 0)
1132 s->show_branch = 0;
1133 }
1134
1135 static int parse_and_validate_options(int argc, const char *argv[],
1136 const struct option *options,
1137 const char * const usage[],
1138 const char *prefix,
1139 struct commit *current_head,
1140 struct wt_status *s)
1141 {
1142 int f = 0;
1143
1144 argc = parse_options(argc, argv, prefix, options, usage, 0);
1145 finalize_deferred_config(s);
1146
1147 if (force_author && !strchr(force_author, '>'))
1148 force_author = find_author_by_nickname(force_author);
1149
1150 if (force_author && renew_authorship)
1151 die(_("Using both --reset-author and --author does not make sense"));
1152
1153 if (logfile || have_option_m || use_message || fixup_message)
1154 use_editor = 0;
1155 if (0 <= edit_flag)
1156 use_editor = edit_flag;
1157
1158 /* Sanity check options */
1159 if (amend && !current_head)
1160 die(_("You have nothing to amend."));
1161 if (amend && whence != FROM_COMMIT) {
1162 if (whence == FROM_MERGE)
1163 die(_("You are in the middle of a merge -- cannot amend."));
1164 else if (whence == FROM_CHERRY_PICK)
1165 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1166 }
1167 if (fixup_message && squash_message)
1168 die(_("Options --squash and --fixup cannot be used together"));
1169 if (use_message)
1170 f++;
1171 if (edit_message)
1172 f++;
1173 if (fixup_message)
1174 f++;
1175 if (logfile)
1176 f++;
1177 if (f > 1)
1178 die(_("Only one of -c/-C/-F/--fixup can be used."));
1179 if (have_option_m && f > 0)
1180 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1181 if (f || have_option_m)
1182 template_file = NULL;
1183 if (edit_message)
1184 use_message = edit_message;
1185 if (amend && !use_message && !fixup_message)
1186 use_message = "HEAD";
1187 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1188 die(_("--reset-author can be used only with -C, -c or --amend."));
1189 if (use_message) {
1190 use_message_buffer = read_commit_message(use_message);
1191 if (!renew_authorship) {
1192 author_message = use_message;
1193 author_message_buffer = use_message_buffer;
1194 }
1195 }
1196 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1197 author_message = "CHERRY_PICK_HEAD";
1198 author_message_buffer = read_commit_message(author_message);
1199 }
1200
1201 if (patch_interactive)
1202 interactive = 1;
1203
1204 if (also + only + all + interactive > 1)
1205 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1206 if (argc == 0 && (also || (only && !amend && !allow_empty)))
1207 die(_("No paths with --include/--only does not make sense."));
1208 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1209 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1210 else if (!strcmp(cleanup_arg, "verbatim"))
1211 cleanup_mode = CLEANUP_NONE;
1212 else if (!strcmp(cleanup_arg, "whitespace"))
1213 cleanup_mode = CLEANUP_SPACE;
1214 else if (!strcmp(cleanup_arg, "strip"))
1215 cleanup_mode = CLEANUP_ALL;
1216 else if (!strcmp(cleanup_arg, "scissors"))
1217 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1218 else
1219 die(_("Invalid cleanup mode %s"), cleanup_arg);
1220
1221 handle_untracked_files_arg(s);
1222
1223 if (all && argc > 0)
1224 die(_("Paths with -a does not make sense."));
1225
1226 if (status_format != STATUS_FORMAT_NONE)
1227 dry_run = 1;
1228
1229 return argc;
1230 }
1231
1232 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1233 const struct commit *current_head, struct wt_status *s)
1234 {
1235 int commitable;
1236 const char *index_file;
1237
1238 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1239 commitable = run_status(stdout, index_file, prefix, 0, s);
1240 rollback_index_files();
1241
1242 return commitable ? 0 : 1;
1243 }
1244
1245 static int parse_status_slot(const char *slot)
1246 {
1247 if (!strcasecmp(slot, "header"))
1248 return WT_STATUS_HEADER;
1249 if (!strcasecmp(slot, "branch"))
1250 return WT_STATUS_ONBRANCH;
1251 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1252 return WT_STATUS_UPDATED;
1253 if (!strcasecmp(slot, "changed"))
1254 return WT_STATUS_CHANGED;
1255 if (!strcasecmp(slot, "untracked"))
1256 return WT_STATUS_UNTRACKED;
1257 if (!strcasecmp(slot, "nobranch"))
1258 return WT_STATUS_NOBRANCH;
1259 if (!strcasecmp(slot, "unmerged"))
1260 return WT_STATUS_UNMERGED;
1261 if (!strcasecmp(slot, "localBranch"))
1262 return WT_STATUS_LOCAL_BRANCH;
1263 if (!strcasecmp(slot, "remoteBranch"))
1264 return WT_STATUS_REMOTE_BRANCH;
1265 return -1;
1266 }
1267
1268 static int git_status_config(const char *k, const char *v, void *cb)
1269 {
1270 struct wt_status *s = cb;
1271 const char *slot_name;
1272
1273 if (starts_with(k, "column."))
1274 return git_column_config(k, v, "status", &s->colopts);
1275 if (!strcmp(k, "status.submodulesummary")) {
1276 int is_bool;
1277 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1278 if (is_bool && s->submodule_summary)
1279 s->submodule_summary = -1;
1280 return 0;
1281 }
1282 if (!strcmp(k, "status.short")) {
1283 if (git_config_bool(k, v))
1284 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1285 else
1286 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1287 return 0;
1288 }
1289 if (!strcmp(k, "status.branch")) {
1290 status_deferred_config.show_branch = git_config_bool(k, v);
1291 return 0;
1292 }
1293 if (!strcmp(k, "status.showstash")) {
1294 s->show_stash = git_config_bool(k, v);
1295 return 0;
1296 }
1297 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1298 s->use_color = git_config_colorbool(k, v);
1299 return 0;
1300 }
1301 if (!strcmp(k, "status.displaycommentprefix")) {
1302 s->display_comment_prefix = git_config_bool(k, v);
1303 return 0;
1304 }
1305 if (skip_prefix(k, "status.color.", &slot_name) ||
1306 skip_prefix(k, "color.status.", &slot_name)) {
1307 int slot = parse_status_slot(slot_name);
1308 if (slot < 0)
1309 return 0;
1310 if (!v)
1311 return config_error_nonbool(k);
1312 return color_parse(v, s->color_palette[slot]);
1313 }
1314 if (!strcmp(k, "status.relativepaths")) {
1315 s->relative_paths = git_config_bool(k, v);
1316 return 0;
1317 }
1318 if (!strcmp(k, "status.showuntrackedfiles")) {
1319 if (!v)
1320 return config_error_nonbool(k);
1321 else if (!strcmp(v, "no"))
1322 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1323 else if (!strcmp(v, "normal"))
1324 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1325 else if (!strcmp(v, "all"))
1326 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1327 else
1328 return error(_("Invalid untracked files mode '%s'"), v);
1329 return 0;
1330 }
1331 return git_diff_ui_config(k, v, NULL);
1332 }
1333
1334 int cmd_status(int argc, const char **argv, const char *prefix)
1335 {
1336 static struct wt_status s;
1337 int fd;
1338 struct object_id oid;
1339 static struct option builtin_status_options[] = {
1340 OPT__VERBOSE(&verbose, N_("be verbose")),
1341 OPT_SET_INT('s', "short", &status_format,
1342 N_("show status concisely"), STATUS_FORMAT_SHORT),
1343 OPT_BOOL('b', "branch", &s.show_branch,
1344 N_("show branch information")),
1345 OPT_BOOL(0, "show-stash", &s.show_stash,
1346 N_("show stash information")),
1347 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1348 N_("version"), N_("machine-readable output"),
1349 PARSE_OPT_OPTARG, opt_parse_porcelain },
1350 OPT_SET_INT(0, "long", &status_format,
1351 N_("show status in long format (default)"),
1352 STATUS_FORMAT_LONG),
1353 OPT_BOOL('z', "null", &s.null_termination,
1354 N_("terminate entries with NUL")),
1355 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1356 N_("mode"),
1357 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1358 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1359 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1360 N_("show ignored files")),
1361 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1362 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1363 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1364 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1365 OPT_END(),
1366 };
1367
1368 if (argc == 2 && !strcmp(argv[1], "-h"))
1369 usage_with_options(builtin_status_usage, builtin_status_options);
1370
1371 status_init_config(&s, git_status_config);
1372 argc = parse_options(argc, argv, prefix,
1373 builtin_status_options,
1374 builtin_status_usage, 0);
1375 finalize_colopts(&s.colopts, -1);
1376 finalize_deferred_config(&s);
1377
1378 handle_untracked_files_arg(&s);
1379 if (show_ignored_in_status)
1380 s.show_ignored_files = 1;
1381 parse_pathspec(&s.pathspec, 0,
1382 PATHSPEC_PREFER_FULL,
1383 prefix, argv);
1384
1385 read_cache_preload(&s.pathspec);
1386 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1387
1388 fd = hold_locked_index(&index_lock, 0);
1389
1390 s.is_initial = get_sha1(s.reference, oid.hash) ? 1 : 0;
1391 if (!s.is_initial)
1392 hashcpy(s.sha1_commit, oid.hash);
1393
1394 s.ignore_submodule_arg = ignore_submodule_arg;
1395 s.status_format = status_format;
1396 s.verbose = verbose;
1397
1398 wt_status_collect(&s);
1399
1400 if (0 <= fd)
1401 update_index_if_able(&the_index, &index_lock);
1402
1403 if (s.relative_paths)
1404 s.prefix = prefix;
1405
1406 wt_status_print(&s);
1407 return 0;
1408 }
1409
1410 static const char *implicit_ident_advice(void)
1411 {
1412 char *user_config = expand_user_path("~/.gitconfig", 0);
1413 char *xdg_config = xdg_config_home("config");
1414 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1415
1416 free(user_config);
1417 free(xdg_config);
1418
1419 if (config_exists)
1420 return _(implicit_ident_advice_config);
1421 else
1422 return _(implicit_ident_advice_noconfig);
1423
1424 }
1425
1426 static void print_summary(const char *prefix, const struct object_id *oid,
1427 int initial_commit)
1428 {
1429 struct rev_info rev;
1430 struct commit *commit;
1431 struct strbuf format = STRBUF_INIT;
1432 struct object_id junk_oid;
1433 const char *head;
1434 struct pretty_print_context pctx = {0};
1435 struct strbuf author_ident = STRBUF_INIT;
1436 struct strbuf committer_ident = STRBUF_INIT;
1437
1438 commit = lookup_commit(oid);
1439 if (!commit)
1440 die(_("couldn't look up newly created commit"));
1441 if (parse_commit(commit))
1442 die(_("could not parse newly created commit"));
1443
1444 strbuf_addstr(&format, "format:%h] %s");
1445
1446 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1447 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1448 if (strbuf_cmp(&author_ident, &committer_ident)) {
1449 strbuf_addstr(&format, "\n Author: ");
1450 strbuf_addbuf_percentquote(&format, &author_ident);
1451 }
1452 if (author_date_is_interesting()) {
1453 struct strbuf date = STRBUF_INIT;
1454 format_commit_message(commit, "%ad", &date, &pctx);
1455 strbuf_addstr(&format, "\n Date: ");
1456 strbuf_addbuf_percentquote(&format, &date);
1457 strbuf_release(&date);
1458 }
1459 if (!committer_ident_sufficiently_given()) {
1460 strbuf_addstr(&format, "\n Committer: ");
1461 strbuf_addbuf_percentquote(&format, &committer_ident);
1462 if (advice_implicit_identity) {
1463 strbuf_addch(&format, '\n');
1464 strbuf_addstr(&format, implicit_ident_advice());
1465 }
1466 }
1467 strbuf_release(&author_ident);
1468 strbuf_release(&committer_ident);
1469
1470 init_revisions(&rev, prefix);
1471 setup_revisions(0, NULL, &rev, NULL);
1472
1473 rev.diff = 1;
1474 rev.diffopt.output_format =
1475 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1476
1477 rev.verbose_header = 1;
1478 rev.show_root_diff = 1;
1479 get_commit_format(format.buf, &rev);
1480 rev.always_show_header = 0;
1481 rev.diffopt.detect_rename = 1;
1482 rev.diffopt.break_opt = 0;
1483 diff_setup_done(&rev.diffopt);
1484
1485 head = resolve_ref_unsafe("HEAD", 0, junk_oid.hash, NULL);
1486 if (!strcmp(head, "HEAD"))
1487 head = _("detached HEAD");
1488 else
1489 skip_prefix(head, "refs/heads/", &head);
1490 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1491
1492 if (!log_tree_commit(&rev, commit)) {
1493 rev.always_show_header = 1;
1494 rev.use_terminator = 1;
1495 log_tree_commit(&rev, commit);
1496 }
1497
1498 strbuf_release(&format);
1499 }
1500
1501 static int git_commit_config(const char *k, const char *v, void *cb)
1502 {
1503 struct wt_status *s = cb;
1504 int status;
1505
1506 if (!strcmp(k, "commit.template"))
1507 return git_config_pathname(&template_file, k, v);
1508 if (!strcmp(k, "commit.status")) {
1509 include_status = git_config_bool(k, v);
1510 return 0;
1511 }
1512 if (!strcmp(k, "commit.cleanup"))
1513 return git_config_string(&cleanup_arg, k, v);
1514 if (!strcmp(k, "commit.gpgsign")) {
1515 sign_commit = git_config_bool(k, v) ? "" : NULL;
1516 return 0;
1517 }
1518 if (!strcmp(k, "commit.verbose")) {
1519 int is_bool;
1520 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1521 return 0;
1522 }
1523
1524 status = git_gpg_config(k, v, NULL);
1525 if (status)
1526 return status;
1527 return git_status_config(k, v, s);
1528 }
1529
1530 static int run_rewrite_hook(const struct object_id *oldoid,
1531 const struct object_id *newoid)
1532 {
1533 struct child_process proc = CHILD_PROCESS_INIT;
1534 const char *argv[3];
1535 int code;
1536 struct strbuf sb = STRBUF_INIT;
1537
1538 argv[0] = find_hook("post-rewrite");
1539 if (!argv[0])
1540 return 0;
1541
1542 argv[1] = "amend";
1543 argv[2] = NULL;
1544
1545 proc.argv = argv;
1546 proc.in = -1;
1547 proc.stdout_to_stderr = 1;
1548
1549 code = start_command(&proc);
1550 if (code)
1551 return code;
1552 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1553 sigchain_push(SIGPIPE, SIG_IGN);
1554 write_in_full(proc.in, sb.buf, sb.len);
1555 close(proc.in);
1556 strbuf_release(&sb);
1557 sigchain_pop(SIGPIPE);
1558 return finish_command(&proc);
1559 }
1560
1561 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1562 {
1563 struct argv_array hook_env = ARGV_ARRAY_INIT;
1564 va_list args;
1565 int ret;
1566
1567 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1568
1569 /*
1570 * Let the hook know that no editor will be launched.
1571 */
1572 if (!editor_is_used)
1573 argv_array_push(&hook_env, "GIT_EDITOR=:");
1574
1575 va_start(args, name);
1576 ret = run_hook_ve(hook_env.argv,name, args);
1577 va_end(args);
1578 argv_array_clear(&hook_env);
1579
1580 return ret;
1581 }
1582
1583 int cmd_commit(int argc, const char **argv, const char *prefix)
1584 {
1585 static struct wt_status s;
1586 static struct option builtin_commit_options[] = {
1587 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1588 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1589
1590 OPT_GROUP(N_("Commit message options")),
1591 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1592 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1593 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1594 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1595 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1596 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1597 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1598 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1599 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1600 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1601 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1602 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1603 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1604 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1605 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1606 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1607 /* end commit message options */
1608
1609 OPT_GROUP(N_("Commit contents options")),
1610 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1611 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1612 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1613 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1614 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1615 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1616 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1617 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1618 STATUS_FORMAT_SHORT),
1619 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1620 OPT_SET_INT(0, "porcelain", &status_format,
1621 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1622 OPT_SET_INT(0, "long", &status_format,
1623 N_("show status in long format (default)"),
1624 STATUS_FORMAT_LONG),
1625 OPT_BOOL('z', "null", &s.null_termination,
1626 N_("terminate entries with NUL")),
1627 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1628 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1629 { 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" },
1630 /* end commit contents options */
1631
1632 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1633 N_("ok to record an empty change")),
1634 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1635 N_("ok to record a change with an empty message")),
1636
1637 OPT_END()
1638 };
1639
1640 struct strbuf sb = STRBUF_INIT;
1641 struct strbuf author_ident = STRBUF_INIT;
1642 const char *index_file, *reflog_msg;
1643 char *nl;
1644 struct object_id oid;
1645 struct commit_list *parents = NULL;
1646 struct stat statbuf;
1647 struct commit *current_head = NULL;
1648 struct commit_extra_header *extra = NULL;
1649 struct ref_transaction *transaction;
1650 struct strbuf err = STRBUF_INIT;
1651
1652 if (argc == 2 && !strcmp(argv[1], "-h"))
1653 usage_with_options(builtin_commit_usage, builtin_commit_options);
1654
1655 status_init_config(&s, git_commit_config);
1656 s.commit_template = 1;
1657 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1658 s.colopts = 0;
1659
1660 if (get_sha1("HEAD", oid.hash))
1661 current_head = NULL;
1662 else {
1663 current_head = lookup_commit_or_die(&oid, "HEAD");
1664 if (parse_commit(current_head))
1665 die(_("could not parse HEAD commit"));
1666 }
1667 verbose = -1; /* unspecified */
1668 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1669 builtin_commit_usage,
1670 prefix, current_head, &s);
1671 if (verbose == -1)
1672 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1673
1674 if (dry_run)
1675 return dry_run_commit(argc, argv, prefix, current_head, &s);
1676 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1677
1678 /* Set up everything for writing the commit object. This includes
1679 running hooks, writing the trees, and interacting with the user. */
1680 if (!prepare_to_commit(index_file, prefix,
1681 current_head, &s, &author_ident)) {
1682 rollback_index_files();
1683 return 1;
1684 }
1685
1686 /* Determine parents */
1687 reflog_msg = getenv("GIT_REFLOG_ACTION");
1688 if (!current_head) {
1689 if (!reflog_msg)
1690 reflog_msg = "commit (initial)";
1691 } else if (amend) {
1692 if (!reflog_msg)
1693 reflog_msg = "commit (amend)";
1694 parents = copy_commit_list(current_head->parents);
1695 } else if (whence == FROM_MERGE) {
1696 struct strbuf m = STRBUF_INIT;
1697 FILE *fp;
1698 int allow_fast_forward = 1;
1699 struct commit_list **pptr = &parents;
1700
1701 if (!reflog_msg)
1702 reflog_msg = "commit (merge)";
1703 pptr = commit_list_append(current_head, pptr);
1704 fp = xfopen(git_path_merge_head(), "r");
1705 while (strbuf_getline_lf(&m, fp) != EOF) {
1706 struct commit *parent;
1707
1708 parent = get_merge_parent(m.buf);
1709 if (!parent)
1710 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1711 pptr = commit_list_append(parent, pptr);
1712 }
1713 fclose(fp);
1714 strbuf_release(&m);
1715 if (!stat(git_path_merge_mode(), &statbuf)) {
1716 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1717 die_errno(_("could not read MERGE_MODE"));
1718 if (!strcmp(sb.buf, "no-ff"))
1719 allow_fast_forward = 0;
1720 }
1721 if (allow_fast_forward)
1722 parents = reduce_heads(parents);
1723 } else {
1724 if (!reflog_msg)
1725 reflog_msg = (whence == FROM_CHERRY_PICK)
1726 ? "commit (cherry-pick)"
1727 : "commit";
1728 commit_list_insert(current_head, &parents);
1729 }
1730
1731 /* Finally, get the commit message */
1732 strbuf_reset(&sb);
1733 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1734 int saved_errno = errno;
1735 rollback_index_files();
1736 die(_("could not read commit message: %s"), strerror(saved_errno));
1737 }
1738
1739 if (verbose || /* Truncate the message just before the diff, if any. */
1740 cleanup_mode == CLEANUP_SCISSORS)
1741 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
1742 if (cleanup_mode != CLEANUP_NONE)
1743 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1744
1745 if (message_is_empty(&sb) && !allow_empty_message) {
1746 rollback_index_files();
1747 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1748 exit(1);
1749 }
1750 if (template_untouched(&sb) && !allow_empty_message) {
1751 rollback_index_files();
1752 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1753 exit(1);
1754 }
1755
1756 if (amend) {
1757 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1758 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1759 } else {
1760 struct commit_extra_header **tail = &extra;
1761 append_merge_tag_headers(parents, &tail);
1762 }
1763
1764 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
1765 parents, oid.hash, author_ident.buf, sign_commit, extra)) {
1766 rollback_index_files();
1767 die(_("failed to write commit object"));
1768 }
1769 strbuf_release(&author_ident);
1770 free_commit_extra_headers(extra);
1771
1772 nl = strchr(sb.buf, '\n');
1773 if (nl)
1774 strbuf_setlen(&sb, nl + 1 - sb.buf);
1775 else
1776 strbuf_addch(&sb, '\n');
1777 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1778 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1779
1780 transaction = ref_transaction_begin(&err);
1781 if (!transaction ||
1782 ref_transaction_update(transaction, "HEAD", oid.hash,
1783 current_head
1784 ? current_head->object.oid.hash : null_sha1,
1785 0, sb.buf, &err) ||
1786 ref_transaction_commit(transaction, &err)) {
1787 rollback_index_files();
1788 die("%s", err.buf);
1789 }
1790 ref_transaction_free(transaction);
1791
1792 unlink(git_path_cherry_pick_head());
1793 unlink(git_path_revert_head());
1794 unlink(git_path_merge_head());
1795 unlink(git_path_merge_msg());
1796 unlink(git_path_merge_mode());
1797 unlink(git_path_squash_msg());
1798
1799 if (commit_index_files())
1800 die (_("Repository has been updated, but unable to write\n"
1801 "new_index file. Check that disk is not full and quota is\n"
1802 "not exceeded, and then \"git reset HEAD\" to recover."));
1803
1804 rerere(0);
1805 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1806 if (amend && !no_post_rewrite) {
1807 struct notes_rewrite_cfg *cfg;
1808 cfg = init_copy_notes_for_rewrite("amend");
1809 if (cfg) {
1810 /* we are amending, so current_head is not NULL */
1811 copy_note_for_rewrite(cfg, &current_head->object.oid, &oid);
1812 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1813 }
1814 run_rewrite_hook(&current_head->object.oid, &oid);
1815 }
1816 if (!quiet)
1817 print_summary(prefix, &oid, !current_head);
1818
1819 strbuf_release(&err);
1820 return 0;
1821 }