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