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