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