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