t5500 & t7403: lose bash-ism "local"
[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 (have_option_m) {
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 /*
730 * prepend SQUASH_MSG here if it exists and a
731 * "merge --squash" was originally performed
732 */
733 if (!stat(git_path_squash_msg(), &statbuf)) {
734 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
735 die_errno(_("could not read SQUASH_MSG"));
736 hook_arg1 = "squash";
737 } else
738 hook_arg1 = "merge";
739 if (strbuf_read_file(&sb, git_path_merge_msg(), 0) < 0)
740 die_errno(_("could not read MERGE_MSG"));
741 } else if (!stat(git_path_squash_msg(), &statbuf)) {
742 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
743 die_errno(_("could not read SQUASH_MSG"));
744 hook_arg1 = "squash";
745 } else if (template_file) {
746 if (strbuf_read_file(&sb, template_file, 0) < 0)
747 die_errno(_("could not read '%s'"), template_file);
748 hook_arg1 = "template";
749 clean_message_contents = 0;
750 }
751
752 /*
753 * The remaining cases don't modify the template message, but
754 * just set the argument(s) to the prepare-commit-msg hook.
755 */
756 else if (whence == FROM_MERGE)
757 hook_arg1 = "merge";
758 else if (whence == FROM_CHERRY_PICK) {
759 hook_arg1 = "commit";
760 hook_arg2 = "CHERRY_PICK_HEAD";
761 }
762
763 if (squash_message) {
764 /*
765 * If squash_commit was used for the commit subject,
766 * then we're possibly hijacking other commit log options.
767 * Reset the hook args to tell the real story.
768 */
769 hook_arg1 = "message";
770 hook_arg2 = "";
771 }
772
773 s->fp = fopen_for_writing(git_path(commit_editmsg));
774 if (s->fp == NULL)
775 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
776
777 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
778 old_display_comment_prefix = s->display_comment_prefix;
779 s->display_comment_prefix = 1;
780
781 /*
782 * Most hints are counter-productive when the commit has
783 * already started.
784 */
785 s->hints = 0;
786
787 if (clean_message_contents)
788 strbuf_stripspace(&sb, 0);
789
790 if (signoff)
791 append_signoff(&sb, ignore_non_trailer(&sb), 0);
792
793 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
794 die_errno(_("could not write commit template"));
795
796 if (auto_comment_line_char)
797 adjust_comment_line_char(&sb);
798 strbuf_release(&sb);
799
800 /* This checks if committer ident is explicitly given */
801 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
802 if (use_editor && include_status) {
803 int ident_shown = 0;
804 int saved_color_setting;
805 struct ident_split ci, ai;
806
807 if (whence != FROM_COMMIT) {
808 if (cleanup_mode == CLEANUP_SCISSORS)
809 wt_status_add_cut_line(s->fp);
810 status_printf_ln(s, GIT_COLOR_NORMAL,
811 whence == FROM_MERGE
812 ? _("\n"
813 "It looks like you may be committing a merge.\n"
814 "If this is not correct, please remove the file\n"
815 " %s\n"
816 "and try again.\n")
817 : _("\n"
818 "It looks like you may be committing a cherry-pick.\n"
819 "If this is not correct, please remove the file\n"
820 " %s\n"
821 "and try again.\n"),
822 git_path(whence == FROM_MERGE
823 ? "MERGE_HEAD"
824 : "CHERRY_PICK_HEAD"));
825 }
826
827 fprintf(s->fp, "\n");
828 if (cleanup_mode == CLEANUP_ALL)
829 status_printf(s, GIT_COLOR_NORMAL,
830 _("Please enter the commit message for your changes."
831 " Lines starting\nwith '%c' will be ignored, and an empty"
832 " message aborts the commit.\n"), comment_line_char);
833 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
834 wt_status_add_cut_line(s->fp);
835 else /* CLEANUP_SPACE, that is. */
836 status_printf(s, GIT_COLOR_NORMAL,
837 _("Please enter the commit message for your changes."
838 " Lines starting\n"
839 "with '%c' will be kept; you may remove them"
840 " yourself if you want to.\n"
841 "An empty message aborts the commit.\n"), comment_line_char);
842 if (only_include_assumed)
843 status_printf_ln(s, GIT_COLOR_NORMAL,
844 "%s", only_include_assumed);
845
846 /*
847 * These should never fail because they come from our own
848 * fmt_ident. They may fail the sane_ident test, but we know
849 * that the name and mail pointers will at least be valid,
850 * which is enough for our tests and printing here.
851 */
852 assert_split_ident(&ai, author_ident);
853 assert_split_ident(&ci, &committer_ident);
854
855 if (ident_cmp(&ai, &ci))
856 status_printf_ln(s, GIT_COLOR_NORMAL,
857 _("%s"
858 "Author: %.*s <%.*s>"),
859 ident_shown++ ? "" : "\n",
860 (int)(ai.name_end - ai.name_begin), ai.name_begin,
861 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
862
863 if (author_date_is_interesting())
864 status_printf_ln(s, GIT_COLOR_NORMAL,
865 _("%s"
866 "Date: %s"),
867 ident_shown++ ? "" : "\n",
868 show_ident_date(&ai, DATE_MODE(NORMAL)));
869
870 if (!committer_ident_sufficiently_given())
871 status_printf_ln(s, GIT_COLOR_NORMAL,
872 _("%s"
873 "Committer: %.*s <%.*s>"),
874 ident_shown++ ? "" : "\n",
875 (int)(ci.name_end - ci.name_begin), ci.name_begin,
876 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
877
878 if (ident_shown)
879 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
880
881 saved_color_setting = s->use_color;
882 s->use_color = 0;
883 commitable = run_status(s->fp, index_file, prefix, 1, s);
884 s->use_color = saved_color_setting;
885 } else {
886 unsigned char sha1[20];
887 const char *parent = "HEAD";
888
889 if (!active_nr && read_cache() < 0)
890 die(_("Cannot read index"));
891
892 if (amend)
893 parent = "HEAD^1";
894
895 if (get_sha1(parent, sha1))
896 commitable = !!active_nr;
897 else {
898 /*
899 * Unless the user did explicitly request a submodule
900 * ignore mode by passing a command line option we do
901 * not ignore any changed submodule SHA-1s when
902 * comparing index and parent, no matter what is
903 * configured. Otherwise we won't commit any
904 * submodules which were manually staged, which would
905 * be really confusing.
906 */
907 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
908 if (ignore_submodule_arg &&
909 !strcmp(ignore_submodule_arg, "all"))
910 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
911 commitable = index_differs_from(parent, diff_flags);
912 }
913 }
914 strbuf_release(&committer_ident);
915
916 fclose(s->fp);
917
918 /*
919 * Reject an attempt to record a non-merge empty commit without
920 * explicit --allow-empty. In the cherry-pick case, it may be
921 * empty due to conflict resolution, which the user should okay.
922 */
923 if (!commitable && whence != FROM_MERGE && !allow_empty &&
924 !(amend && is_a_merge(current_head))) {
925 s->display_comment_prefix = old_display_comment_prefix;
926 run_status(stdout, index_file, prefix, 0, s);
927 if (amend)
928 fputs(_(empty_amend_advice), stderr);
929 else if (whence == FROM_CHERRY_PICK) {
930 fputs(_(empty_cherry_pick_advice), stderr);
931 if (!sequencer_in_use)
932 fputs(_(empty_cherry_pick_advice_single), stderr);
933 else
934 fputs(_(empty_cherry_pick_advice_multi), stderr);
935 }
936 return 0;
937 }
938
939 /*
940 * Re-read the index as pre-commit hook could have updated it,
941 * and write it out as a tree. We must do this before we invoke
942 * the editor and after we invoke run_status above.
943 */
944 discard_cache();
945 read_cache_from(index_file);
946 if (update_main_cache_tree(0)) {
947 error(_("Error building trees"));
948 return 0;
949 }
950
951 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
952 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
953 return 0;
954
955 if (use_editor) {
956 char index[PATH_MAX];
957 const char *env[2] = { NULL };
958 env[0] = index;
959 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
960 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
961 fprintf(stderr,
962 _("Please supply the message using either -m or -F option.\n"));
963 exit(1);
964 }
965 }
966
967 if (!no_verify &&
968 run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
969 return 0;
970 }
971
972 return 1;
973 }
974
975 static int rest_is_empty(struct strbuf *sb, int start)
976 {
977 int i, eol;
978 const char *nl;
979
980 /* Check if the rest is just whitespace and Signed-of-by's. */
981 for (i = start; i < sb->len; i++) {
982 nl = memchr(sb->buf + i, '\n', sb->len - i);
983 if (nl)
984 eol = nl - sb->buf;
985 else
986 eol = sb->len;
987
988 if (strlen(sign_off_header) <= eol - i &&
989 starts_with(sb->buf + i, sign_off_header)) {
990 i = eol;
991 continue;
992 }
993 while (i < eol)
994 if (!isspace(sb->buf[i++]))
995 return 0;
996 }
997
998 return 1;
999 }
1000
1001 /*
1002 * Find out if the message in the strbuf contains only whitespace and
1003 * Signed-off-by lines.
1004 */
1005 static int message_is_empty(struct strbuf *sb)
1006 {
1007 if (cleanup_mode == CLEANUP_NONE && sb->len)
1008 return 0;
1009 return rest_is_empty(sb, 0);
1010 }
1011
1012 /*
1013 * See if the user edited the message in the editor or left what
1014 * was in the template intact
1015 */
1016 static int template_untouched(struct strbuf *sb)
1017 {
1018 struct strbuf tmpl = STRBUF_INIT;
1019 const char *start;
1020
1021 if (cleanup_mode == CLEANUP_NONE && sb->len)
1022 return 0;
1023
1024 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1025 return 0;
1026
1027 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1028 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1029 start = sb->buf;
1030 strbuf_release(&tmpl);
1031 return rest_is_empty(sb, start - sb->buf);
1032 }
1033
1034 static const char *find_author_by_nickname(const char *name)
1035 {
1036 struct rev_info revs;
1037 struct commit *commit;
1038 struct strbuf buf = STRBUF_INIT;
1039 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1040 const char *av[20];
1041 int ac = 0;
1042
1043 init_revisions(&revs, NULL);
1044 strbuf_addf(&buf, "--author=%s", name);
1045 av[++ac] = "--all";
1046 av[++ac] = "-i";
1047 av[++ac] = buf.buf;
1048 av[++ac] = NULL;
1049 setup_revisions(ac, av, &revs, NULL);
1050 revs.mailmap = &mailmap;
1051 read_mailmap(revs.mailmap, NULL);
1052
1053 if (prepare_revision_walk(&revs))
1054 die(_("revision walk setup failed"));
1055 commit = get_revision(&revs);
1056 if (commit) {
1057 struct pretty_print_context ctx = {0};
1058 ctx.date_mode.type = DATE_NORMAL;
1059 strbuf_release(&buf);
1060 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1061 clear_mailmap(&mailmap);
1062 return strbuf_detach(&buf, NULL);
1063 }
1064 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1065 }
1066
1067
1068 static void handle_untracked_files_arg(struct wt_status *s)
1069 {
1070 if (!untracked_files_arg)
1071 ; /* default already initialized */
1072 else if (!strcmp(untracked_files_arg, "no"))
1073 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1074 else if (!strcmp(untracked_files_arg, "normal"))
1075 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1076 else if (!strcmp(untracked_files_arg, "all"))
1077 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1078 else
1079 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1080 }
1081
1082 static const char *read_commit_message(const char *name)
1083 {
1084 const char *out_enc;
1085 struct commit *commit;
1086
1087 commit = lookup_commit_reference_by_name(name);
1088 if (!commit)
1089 die(_("could not lookup commit %s"), name);
1090 out_enc = get_commit_output_encoding();
1091 return logmsg_reencode(commit, NULL, out_enc);
1092 }
1093
1094 /*
1095 * Enumerate what needs to be propagated when --porcelain
1096 * is not in effect here.
1097 */
1098 static struct status_deferred_config {
1099 enum status_format status_format;
1100 int show_branch;
1101 } status_deferred_config = {
1102 STATUS_FORMAT_UNSPECIFIED,
1103 -1 /* unspecified */
1104 };
1105
1106 static void finalize_deferred_config(struct wt_status *s)
1107 {
1108 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1109 !s->null_termination);
1110
1111 if (s->null_termination) {
1112 if (status_format == STATUS_FORMAT_NONE ||
1113 status_format == STATUS_FORMAT_UNSPECIFIED)
1114 status_format = STATUS_FORMAT_PORCELAIN;
1115 else if (status_format == STATUS_FORMAT_LONG)
1116 die(_("--long and -z are incompatible"));
1117 }
1118
1119 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1120 status_format = status_deferred_config.status_format;
1121 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1122 status_format = STATUS_FORMAT_NONE;
1123
1124 if (use_deferred_config && s->show_branch < 0)
1125 s->show_branch = status_deferred_config.show_branch;
1126 if (s->show_branch < 0)
1127 s->show_branch = 0;
1128 }
1129
1130 static int parse_and_validate_options(int argc, const char *argv[],
1131 const struct option *options,
1132 const char * const usage[],
1133 const char *prefix,
1134 struct commit *current_head,
1135 struct wt_status *s)
1136 {
1137 int f = 0;
1138
1139 argc = parse_options(argc, argv, prefix, options, usage, 0);
1140 finalize_deferred_config(s);
1141
1142 if (force_author && !strchr(force_author, '>'))
1143 force_author = find_author_by_nickname(force_author);
1144
1145 if (force_author && renew_authorship)
1146 die(_("Using both --reset-author and --author does not make sense"));
1147
1148 if (logfile || have_option_m || use_message || fixup_message)
1149 use_editor = 0;
1150 if (0 <= edit_flag)
1151 use_editor = edit_flag;
1152
1153 /* Sanity check options */
1154 if (amend && !current_head)
1155 die(_("You have nothing to amend."));
1156 if (amend && whence != FROM_COMMIT) {
1157 if (whence == FROM_MERGE)
1158 die(_("You are in the middle of a merge -- cannot amend."));
1159 else if (whence == FROM_CHERRY_PICK)
1160 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1161 }
1162 if (fixup_message && squash_message)
1163 die(_("Options --squash and --fixup cannot be used together"));
1164 if (use_message)
1165 f++;
1166 if (edit_message)
1167 f++;
1168 if (fixup_message)
1169 f++;
1170 if (logfile)
1171 f++;
1172 if (f > 1)
1173 die(_("Only one of -c/-C/-F/--fixup can be used."));
1174 if (have_option_m && f > 0)
1175 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1176 if (f || have_option_m)
1177 template_file = NULL;
1178 if (edit_message)
1179 use_message = edit_message;
1180 if (amend && !use_message && !fixup_message)
1181 use_message = "HEAD";
1182 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1183 die(_("--reset-author can be used only with -C, -c or --amend."));
1184 if (use_message) {
1185 use_message_buffer = read_commit_message(use_message);
1186 if (!renew_authorship) {
1187 author_message = use_message;
1188 author_message_buffer = use_message_buffer;
1189 }
1190 }
1191 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1192 author_message = "CHERRY_PICK_HEAD";
1193 author_message_buffer = read_commit_message(author_message);
1194 }
1195
1196 if (patch_interactive)
1197 interactive = 1;
1198
1199 if (also + only + all + interactive > 1)
1200 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1201 if (argc == 0 && (also || (only && !amend)))
1202 die(_("No paths with --include/--only does not make sense."));
1203 if (argc == 0 && only && amend)
1204 only_include_assumed = _("Clever... amending the last one with dirty index.");
1205 if (argc > 0 && !also && !only)
1206 only_include_assumed = _("Explicit paths specified without -i or -o; assuming --only paths...");
1207 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1208 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1209 else if (!strcmp(cleanup_arg, "verbatim"))
1210 cleanup_mode = CLEANUP_NONE;
1211 else if (!strcmp(cleanup_arg, "whitespace"))
1212 cleanup_mode = CLEANUP_SPACE;
1213 else if (!strcmp(cleanup_arg, "strip"))
1214 cleanup_mode = CLEANUP_ALL;
1215 else if (!strcmp(cleanup_arg, "scissors"))
1216 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1217 else
1218 die(_("Invalid cleanup mode %s"), cleanup_arg);
1219
1220 handle_untracked_files_arg(s);
1221
1222 if (all && argc > 0)
1223 die(_("Paths with -a does not make sense."));
1224
1225 if (status_format != STATUS_FORMAT_NONE)
1226 dry_run = 1;
1227
1228 return argc;
1229 }
1230
1231 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1232 const struct commit *current_head, struct wt_status *s)
1233 {
1234 int commitable;
1235 const char *index_file;
1236
1237 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1238 commitable = run_status(stdout, index_file, prefix, 0, s);
1239 rollback_index_files();
1240
1241 return commitable ? 0 : 1;
1242 }
1243
1244 static int parse_status_slot(const char *slot)
1245 {
1246 if (!strcasecmp(slot, "header"))
1247 return WT_STATUS_HEADER;
1248 if (!strcasecmp(slot, "branch"))
1249 return WT_STATUS_ONBRANCH;
1250 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1251 return WT_STATUS_UPDATED;
1252 if (!strcasecmp(slot, "changed"))
1253 return WT_STATUS_CHANGED;
1254 if (!strcasecmp(slot, "untracked"))
1255 return WT_STATUS_UNTRACKED;
1256 if (!strcasecmp(slot, "nobranch"))
1257 return WT_STATUS_NOBRANCH;
1258 if (!strcasecmp(slot, "unmerged"))
1259 return WT_STATUS_UNMERGED;
1260 return -1;
1261 }
1262
1263 static int git_status_config(const char *k, const char *v, void *cb)
1264 {
1265 struct wt_status *s = cb;
1266 const char *slot_name;
1267
1268 if (starts_with(k, "column."))
1269 return git_column_config(k, v, "status", &s->colopts);
1270 if (!strcmp(k, "status.submodulesummary")) {
1271 int is_bool;
1272 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1273 if (is_bool && s->submodule_summary)
1274 s->submodule_summary = -1;
1275 return 0;
1276 }
1277 if (!strcmp(k, "status.short")) {
1278 if (git_config_bool(k, v))
1279 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1280 else
1281 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1282 return 0;
1283 }
1284 if (!strcmp(k, "status.branch")) {
1285 status_deferred_config.show_branch = git_config_bool(k, v);
1286 return 0;
1287 }
1288 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1289 s->use_color = git_config_colorbool(k, v);
1290 return 0;
1291 }
1292 if (!strcmp(k, "status.displaycommentprefix")) {
1293 s->display_comment_prefix = git_config_bool(k, v);
1294 return 0;
1295 }
1296 if (skip_prefix(k, "status.color.", &slot_name) ||
1297 skip_prefix(k, "color.status.", &slot_name)) {
1298 int slot = parse_status_slot(slot_name);
1299 if (slot < 0)
1300 return 0;
1301 if (!v)
1302 return config_error_nonbool(k);
1303 return color_parse(v, s->color_palette[slot]);
1304 }
1305 if (!strcmp(k, "status.relativepaths")) {
1306 s->relative_paths = git_config_bool(k, v);
1307 return 0;
1308 }
1309 if (!strcmp(k, "status.showuntrackedfiles")) {
1310 if (!v)
1311 return config_error_nonbool(k);
1312 else if (!strcmp(v, "no"))
1313 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1314 else if (!strcmp(v, "normal"))
1315 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1316 else if (!strcmp(v, "all"))
1317 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1318 else
1319 return error(_("Invalid untracked files mode '%s'"), v);
1320 return 0;
1321 }
1322 return git_diff_ui_config(k, v, NULL);
1323 }
1324
1325 int cmd_status(int argc, const char **argv, const char *prefix)
1326 {
1327 static struct wt_status s;
1328 int fd;
1329 unsigned char sha1[20];
1330 static struct option builtin_status_options[] = {
1331 OPT__VERBOSE(&verbose, N_("be verbose")),
1332 OPT_SET_INT('s', "short", &status_format,
1333 N_("show status concisely"), STATUS_FORMAT_SHORT),
1334 OPT_BOOL('b', "branch", &s.show_branch,
1335 N_("show branch information")),
1336 OPT_SET_INT(0, "porcelain", &status_format,
1337 N_("machine-readable output"),
1338 STATUS_FORMAT_PORCELAIN),
1339 OPT_SET_INT(0, "long", &status_format,
1340 N_("show status in long format (default)"),
1341 STATUS_FORMAT_LONG),
1342 OPT_BOOL('z', "null", &s.null_termination,
1343 N_("terminate entries with NUL")),
1344 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1345 N_("mode"),
1346 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1347 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1348 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1349 N_("show ignored files")),
1350 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1351 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1352 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1353 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1354 OPT_END(),
1355 };
1356
1357 if (argc == 2 && !strcmp(argv[1], "-h"))
1358 usage_with_options(builtin_status_usage, builtin_status_options);
1359
1360 status_init_config(&s, git_status_config);
1361 argc = parse_options(argc, argv, prefix,
1362 builtin_status_options,
1363 builtin_status_usage, 0);
1364 finalize_colopts(&s.colopts, -1);
1365 finalize_deferred_config(&s);
1366
1367 handle_untracked_files_arg(&s);
1368 if (show_ignored_in_status)
1369 s.show_ignored_files = 1;
1370 parse_pathspec(&s.pathspec, 0,
1371 PATHSPEC_PREFER_FULL,
1372 prefix, argv);
1373
1374 read_cache_preload(&s.pathspec);
1375 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1376
1377 fd = hold_locked_index(&index_lock, 0);
1378
1379 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1380 s.ignore_submodule_arg = ignore_submodule_arg;
1381 wt_status_collect(&s);
1382
1383 if (0 <= fd)
1384 update_index_if_able(&the_index, &index_lock);
1385
1386 if (s.relative_paths)
1387 s.prefix = prefix;
1388
1389 switch (status_format) {
1390 case STATUS_FORMAT_SHORT:
1391 wt_shortstatus_print(&s);
1392 break;
1393 case STATUS_FORMAT_PORCELAIN:
1394 wt_porcelain_print(&s);
1395 break;
1396 case STATUS_FORMAT_UNSPECIFIED:
1397 die("BUG: finalize_deferred_config() should have been called");
1398 break;
1399 case STATUS_FORMAT_NONE:
1400 case STATUS_FORMAT_LONG:
1401 s.verbose = verbose;
1402 s.ignore_submodule_arg = ignore_submodule_arg;
1403 wt_status_print(&s);
1404 break;
1405 }
1406 return 0;
1407 }
1408
1409 static const char *implicit_ident_advice(void)
1410 {
1411 char *user_config = expand_user_path("~/.gitconfig");
1412 char *xdg_config = xdg_config_home("config");
1413 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1414
1415 free(user_config);
1416 free(xdg_config);
1417
1418 if (config_exists)
1419 return _(implicit_ident_advice_config);
1420 else
1421 return _(implicit_ident_advice_noconfig);
1422
1423 }
1424
1425 static void print_summary(const char *prefix, const unsigned char *sha1,
1426 int initial_commit)
1427 {
1428 struct rev_info rev;
1429 struct commit *commit;
1430 struct strbuf format = STRBUF_INIT;
1431 unsigned char junk_sha1[20];
1432 const char *head;
1433 struct pretty_print_context pctx = {0};
1434 struct strbuf author_ident = STRBUF_INIT;
1435 struct strbuf committer_ident = STRBUF_INIT;
1436
1437 commit = lookup_commit(sha1);
1438 if (!commit)
1439 die(_("couldn't look up newly created commit"));
1440 if (parse_commit(commit))
1441 die(_("could not parse newly created commit"));
1442
1443 strbuf_addstr(&format, "format:%h] %s");
1444
1445 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1446 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1447 if (strbuf_cmp(&author_ident, &committer_ident)) {
1448 strbuf_addstr(&format, "\n Author: ");
1449 strbuf_addbuf_percentquote(&format, &author_ident);
1450 }
1451 if (author_date_is_interesting()) {
1452 struct strbuf date = STRBUF_INIT;
1453 format_commit_message(commit, "%ad", &date, &pctx);
1454 strbuf_addstr(&format, "\n Date: ");
1455 strbuf_addbuf_percentquote(&format, &date);
1456 strbuf_release(&date);
1457 }
1458 if (!committer_ident_sufficiently_given()) {
1459 strbuf_addstr(&format, "\n Committer: ");
1460 strbuf_addbuf_percentquote(&format, &committer_ident);
1461 if (advice_implicit_identity) {
1462 strbuf_addch(&format, '\n');
1463 strbuf_addstr(&format, implicit_ident_advice());
1464 }
1465 }
1466 strbuf_release(&author_ident);
1467 strbuf_release(&committer_ident);
1468
1469 init_revisions(&rev, prefix);
1470 setup_revisions(0, NULL, &rev, NULL);
1471
1472 rev.diff = 1;
1473 rev.diffopt.output_format =
1474 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1475
1476 rev.verbose_header = 1;
1477 rev.show_root_diff = 1;
1478 get_commit_format(format.buf, &rev);
1479 rev.always_show_header = 0;
1480 rev.diffopt.detect_rename = 1;
1481 rev.diffopt.break_opt = 0;
1482 diff_setup_done(&rev.diffopt);
1483
1484 head = resolve_ref_unsafe("HEAD", 0, junk_sha1, NULL);
1485 if (!strcmp(head, "HEAD"))
1486 head = _("detached HEAD");
1487 else
1488 skip_prefix(head, "refs/heads/", &head);
1489 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1490
1491 if (!log_tree_commit(&rev, commit)) {
1492 rev.always_show_header = 1;
1493 rev.use_terminator = 1;
1494 log_tree_commit(&rev, commit);
1495 }
1496
1497 strbuf_release(&format);
1498 }
1499
1500 static int git_commit_config(const char *k, const char *v, void *cb)
1501 {
1502 struct wt_status *s = cb;
1503 int status;
1504
1505 if (!strcmp(k, "commit.template"))
1506 return git_config_pathname(&template_file, k, v);
1507 if (!strcmp(k, "commit.status")) {
1508 include_status = git_config_bool(k, v);
1509 return 0;
1510 }
1511 if (!strcmp(k, "commit.cleanup"))
1512 return git_config_string(&cleanup_arg, k, v);
1513 if (!strcmp(k, "commit.gpgsign")) {
1514 sign_commit = git_config_bool(k, v) ? "" : NULL;
1515 return 0;
1516 }
1517
1518 status = git_gpg_config(k, v, NULL);
1519 if (status)
1520 return status;
1521 return git_status_config(k, v, s);
1522 }
1523
1524 static int run_rewrite_hook(const unsigned char *oldsha1,
1525 const unsigned char *newsha1)
1526 {
1527 /* oldsha1 SP newsha1 LF NUL */
1528 static char buf[2*40 + 3];
1529 struct child_process proc = CHILD_PROCESS_INIT;
1530 const char *argv[3];
1531 int code;
1532 size_t n;
1533
1534 argv[0] = find_hook("post-rewrite");
1535 if (!argv[0])
1536 return 0;
1537
1538 argv[1] = "amend";
1539 argv[2] = NULL;
1540
1541 proc.argv = argv;
1542 proc.in = -1;
1543 proc.stdout_to_stderr = 1;
1544
1545 code = start_command(&proc);
1546 if (code)
1547 return code;
1548 n = snprintf(buf, sizeof(buf), "%s %s\n",
1549 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1550 sigchain_push(SIGPIPE, SIG_IGN);
1551 write_in_full(proc.in, buf, n);
1552 close(proc.in);
1553 sigchain_pop(SIGPIPE);
1554 return finish_command(&proc);
1555 }
1556
1557 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1558 {
1559 const char *hook_env[3] = { NULL };
1560 char index[PATH_MAX];
1561 va_list args;
1562 int ret;
1563
1564 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1565 hook_env[0] = index;
1566
1567 /*
1568 * Let the hook know that no editor will be launched.
1569 */
1570 if (!editor_is_used)
1571 hook_env[1] = "GIT_EDITOR=:";
1572
1573 va_start(args, name);
1574 ret = run_hook_ve(hook_env, name, args);
1575 va_end(args);
1576
1577 return ret;
1578 }
1579
1580 int cmd_commit(int argc, const char **argv, const char *prefix)
1581 {
1582 static struct wt_status s;
1583 static struct option builtin_commit_options[] = {
1584 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1585 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1586
1587 OPT_GROUP(N_("Commit message options")),
1588 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1589 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1590 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1591 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1592 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1593 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1594 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1595 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1596 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1597 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1598 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1599 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1600 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1601 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1602 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1603 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1604 /* end commit message options */
1605
1606 OPT_GROUP(N_("Commit contents options")),
1607 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1608 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1609 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1610 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1611 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1612 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1613 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1614 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1615 STATUS_FORMAT_SHORT),
1616 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1617 OPT_SET_INT(0, "porcelain", &status_format,
1618 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1619 OPT_SET_INT(0, "long", &status_format,
1620 N_("show status in long format (default)"),
1621 STATUS_FORMAT_LONG),
1622 OPT_BOOL('z', "null", &s.null_termination,
1623 N_("terminate entries with NUL")),
1624 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1625 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1626 { 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" },
1627 /* end commit contents options */
1628
1629 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1630 N_("ok to record an empty change")),
1631 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1632 N_("ok to record a change with an empty message")),
1633
1634 OPT_END()
1635 };
1636
1637 struct strbuf sb = STRBUF_INIT;
1638 struct strbuf author_ident = STRBUF_INIT;
1639 const char *index_file, *reflog_msg;
1640 char *nl;
1641 unsigned char sha1[20];
1642 struct commit_list *parents = NULL, **pptr = &parents;
1643 struct stat statbuf;
1644 struct commit *current_head = NULL;
1645 struct commit_extra_header *extra = NULL;
1646 struct ref_transaction *transaction;
1647 struct strbuf err = STRBUF_INIT;
1648
1649 if (argc == 2 && !strcmp(argv[1], "-h"))
1650 usage_with_options(builtin_commit_usage, builtin_commit_options);
1651
1652 status_init_config(&s, git_commit_config);
1653 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1654 s.colopts = 0;
1655
1656 if (get_sha1("HEAD", sha1))
1657 current_head = NULL;
1658 else {
1659 current_head = lookup_commit_or_die(sha1, "HEAD");
1660 if (parse_commit(current_head))
1661 die(_("could not parse HEAD commit"));
1662 }
1663 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1664 builtin_commit_usage,
1665 prefix, current_head, &s);
1666 if (dry_run)
1667 return dry_run_commit(argc, argv, prefix, current_head, &s);
1668 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1669
1670 /* Set up everything for writing the commit object. This includes
1671 running hooks, writing the trees, and interacting with the user. */
1672 if (!prepare_to_commit(index_file, prefix,
1673 current_head, &s, &author_ident)) {
1674 rollback_index_files();
1675 return 1;
1676 }
1677
1678 /* Determine parents */
1679 reflog_msg = getenv("GIT_REFLOG_ACTION");
1680 if (!current_head) {
1681 if (!reflog_msg)
1682 reflog_msg = "commit (initial)";
1683 } else if (amend) {
1684 struct commit_list *c;
1685
1686 if (!reflog_msg)
1687 reflog_msg = "commit (amend)";
1688 for (c = current_head->parents; c; c = c->next)
1689 pptr = &commit_list_insert(c->item, pptr)->next;
1690 } else if (whence == FROM_MERGE) {
1691 struct strbuf m = STRBUF_INIT;
1692 FILE *fp;
1693 int allow_fast_forward = 1;
1694
1695 if (!reflog_msg)
1696 reflog_msg = "commit (merge)";
1697 pptr = &commit_list_insert(current_head, pptr)->next;
1698 fp = fopen(git_path_merge_head(), "r");
1699 if (fp == NULL)
1700 die_errno(_("could not open '%s' for reading"),
1701 git_path_merge_head());
1702 while (strbuf_getline_lf(&m, fp) != EOF) {
1703 struct commit *parent;
1704
1705 parent = get_merge_parent(m.buf);
1706 if (!parent)
1707 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1708 pptr = &commit_list_insert(parent, pptr)->next;
1709 }
1710 fclose(fp);
1711 strbuf_release(&m);
1712 if (!stat(git_path_merge_mode(), &statbuf)) {
1713 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1714 die_errno(_("could not read MERGE_MODE"));
1715 if (!strcmp(sb.buf, "no-ff"))
1716 allow_fast_forward = 0;
1717 }
1718 if (allow_fast_forward)
1719 parents = reduce_heads(parents);
1720 } else {
1721 if (!reflog_msg)
1722 reflog_msg = (whence == FROM_CHERRY_PICK)
1723 ? "commit (cherry-pick)"
1724 : "commit";
1725 pptr = &commit_list_insert(current_head, pptr)->next;
1726 }
1727
1728 /* Finally, get the commit message */
1729 strbuf_reset(&sb);
1730 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1731 int saved_errno = errno;
1732 rollback_index_files();
1733 die(_("could not read commit message: %s"), strerror(saved_errno));
1734 }
1735
1736 if (verbose || /* Truncate the message just before the diff, if any. */
1737 cleanup_mode == CLEANUP_SCISSORS)
1738 wt_status_truncate_message_at_cut_line(&sb);
1739
1740 if (cleanup_mode != CLEANUP_NONE)
1741 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1742 if (template_untouched(&sb) && !allow_empty_message) {
1743 rollback_index_files();
1744 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1745 exit(1);
1746 }
1747 if (message_is_empty(&sb) && !allow_empty_message) {
1748 rollback_index_files();
1749 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1750 exit(1);
1751 }
1752
1753 if (amend) {
1754 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1755 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1756 } else {
1757 struct commit_extra_header **tail = &extra;
1758 append_merge_tag_headers(parents, &tail);
1759 }
1760
1761 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->sha1,
1762 parents, sha1, author_ident.buf, sign_commit, extra)) {
1763 rollback_index_files();
1764 die(_("failed to write commit object"));
1765 }
1766 strbuf_release(&author_ident);
1767 free_commit_extra_headers(extra);
1768
1769 nl = strchr(sb.buf, '\n');
1770 if (nl)
1771 strbuf_setlen(&sb, nl + 1 - sb.buf);
1772 else
1773 strbuf_addch(&sb, '\n');
1774 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1775 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1776
1777 transaction = ref_transaction_begin(&err);
1778 if (!transaction ||
1779 ref_transaction_update(transaction, "HEAD", sha1,
1780 current_head
1781 ? current_head->object.oid.hash : null_sha1,
1782 0, sb.buf, &err) ||
1783 ref_transaction_commit(transaction, &err)) {
1784 rollback_index_files();
1785 die("%s", err.buf);
1786 }
1787 ref_transaction_free(transaction);
1788
1789 unlink(git_path_cherry_pick_head());
1790 unlink(git_path_revert_head());
1791 unlink(git_path_merge_head());
1792 unlink(git_path_merge_msg());
1793 unlink(git_path_merge_mode());
1794 unlink(git_path_squash_msg());
1795
1796 if (commit_index_files())
1797 die (_("Repository has been updated, but unable to write\n"
1798 "new_index file. Check that disk is not full and quota is\n"
1799 "not exceeded, and then \"git reset HEAD\" to recover."));
1800
1801 rerere(0);
1802 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1803 if (amend && !no_post_rewrite) {
1804 struct notes_rewrite_cfg *cfg;
1805 cfg = init_copy_notes_for_rewrite("amend");
1806 if (cfg) {
1807 /* we are amending, so current_head is not NULL */
1808 copy_note_for_rewrite(cfg, current_head->object.oid.hash, sha1);
1809 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1810 }
1811 run_rewrite_hook(current_head->object.oid.hash, sha1);
1812 }
1813 if (!quiet)
1814 print_summary(prefix, sha1, !current_head);
1815
1816 strbuf_release(&err);
1817 return 0;
1818 }