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