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