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