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