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