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