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