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