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