status: refactor colopts handling
[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,
530 IDENT_ERROR_ON_NO_NAME));
531 if (!split_ident_line(&author, author_ident->buf, author_ident->len)) {
532 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
533 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
534 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
535 }
536 }
537
538 static int ends_rfc2822_footer(struct strbuf *sb)
539 {
540 int ch;
541 int hit = 0;
542 int i, j, k;
543 int len = sb->len;
544 int first = 1;
545 const char *buf = sb->buf;
546
547 for (i = len - 1; i > 0; i--) {
548 if (hit && buf[i] == '\n')
549 break;
550 hit = (buf[i] == '\n');
551 }
552
553 while (i < len - 1 && buf[i] == '\n')
554 i++;
555
556 for (; i < len; i = k) {
557 for (k = i; k < len && buf[k] != '\n'; k++)
558 ; /* do nothing */
559 k++;
560
561 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
562 continue;
563
564 first = 0;
565
566 for (j = 0; i + j < len; j++) {
567 ch = buf[i + j];
568 if (ch == ':')
569 break;
570 if (isalnum(ch) ||
571 (ch == '-'))
572 continue;
573 return 0;
574 }
575 }
576 return 1;
577 }
578
579 static char *cut_ident_timestamp_part(char *string)
580 {
581 char *ket = strrchr(string, '>');
582 if (!ket || ket[1] != ' ')
583 die(_("Malformed ident string: '%s'"), string);
584 *++ket = '\0';
585 return ket;
586 }
587
588 static int prepare_to_commit(const char *index_file, const char *prefix,
589 struct commit *current_head,
590 struct wt_status *s,
591 struct strbuf *author_ident)
592 {
593 struct stat statbuf;
594 struct strbuf committer_ident = STRBUF_INIT;
595 int commitable, saved_color_setting;
596 struct strbuf sb = STRBUF_INIT;
597 char *buffer;
598 const char *hook_arg1 = NULL;
599 const char *hook_arg2 = NULL;
600 int ident_shown = 0;
601 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
602
603 /* This checks and barfs if author is badly specified */
604 determine_author_info(author_ident);
605
606 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
607 return 0;
608
609 if (squash_message) {
610 /*
611 * Insert the proper subject line before other commit
612 * message options add their content.
613 */
614 if (use_message && !strcmp(use_message, squash_message))
615 strbuf_addstr(&sb, "squash! ");
616 else {
617 struct pretty_print_context ctx = {0};
618 struct commit *c;
619 c = lookup_commit_reference_by_name(squash_message);
620 if (!c)
621 die(_("could not lookup commit %s"), squash_message);
622 ctx.output_encoding = get_commit_output_encoding();
623 format_commit_message(c, "squash! %s\n\n", &sb,
624 &ctx);
625 }
626 }
627
628 if (message.len) {
629 strbuf_addbuf(&sb, &message);
630 hook_arg1 = "message";
631 } else if (logfile && !strcmp(logfile, "-")) {
632 if (isatty(0))
633 fprintf(stderr, _("(reading log message from standard input)\n"));
634 if (strbuf_read(&sb, 0, 0) < 0)
635 die_errno(_("could not read log from standard input"));
636 hook_arg1 = "message";
637 } else if (logfile) {
638 if (strbuf_read_file(&sb, logfile, 0) < 0)
639 die_errno(_("could not read log file '%s'"),
640 logfile);
641 hook_arg1 = "message";
642 } else if (use_message) {
643 buffer = strstr(use_message_buffer, "\n\n");
644 if (!buffer || buffer[2] == '\0')
645 die(_("commit has empty message"));
646 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
647 hook_arg1 = "commit";
648 hook_arg2 = use_message;
649 } else if (fixup_message) {
650 struct pretty_print_context ctx = {0};
651 struct commit *commit;
652 commit = lookup_commit_reference_by_name(fixup_message);
653 if (!commit)
654 die(_("could not lookup commit %s"), fixup_message);
655 ctx.output_encoding = get_commit_output_encoding();
656 format_commit_message(commit, "fixup! %s\n\n",
657 &sb, &ctx);
658 hook_arg1 = "message";
659 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
660 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
661 die_errno(_("could not read MERGE_MSG"));
662 hook_arg1 = "merge";
663 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
664 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
665 die_errno(_("could not read SQUASH_MSG"));
666 hook_arg1 = "squash";
667 } else if (template_file) {
668 if (strbuf_read_file(&sb, template_file, 0) < 0)
669 die_errno(_("could not read '%s'"), template_file);
670 hook_arg1 = "template";
671 clean_message_contents = 0;
672 }
673
674 /*
675 * The remaining cases don't modify the template message, but
676 * just set the argument(s) to the prepare-commit-msg hook.
677 */
678 else if (whence == FROM_MERGE)
679 hook_arg1 = "merge";
680 else if (whence == FROM_CHERRY_PICK) {
681 hook_arg1 = "commit";
682 hook_arg2 = "CHERRY_PICK_HEAD";
683 }
684
685 if (squash_message) {
686 /*
687 * If squash_commit was used for the commit subject,
688 * then we're possibly hijacking other commit log options.
689 * Reset the hook args to tell the real story.
690 */
691 hook_arg1 = "message";
692 hook_arg2 = "";
693 }
694
695 s->fp = fopen(git_path(commit_editmsg), "w");
696 if (s->fp == NULL)
697 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
698
699 if (clean_message_contents)
700 stripspace(&sb, 0);
701
702 if (signoff) {
703 struct strbuf sob = STRBUF_INIT;
704 int i;
705
706 strbuf_addstr(&sob, sign_off_header);
707 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
708 getenv("GIT_COMMITTER_EMAIL")));
709 strbuf_addch(&sob, '\n');
710 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
711 ; /* do nothing */
712 if (prefixcmp(sb.buf + i, sob.buf)) {
713 if (!i || !ends_rfc2822_footer(&sb))
714 strbuf_addch(&sb, '\n');
715 strbuf_addbuf(&sb, &sob);
716 }
717 strbuf_release(&sob);
718 }
719
720 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
721 die_errno(_("could not write commit template"));
722
723 strbuf_release(&sb);
724
725 /* This checks if committer ident is explicitly given */
726 strbuf_addstr(&committer_ident, git_committer_info(0));
727 if (use_editor && include_status) {
728 char *ai_tmp, *ci_tmp;
729 if (whence != FROM_COMMIT)
730 status_printf_ln(s, GIT_COLOR_NORMAL,
731 whence == FROM_MERGE
732 ? _("\n"
733 "It looks like you may be committing a merge.\n"
734 "If this is not correct, please remove the file\n"
735 " %s\n"
736 "and try again.\n")
737 : _("\n"
738 "It looks like you may be committing a cherry-pick.\n"
739 "If this is not correct, please remove the file\n"
740 " %s\n"
741 "and try again.\n"),
742 git_path(whence == FROM_MERGE
743 ? "MERGE_HEAD"
744 : "CHERRY_PICK_HEAD"));
745
746 fprintf(s->fp, "\n");
747 if (cleanup_mode == CLEANUP_ALL)
748 status_printf(s, GIT_COLOR_NORMAL,
749 _("Please enter the commit message for your changes."
750 " Lines starting\nwith '#' will be ignored, and an empty"
751 " message aborts the commit.\n"));
752 else /* CLEANUP_SPACE, that is. */
753 status_printf(s, GIT_COLOR_NORMAL,
754 _("Please enter the commit message for your changes."
755 " Lines starting\n"
756 "with '#' will be kept; you may remove them"
757 " yourself if you want to.\n"
758 "An empty message aborts the commit.\n"));
759 if (only_include_assumed)
760 status_printf_ln(s, GIT_COLOR_NORMAL,
761 "%s", only_include_assumed);
762
763 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
764 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
765 if (strcmp(author_ident->buf, committer_ident.buf))
766 status_printf_ln(s, GIT_COLOR_NORMAL,
767 _("%s"
768 "Author: %s"),
769 ident_shown++ ? "" : "\n",
770 author_ident->buf);
771
772 if (!user_ident_sufficiently_given())
773 status_printf_ln(s, GIT_COLOR_NORMAL,
774 _("%s"
775 "Committer: %s"),
776 ident_shown++ ? "" : "\n",
777 committer_ident.buf);
778
779 if (ident_shown)
780 status_printf_ln(s, GIT_COLOR_NORMAL, "");
781
782 saved_color_setting = s->use_color;
783 s->use_color = 0;
784 commitable = run_status(s->fp, index_file, prefix, 1, s);
785 s->use_color = saved_color_setting;
786
787 *ai_tmp = ' ';
788 *ci_tmp = ' ';
789 } else {
790 unsigned char sha1[20];
791 const char *parent = "HEAD";
792
793 if (!active_nr && read_cache() < 0)
794 die(_("Cannot read index"));
795
796 if (amend)
797 parent = "HEAD^1";
798
799 if (get_sha1(parent, sha1))
800 commitable = !!active_nr;
801 else
802 commitable = index_differs_from(parent, 0);
803 }
804 strbuf_release(&committer_ident);
805
806 fclose(s->fp);
807
808 /*
809 * Reject an attempt to record a non-merge empty commit without
810 * explicit --allow-empty. In the cherry-pick case, it may be
811 * empty due to conflict resolution, which the user should okay.
812 */
813 if (!commitable && whence != FROM_MERGE && !allow_empty &&
814 !(amend && is_a_merge(current_head))) {
815 run_status(stdout, index_file, prefix, 0, s);
816 if (amend)
817 fputs(_(empty_amend_advice), stderr);
818 else if (whence == FROM_CHERRY_PICK)
819 fputs(_(empty_cherry_pick_advice), stderr);
820 return 0;
821 }
822
823 /*
824 * Re-read the index as pre-commit hook could have updated it,
825 * and write it out as a tree. We must do this before we invoke
826 * the editor and after we invoke run_status above.
827 */
828 discard_cache();
829 read_cache_from(index_file);
830 if (update_main_cache_tree(0)) {
831 error(_("Error building trees"));
832 return 0;
833 }
834
835 if (run_hook(index_file, "prepare-commit-msg",
836 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
837 return 0;
838
839 if (use_editor) {
840 char index[PATH_MAX];
841 const char *env[2] = { NULL };
842 env[0] = index;
843 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
844 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
845 fprintf(stderr,
846 _("Please supply the message using either -m or -F option.\n"));
847 exit(1);
848 }
849 }
850
851 if (!no_verify &&
852 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
853 return 0;
854 }
855
856 return 1;
857 }
858
859 static int rest_is_empty(struct strbuf *sb, int start)
860 {
861 int i, eol;
862 const char *nl;
863
864 /* Check if the rest is just whitespace and Signed-of-by's. */
865 for (i = start; i < sb->len; i++) {
866 nl = memchr(sb->buf + i, '\n', sb->len - i);
867 if (nl)
868 eol = nl - sb->buf;
869 else
870 eol = sb->len;
871
872 if (strlen(sign_off_header) <= eol - i &&
873 !prefixcmp(sb->buf + i, sign_off_header)) {
874 i = eol;
875 continue;
876 }
877 while (i < eol)
878 if (!isspace(sb->buf[i++]))
879 return 0;
880 }
881
882 return 1;
883 }
884
885 /*
886 * Find out if the message in the strbuf contains only whitespace and
887 * Signed-off-by lines.
888 */
889 static int message_is_empty(struct strbuf *sb)
890 {
891 if (cleanup_mode == CLEANUP_NONE && sb->len)
892 return 0;
893 return rest_is_empty(sb, 0);
894 }
895
896 /*
897 * See if the user edited the message in the editor or left what
898 * was in the template intact
899 */
900 static int template_untouched(struct strbuf *sb)
901 {
902 struct strbuf tmpl = STRBUF_INIT;
903 char *start;
904
905 if (cleanup_mode == CLEANUP_NONE && sb->len)
906 return 0;
907
908 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
909 return 0;
910
911 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
912 start = (char *)skip_prefix(sb->buf, tmpl.buf);
913 if (!start)
914 start = sb->buf;
915 strbuf_release(&tmpl);
916 return rest_is_empty(sb, start - sb->buf);
917 }
918
919 static const char *find_author_by_nickname(const char *name)
920 {
921 struct rev_info revs;
922 struct commit *commit;
923 struct strbuf buf = STRBUF_INIT;
924 const char *av[20];
925 int ac = 0;
926
927 init_revisions(&revs, NULL);
928 strbuf_addf(&buf, "--author=%s", name);
929 av[++ac] = "--all";
930 av[++ac] = "-i";
931 av[++ac] = buf.buf;
932 av[++ac] = NULL;
933 setup_revisions(ac, av, &revs, NULL);
934 prepare_revision_walk(&revs);
935 commit = get_revision(&revs);
936 if (commit) {
937 struct pretty_print_context ctx = {0};
938 ctx.date_mode = DATE_NORMAL;
939 strbuf_release(&buf);
940 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
941 return strbuf_detach(&buf, NULL);
942 }
943 die(_("No existing author found with '%s'"), name);
944 }
945
946
947 static void handle_untracked_files_arg(struct wt_status *s)
948 {
949 if (!untracked_files_arg)
950 ; /* default already initialized */
951 else if (!strcmp(untracked_files_arg, "no"))
952 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
953 else if (!strcmp(untracked_files_arg, "normal"))
954 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
955 else if (!strcmp(untracked_files_arg, "all"))
956 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
957 else
958 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
959 }
960
961 static const char *read_commit_message(const char *name)
962 {
963 const char *out_enc, *out;
964 struct commit *commit;
965
966 commit = lookup_commit_reference_by_name(name);
967 if (!commit)
968 die(_("could not lookup commit %s"), name);
969 out_enc = get_commit_output_encoding();
970 out = logmsg_reencode(commit, out_enc);
971
972 /*
973 * If we failed to reencode the buffer, just copy it
974 * byte for byte so the user can try to fix it up.
975 * This also handles the case where input and output
976 * encodings are identical.
977 */
978 if (out == NULL)
979 out = xstrdup(commit->buffer);
980 return out;
981 }
982
983 static int parse_and_validate_options(int argc, const char *argv[],
984 const struct option *options,
985 const char * const usage[],
986 const char *prefix,
987 struct commit *current_head,
988 struct wt_status *s)
989 {
990 int f = 0;
991
992 argc = parse_options(argc, argv, prefix, options, usage, 0);
993
994 if (force_author && !strchr(force_author, '>'))
995 force_author = find_author_by_nickname(force_author);
996
997 if (force_author && renew_authorship)
998 die(_("Using both --reset-author and --author does not make sense"));
999
1000 if (logfile || message.len || use_message || fixup_message)
1001 use_editor = 0;
1002 if (0 <= edit_flag)
1003 use_editor = edit_flag;
1004 if (!use_editor)
1005 setenv("GIT_EDITOR", ":", 1);
1006
1007 /* Sanity check options */
1008 if (amend && !current_head)
1009 die(_("You have nothing to amend."));
1010 if (amend && whence != FROM_COMMIT) {
1011 if (whence == FROM_MERGE)
1012 die(_("You are in the middle of a merge -- cannot amend."));
1013 else if (whence == FROM_CHERRY_PICK)
1014 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1015 }
1016 if (fixup_message && squash_message)
1017 die(_("Options --squash and --fixup cannot be used together"));
1018 if (use_message)
1019 f++;
1020 if (edit_message)
1021 f++;
1022 if (fixup_message)
1023 f++;
1024 if (logfile)
1025 f++;
1026 if (f > 1)
1027 die(_("Only one of -c/-C/-F/--fixup can be used."));
1028 if (message.len && f > 0)
1029 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1030 if (f || message.len)
1031 template_file = NULL;
1032 if (edit_message)
1033 use_message = edit_message;
1034 if (amend && !use_message && !fixup_message)
1035 use_message = "HEAD";
1036 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1037 die(_("--reset-author can be used only with -C, -c or --amend."));
1038 if (use_message) {
1039 use_message_buffer = read_commit_message(use_message);
1040 if (!renew_authorship) {
1041 author_message = use_message;
1042 author_message_buffer = use_message_buffer;
1043 }
1044 }
1045 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1046 author_message = "CHERRY_PICK_HEAD";
1047 author_message_buffer = read_commit_message(author_message);
1048 }
1049
1050 if (patch_interactive)
1051 interactive = 1;
1052
1053 if (!!also + !!only + !!all + !!interactive > 1)
1054 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1055 if (argc == 0 && (also || (only && !amend)))
1056 die(_("No paths with --include/--only does not make sense."));
1057 if (argc == 0 && only && amend)
1058 only_include_assumed = _("Clever... amending the last one with dirty index.");
1059 if (argc > 0 && !also && !only)
1060 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1061 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1062 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1063 else if (!strcmp(cleanup_arg, "verbatim"))
1064 cleanup_mode = CLEANUP_NONE;
1065 else if (!strcmp(cleanup_arg, "whitespace"))
1066 cleanup_mode = CLEANUP_SPACE;
1067 else if (!strcmp(cleanup_arg, "strip"))
1068 cleanup_mode = CLEANUP_ALL;
1069 else
1070 die(_("Invalid cleanup mode %s"), cleanup_arg);
1071
1072 handle_untracked_files_arg(s);
1073
1074 if (all && argc > 0)
1075 die(_("Paths with -a does not make sense."));
1076
1077 if (s->null_termination && status_format == STATUS_FORMAT_LONG)
1078 status_format = STATUS_FORMAT_PORCELAIN;
1079 if (status_format != STATUS_FORMAT_LONG)
1080 dry_run = 1;
1081
1082 return argc;
1083 }
1084
1085 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1086 const struct commit *current_head, struct wt_status *s)
1087 {
1088 int commitable;
1089 const char *index_file;
1090
1091 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1092 commitable = run_status(stdout, index_file, prefix, 0, s);
1093 rollback_index_files();
1094
1095 return commitable ? 0 : 1;
1096 }
1097
1098 static int parse_status_slot(const char *var, int offset)
1099 {
1100 if (!strcasecmp(var+offset, "header"))
1101 return WT_STATUS_HEADER;
1102 if (!strcasecmp(var+offset, "branch"))
1103 return WT_STATUS_ONBRANCH;
1104 if (!strcasecmp(var+offset, "updated")
1105 || !strcasecmp(var+offset, "added"))
1106 return WT_STATUS_UPDATED;
1107 if (!strcasecmp(var+offset, "changed"))
1108 return WT_STATUS_CHANGED;
1109 if (!strcasecmp(var+offset, "untracked"))
1110 return WT_STATUS_UNTRACKED;
1111 if (!strcasecmp(var+offset, "nobranch"))
1112 return WT_STATUS_NOBRANCH;
1113 if (!strcasecmp(var+offset, "unmerged"))
1114 return WT_STATUS_UNMERGED;
1115 return -1;
1116 }
1117
1118 static int git_status_config(const char *k, const char *v, void *cb)
1119 {
1120 struct wt_status *s = cb;
1121
1122 if (!prefixcmp(k, "column."))
1123 return git_column_config(k, v, "status", &s->colopts);
1124 if (!strcmp(k, "status.submodulesummary")) {
1125 int is_bool;
1126 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1127 if (is_bool && s->submodule_summary)
1128 s->submodule_summary = -1;
1129 return 0;
1130 }
1131 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1132 s->use_color = git_config_colorbool(k, v);
1133 return 0;
1134 }
1135 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1136 int slot = parse_status_slot(k, 13);
1137 if (slot < 0)
1138 return 0;
1139 if (!v)
1140 return config_error_nonbool(k);
1141 color_parse(v, k, s->color_palette[slot]);
1142 return 0;
1143 }
1144 if (!strcmp(k, "status.relativepaths")) {
1145 s->relative_paths = git_config_bool(k, v);
1146 return 0;
1147 }
1148 if (!strcmp(k, "status.showuntrackedfiles")) {
1149 if (!v)
1150 return config_error_nonbool(k);
1151 else if (!strcmp(v, "no"))
1152 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1153 else if (!strcmp(v, "normal"))
1154 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1155 else if (!strcmp(v, "all"))
1156 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1157 else
1158 return error(_("Invalid untracked files mode '%s'"), v);
1159 return 0;
1160 }
1161 return git_diff_ui_config(k, v, NULL);
1162 }
1163
1164 int cmd_status(int argc, const char **argv, const char *prefix)
1165 {
1166 static struct wt_status s;
1167 int fd;
1168 unsigned char sha1[20];
1169 static struct option builtin_status_options[] = {
1170 OPT__VERBOSE(&verbose, "be verbose"),
1171 OPT_SET_INT('s', "short", &status_format,
1172 "show status concisely", STATUS_FORMAT_SHORT),
1173 OPT_BOOLEAN('b', "branch", &s.show_branch,
1174 "show branch information"),
1175 OPT_SET_INT(0, "porcelain", &status_format,
1176 "machine-readable output",
1177 STATUS_FORMAT_PORCELAIN),
1178 OPT_BOOLEAN('z', "null", &s.null_termination,
1179 "terminate entries with NUL"),
1180 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1181 "mode",
1182 "show untracked files, optional modes: all, normal, no. (Default: all)",
1183 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1184 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1185 "show ignored files"),
1186 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1187 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1188 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1189 OPT_COLUMN(0, "column", &s.colopts, "list untracked files in columns"),
1190 OPT_END(),
1191 };
1192
1193 if (argc == 2 && !strcmp(argv[1], "-h"))
1194 usage_with_options(builtin_status_usage, builtin_status_options);
1195
1196 wt_status_prepare(&s);
1197 gitmodules_config();
1198 git_config(git_status_config, &s);
1199 determine_whence(&s);
1200 argc = parse_options(argc, argv, prefix,
1201 builtin_status_options,
1202 builtin_status_usage, 0);
1203 finalize_colopts(&s.colopts, -1);
1204
1205 if (s.null_termination && status_format == STATUS_FORMAT_LONG)
1206 status_format = STATUS_FORMAT_PORCELAIN;
1207
1208 handle_untracked_files_arg(&s);
1209 if (show_ignored_in_status)
1210 s.show_ignored_files = 1;
1211 if (*argv)
1212 s.pathspec = get_pathspec(prefix, argv);
1213
1214 read_cache_preload(s.pathspec);
1215 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1216
1217 fd = hold_locked_index(&index_lock, 0);
1218 if (0 <= fd)
1219 update_index_if_able(&the_index, &index_lock);
1220
1221 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1222 s.ignore_submodule_arg = ignore_submodule_arg;
1223 wt_status_collect(&s);
1224
1225 if (s.relative_paths)
1226 s.prefix = prefix;
1227
1228 switch (status_format) {
1229 case STATUS_FORMAT_SHORT:
1230 wt_shortstatus_print(&s);
1231 break;
1232 case STATUS_FORMAT_PORCELAIN:
1233 wt_porcelain_print(&s);
1234 break;
1235 case STATUS_FORMAT_LONG:
1236 s.verbose = verbose;
1237 s.ignore_submodule_arg = ignore_submodule_arg;
1238 wt_status_print(&s);
1239 break;
1240 }
1241 return 0;
1242 }
1243
1244 static void print_summary(const char *prefix, const unsigned char *sha1,
1245 int initial_commit)
1246 {
1247 struct rev_info rev;
1248 struct commit *commit;
1249 struct strbuf format = STRBUF_INIT;
1250 unsigned char junk_sha1[20];
1251 const char *head;
1252 struct pretty_print_context pctx = {0};
1253 struct strbuf author_ident = STRBUF_INIT;
1254 struct strbuf committer_ident = STRBUF_INIT;
1255
1256 commit = lookup_commit(sha1);
1257 if (!commit)
1258 die(_("couldn't look up newly created commit"));
1259 if (!commit || parse_commit(commit))
1260 die(_("could not parse newly created commit"));
1261
1262 strbuf_addstr(&format, "format:%h] %s");
1263
1264 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1265 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1266 if (strbuf_cmp(&author_ident, &committer_ident)) {
1267 strbuf_addstr(&format, "\n Author: ");
1268 strbuf_addbuf_percentquote(&format, &author_ident);
1269 }
1270 if (!user_ident_sufficiently_given()) {
1271 strbuf_addstr(&format, "\n Committer: ");
1272 strbuf_addbuf_percentquote(&format, &committer_ident);
1273 if (advice_implicit_identity) {
1274 strbuf_addch(&format, '\n');
1275 strbuf_addstr(&format, _(implicit_ident_advice));
1276 }
1277 }
1278 strbuf_release(&author_ident);
1279 strbuf_release(&committer_ident);
1280
1281 init_revisions(&rev, prefix);
1282 setup_revisions(0, NULL, &rev, NULL);
1283
1284 rev.diff = 1;
1285 rev.diffopt.output_format =
1286 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1287
1288 rev.verbose_header = 1;
1289 rev.show_root_diff = 1;
1290 get_commit_format(format.buf, &rev);
1291 rev.always_show_header = 0;
1292 rev.diffopt.detect_rename = 1;
1293 rev.diffopt.break_opt = 0;
1294 diff_setup_done(&rev.diffopt);
1295
1296 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1297 printf("[%s%s ",
1298 !prefixcmp(head, "refs/heads/") ?
1299 head + 11 :
1300 !strcmp(head, "HEAD") ?
1301 _("detached HEAD") :
1302 head,
1303 initial_commit ? _(" (root-commit)") : "");
1304
1305 if (!log_tree_commit(&rev, commit)) {
1306 rev.always_show_header = 1;
1307 rev.use_terminator = 1;
1308 log_tree_commit(&rev, commit);
1309 }
1310
1311 strbuf_release(&format);
1312 }
1313
1314 static int git_commit_config(const char *k, const char *v, void *cb)
1315 {
1316 struct wt_status *s = cb;
1317 int status;
1318
1319 if (!strcmp(k, "commit.template"))
1320 return git_config_pathname(&template_file, k, v);
1321 if (!strcmp(k, "commit.status")) {
1322 include_status = git_config_bool(k, v);
1323 return 0;
1324 }
1325
1326 status = git_gpg_config(k, v, NULL);
1327 if (status)
1328 return status;
1329 return git_status_config(k, v, s);
1330 }
1331
1332 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1333
1334 static int run_rewrite_hook(const unsigned char *oldsha1,
1335 const unsigned char *newsha1)
1336 {
1337 /* oldsha1 SP newsha1 LF NUL */
1338 static char buf[2*40 + 3];
1339 struct child_process proc;
1340 const char *argv[3];
1341 int code;
1342 size_t n;
1343
1344 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1345 return 0;
1346
1347 argv[0] = git_path(post_rewrite_hook);
1348 argv[1] = "amend";
1349 argv[2] = NULL;
1350
1351 memset(&proc, 0, sizeof(proc));
1352 proc.argv = argv;
1353 proc.in = -1;
1354 proc.stdout_to_stderr = 1;
1355
1356 code = start_command(&proc);
1357 if (code)
1358 return code;
1359 n = snprintf(buf, sizeof(buf), "%s %s\n",
1360 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1361 write_in_full(proc.in, buf, n);
1362 close(proc.in);
1363 return finish_command(&proc);
1364 }
1365
1366 int cmd_commit(int argc, const char **argv, const char *prefix)
1367 {
1368 static struct wt_status s;
1369 static struct option builtin_commit_options[] = {
1370 OPT__QUIET(&quiet, "suppress summary after successful commit"),
1371 OPT__VERBOSE(&verbose, "show diff in commit message template"),
1372
1373 OPT_GROUP("Commit message options"),
1374 OPT_FILENAME('F', "file", &logfile, "read message from file"),
1375 OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
1376 OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
1377 OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
1378 OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
1379 OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
1380 OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
1381 OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
1382 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C/-c/--amend)"),
1383 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
1384 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
1385 OPT_BOOL('e', "edit", &edit_flag, "force edit of commit"),
1386 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
1387 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
1388 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, "key id",
1389 "GPG sign commit", PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1390 /* end commit message options */
1391
1392 OPT_GROUP("Commit contents options"),
1393 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
1394 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
1395 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
1396 OPT_BOOLEAN('p', "patch", &patch_interactive, "interactively add changes"),
1397 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
1398 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
1399 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
1400 OPT_SET_INT(0, "short", &status_format, "show status concisely",
1401 STATUS_FORMAT_SHORT),
1402 OPT_BOOLEAN(0, "branch", &s.show_branch, "show branch information"),
1403 OPT_SET_INT(0, "porcelain", &status_format,
1404 "machine-readable output", STATUS_FORMAT_PORCELAIN),
1405 OPT_BOOLEAN('z', "null", &s.null_termination,
1406 "terminate entries with NUL"),
1407 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
1408 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
1409 { 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" },
1410 /* end commit contents options */
1411
1412 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
1413 "ok to record an empty change",
1414 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1415 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
1416 "ok to record a change with an empty message",
1417 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1418
1419 OPT_END()
1420 };
1421
1422 struct strbuf sb = STRBUF_INIT;
1423 struct strbuf author_ident = STRBUF_INIT;
1424 const char *index_file, *reflog_msg;
1425 char *nl, *p;
1426 unsigned char sha1[20];
1427 struct ref_lock *ref_lock;
1428 struct commit_list *parents = NULL, **pptr = &parents;
1429 struct stat statbuf;
1430 int allow_fast_forward = 1;
1431 struct commit *current_head = NULL;
1432 struct commit_extra_header *extra = NULL;
1433
1434 if (argc == 2 && !strcmp(argv[1], "-h"))
1435 usage_with_options(builtin_commit_usage, builtin_commit_options);
1436
1437 wt_status_prepare(&s);
1438 git_config(git_commit_config, &s);
1439 determine_whence(&s);
1440 s.colopts = 0;
1441
1442 if (get_sha1("HEAD", sha1))
1443 current_head = NULL;
1444 else {
1445 current_head = lookup_commit_or_die(sha1, "HEAD");
1446 if (!current_head || parse_commit(current_head))
1447 die(_("could not parse HEAD commit"));
1448 }
1449 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1450 builtin_commit_usage,
1451 prefix, current_head, &s);
1452 if (dry_run)
1453 return dry_run_commit(argc, argv, prefix, current_head, &s);
1454 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1455
1456 /* Set up everything for writing the commit object. This includes
1457 running hooks, writing the trees, and interacting with the user. */
1458 if (!prepare_to_commit(index_file, prefix,
1459 current_head, &s, &author_ident)) {
1460 rollback_index_files();
1461 return 1;
1462 }
1463
1464 /* Determine parents */
1465 reflog_msg = getenv("GIT_REFLOG_ACTION");
1466 if (!current_head) {
1467 if (!reflog_msg)
1468 reflog_msg = "commit (initial)";
1469 } else if (amend) {
1470 struct commit_list *c;
1471
1472 if (!reflog_msg)
1473 reflog_msg = "commit (amend)";
1474 for (c = current_head->parents; c; c = c->next)
1475 pptr = &commit_list_insert(c->item, pptr)->next;
1476 } else if (whence == FROM_MERGE) {
1477 struct strbuf m = STRBUF_INIT;
1478 FILE *fp;
1479
1480 if (!reflog_msg)
1481 reflog_msg = "commit (merge)";
1482 pptr = &commit_list_insert(current_head, pptr)->next;
1483 fp = fopen(git_path("MERGE_HEAD"), "r");
1484 if (fp == NULL)
1485 die_errno(_("could not open '%s' for reading"),
1486 git_path("MERGE_HEAD"));
1487 while (strbuf_getline(&m, fp, '\n') != EOF) {
1488 struct commit *parent;
1489
1490 parent = get_merge_parent(m.buf);
1491 if (!parent)
1492 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1493 pptr = &commit_list_insert(parent, pptr)->next;
1494 }
1495 fclose(fp);
1496 strbuf_release(&m);
1497 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1498 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1499 die_errno(_("could not read MERGE_MODE"));
1500 if (!strcmp(sb.buf, "no-ff"))
1501 allow_fast_forward = 0;
1502 }
1503 if (allow_fast_forward)
1504 parents = reduce_heads(parents);
1505 } else {
1506 if (!reflog_msg)
1507 reflog_msg = (whence == FROM_CHERRY_PICK)
1508 ? "commit (cherry-pick)"
1509 : "commit";
1510 pptr = &commit_list_insert(current_head, pptr)->next;
1511 }
1512
1513 /* Finally, get the commit message */
1514 strbuf_reset(&sb);
1515 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1516 int saved_errno = errno;
1517 rollback_index_files();
1518 die(_("could not read commit message: %s"), strerror(saved_errno));
1519 }
1520
1521 /* Truncate the message just before the diff, if any. */
1522 if (verbose) {
1523 p = strstr(sb.buf, "\ndiff --git ");
1524 if (p != NULL)
1525 strbuf_setlen(&sb, p - sb.buf + 1);
1526 }
1527
1528 if (cleanup_mode != CLEANUP_NONE)
1529 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1530 if (template_untouched(&sb) && !allow_empty_message) {
1531 rollback_index_files();
1532 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1533 exit(1);
1534 }
1535 if (message_is_empty(&sb) && !allow_empty_message) {
1536 rollback_index_files();
1537 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1538 exit(1);
1539 }
1540
1541 if (amend) {
1542 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1543 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1544 } else {
1545 struct commit_extra_header **tail = &extra;
1546 append_merge_tag_headers(parents, &tail);
1547 }
1548
1549 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1550 author_ident.buf, sign_commit, extra)) {
1551 rollback_index_files();
1552 die(_("failed to write commit object"));
1553 }
1554 strbuf_release(&author_ident);
1555 free_commit_extra_headers(extra);
1556
1557 ref_lock = lock_any_ref_for_update("HEAD",
1558 !current_head
1559 ? NULL
1560 : current_head->object.sha1,
1561 0);
1562
1563 nl = strchr(sb.buf, '\n');
1564 if (nl)
1565 strbuf_setlen(&sb, nl + 1 - sb.buf);
1566 else
1567 strbuf_addch(&sb, '\n');
1568 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1569 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1570
1571 if (!ref_lock) {
1572 rollback_index_files();
1573 die(_("cannot lock HEAD ref"));
1574 }
1575 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1576 rollback_index_files();
1577 die(_("cannot update HEAD ref"));
1578 }
1579
1580 unlink(git_path("CHERRY_PICK_HEAD"));
1581 unlink(git_path("REVERT_HEAD"));
1582 unlink(git_path("MERGE_HEAD"));
1583 unlink(git_path("MERGE_MSG"));
1584 unlink(git_path("MERGE_MODE"));
1585 unlink(git_path("SQUASH_MSG"));
1586
1587 if (commit_index_files())
1588 die (_("Repository has been updated, but unable to write\n"
1589 "new_index file. Check that disk is not full or quota is\n"
1590 "not exceeded, and then \"git reset HEAD\" to recover."));
1591
1592 rerere(0);
1593 run_hook(get_index_file(), "post-commit", NULL);
1594 if (amend && !no_post_rewrite) {
1595 struct notes_rewrite_cfg *cfg;
1596 cfg = init_copy_notes_for_rewrite("amend");
1597 if (cfg) {
1598 /* we are amending, so current_head is not NULL */
1599 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1600 finish_copy_notes_for_rewrite(cfg);
1601 }
1602 run_rewrite_hook(current_head->object.sha1, sha1);
1603 }
1604 if (!quiet)
1605 print_summary(prefix, sha1, !current_head);
1606
1607 return 0;
1608 }