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