t7606 (merge-theirs): modernize style
[git/dscho.git] / builtin / commit.c
bloba78dbd83bf04c7080487b8508321d79d848e9b1f
1 /*
2 * Builtin "git commit"
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"
29 static const char * const builtin_commit_usage[] = {
30 "git commit [options] [--] <filepattern>...",
31 NULL
34 static const char * const builtin_status_usage[] = {
35 "git status [options] [--] <filepattern>...",
36 NULL
39 static const char implicit_ident_advice[] =
40 "Your name and email address were configured automatically based\n"
41 "on your username and hostname. Please check that they are accurate.\n"
42 "You can suppress this message by setting them explicitly:\n"
43 "\n"
44 " git config --global user.name \"Your Name\"\n"
45 " git config --global user.email you@example.com\n"
46 "\n"
47 "If the identity used for this commit is wrong, you can fix it with:\n"
48 "\n"
49 " git commit --amend --author='Your Name <you@example.com>'\n";
51 static const char empty_amend_advice[] =
52 "You asked to amend the most recent commit, but doing so would make\n"
53 "it empty. You can repeat your command with --allow-empty, or you can\n"
54 "remove the commit entirely with \"git reset HEAD^\".\n";
56 static unsigned char head_sha1[20];
58 static char *use_message_buffer;
59 static const char commit_editmsg[] = "COMMIT_EDITMSG";
60 static struct lock_file index_lock; /* real index */
61 static struct lock_file false_lock; /* used only for partial commits */
62 static enum {
63 COMMIT_AS_IS = 1,
64 COMMIT_NORMAL,
65 COMMIT_PARTIAL
66 } commit_style;
68 static const char *logfile, *force_author;
69 static const char *template_file;
70 static char *edit_message, *use_message;
71 static char *author_name, *author_email, *author_date;
72 static int all, edit_flag, also, interactive, only, amend, signoff;
73 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
74 static int no_post_rewrite, allow_empty_message;
75 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
77 * The default commit message cleanup mode will remove the lines
78 * beginning with # (shell comments) and leading and trailing
79 * whitespaces (empty lines or containing only whitespaces)
80 * if editor is used, and only the whitespaces if the message
81 * is specified explicitly.
83 static enum {
84 CLEANUP_SPACE,
85 CLEANUP_NONE,
86 CLEANUP_ALL
87 } cleanup_mode;
88 static char *cleanup_arg;
90 static int use_editor = 1, initial_commit, in_merge, include_status = 1;
91 static int show_ignored_in_status;
92 static const char *only_include_assumed;
93 static struct strbuf message;
95 static int null_termination;
96 static enum {
97 STATUS_FORMAT_LONG,
98 STATUS_FORMAT_SHORT,
99 STATUS_FORMAT_PORCELAIN
100 } status_format = STATUS_FORMAT_LONG;
101 static int status_show_branch;
103 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
105 struct strbuf *buf = opt->value;
106 if (unset)
107 strbuf_setlen(buf, 0);
108 else {
109 strbuf_addstr(buf, arg);
110 strbuf_addstr(buf, "\n\n");
112 return 0;
115 static struct option builtin_commit_options[] = {
116 OPT__QUIET(&quiet),
117 OPT__VERBOSE(&verbose),
119 OPT_GROUP("Commit message options"),
120 OPT_FILENAME('F', "file", &logfile, "read log from file"),
121 OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
122 OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
123 OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
124 OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
125 OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
126 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
127 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
128 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
129 OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
130 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
131 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
132 /* end commit message options */
134 OPT_GROUP("Commit contents options"),
135 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
136 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
137 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
138 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
139 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
140 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
141 OPT_SET_INT(0, "short", &status_format, "show status concisely",
142 STATUS_FORMAT_SHORT),
143 OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
144 OPT_SET_INT(0, "porcelain", &status_format,
145 "show porcelain output format", STATUS_FORMAT_PORCELAIN),
146 OPT_BOOLEAN('z', "null", &null_termination,
147 "terminate entries with NUL"),
148 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
149 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
150 { 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" },
151 /* end commit contents options */
153 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
154 "ok to record an empty change",
155 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
156 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
157 "ok to record a change with an empty message",
158 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
160 OPT_END()
163 static void rollback_index_files(void)
165 switch (commit_style) {
166 case COMMIT_AS_IS:
167 break; /* nothing to do */
168 case COMMIT_NORMAL:
169 rollback_lock_file(&index_lock);
170 break;
171 case COMMIT_PARTIAL:
172 rollback_lock_file(&index_lock);
173 rollback_lock_file(&false_lock);
174 break;
178 static int commit_index_files(void)
180 int err = 0;
182 switch (commit_style) {
183 case COMMIT_AS_IS:
184 break; /* nothing to do */
185 case COMMIT_NORMAL:
186 err = commit_lock_file(&index_lock);
187 break;
188 case COMMIT_PARTIAL:
189 err = commit_lock_file(&index_lock);
190 rollback_lock_file(&false_lock);
191 break;
194 return err;
198 * Take a union of paths in the index and the named tree (typically, "HEAD"),
199 * and return the paths that match the given pattern in list.
201 static int list_paths(struct string_list *list, const char *with_tree,
202 const char *prefix, const char **pattern)
204 int i;
205 char *m;
207 for (i = 0; pattern[i]; i++)
209 m = xcalloc(1, i);
211 if (with_tree)
212 overlay_tree_on_cache(with_tree, prefix);
214 for (i = 0; i < active_nr; i++) {
215 struct cache_entry *ce = active_cache[i];
216 struct string_list_item *item;
218 if (ce->ce_flags & CE_UPDATE)
219 continue;
220 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
221 continue;
222 item = string_list_insert(list, ce->name);
223 if (ce_skip_worktree(ce))
224 item->util = item; /* better a valid pointer than a fake one */
227 return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
230 static void add_remove_files(struct string_list *list)
232 int i;
233 for (i = 0; i < list->nr; i++) {
234 struct stat st;
235 struct string_list_item *p = &(list->items[i]);
237 /* p->util is skip-worktree */
238 if (p->util)
239 continue;
241 if (!lstat(p->string, &st)) {
242 if (add_to_cache(p->string, &st, 0))
243 die("updating files failed");
244 } else
245 remove_file_from_cache(p->string);
249 static void create_base_index(void)
251 struct tree *tree;
252 struct unpack_trees_options opts;
253 struct tree_desc t;
255 if (initial_commit) {
256 discard_cache();
257 return;
260 memset(&opts, 0, sizeof(opts));
261 opts.head_idx = 1;
262 opts.index_only = 1;
263 opts.merge = 1;
264 opts.src_index = &the_index;
265 opts.dst_index = &the_index;
267 opts.fn = oneway_merge;
268 tree = parse_tree_indirect(head_sha1);
269 if (!tree)
270 die("failed to unpack HEAD tree object");
271 parse_tree(tree);
272 init_tree_desc(&t, tree->buffer, tree->size);
273 if (unpack_trees(1, &t, &opts))
274 exit(128); /* We've already reported the error, finish dying */
277 static void refresh_cache_or_die(int refresh_flags)
280 * refresh_flags contains REFRESH_QUIET, so the only errors
281 * are for unmerged entries.
283 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
284 die_resolve_conflict("commit");
287 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
289 int fd;
290 struct string_list partial;
291 const char **pathspec = NULL;
292 int refresh_flags = REFRESH_QUIET;
294 if (is_status)
295 refresh_flags |= REFRESH_UNMERGED;
296 if (interactive) {
297 if (interactive_add(argc, argv, prefix) != 0)
298 die("interactive add failed");
299 if (read_cache_preload(NULL) < 0)
300 die("index file corrupt");
301 commit_style = COMMIT_AS_IS;
302 return get_index_file();
305 if (*argv)
306 pathspec = get_pathspec(prefix, argv);
308 if (read_cache_preload(pathspec) < 0)
309 die("index file corrupt");
312 * Non partial, non as-is commit.
314 * (1) get the real index;
315 * (2) update the_index as necessary;
316 * (3) write the_index out to the real index (still locked);
317 * (4) return the name of the locked index file.
319 * The caller should run hooks on the locked real index, and
320 * (A) if all goes well, commit the real index;
321 * (B) on failure, rollback the real index.
323 if (all || (also && pathspec && *pathspec)) {
324 fd = hold_locked_index(&index_lock, 1);
325 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
326 refresh_cache_or_die(refresh_flags);
327 if (write_cache(fd, active_cache, active_nr) ||
328 close_lock_file(&index_lock))
329 die("unable to write new_index file");
330 commit_style = COMMIT_NORMAL;
331 return index_lock.filename;
335 * As-is commit.
337 * (1) return the name of the real index file.
339 * The caller should run hooks on the real index,
340 * and create commit from the_index.
341 * We still need to refresh the index here.
343 if (!pathspec || !*pathspec) {
344 fd = hold_locked_index(&index_lock, 1);
345 refresh_cache_or_die(refresh_flags);
346 if (active_cache_changed) {
347 if (write_cache(fd, active_cache, active_nr) ||
348 commit_locked_index(&index_lock))
349 die("unable to write new_index file");
350 } else {
351 rollback_lock_file(&index_lock);
353 commit_style = COMMIT_AS_IS;
354 return get_index_file();
358 * A partial commit.
360 * (0) find the set of affected paths;
361 * (1) get lock on the real index file;
362 * (2) update the_index with the given paths;
363 * (3) write the_index out to the real index (still locked);
364 * (4) get lock on the false index file;
365 * (5) reset the_index from HEAD;
366 * (6) update the_index the same way as (2);
367 * (7) write the_index out to the false index file;
368 * (8) return the name of the false index file (still locked);
370 * The caller should run hooks on the locked false index, and
371 * create commit from it. Then
372 * (A) if all goes well, commit the real index;
373 * (B) on failure, rollback the real index;
374 * In either case, rollback the false index.
376 commit_style = COMMIT_PARTIAL;
378 if (in_merge)
379 die("cannot do a partial commit during a merge.");
381 memset(&partial, 0, sizeof(partial));
382 partial.strdup_strings = 1;
383 if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
384 exit(1);
386 discard_cache();
387 if (read_cache() < 0)
388 die("cannot read the index");
390 fd = hold_locked_index(&index_lock, 1);
391 add_remove_files(&partial);
392 refresh_cache(REFRESH_QUIET);
393 if (write_cache(fd, active_cache, active_nr) ||
394 close_lock_file(&index_lock))
395 die("unable to write new_index file");
397 fd = hold_lock_file_for_update(&false_lock,
398 git_path("next-index-%"PRIuMAX,
399 (uintmax_t) getpid()),
400 LOCK_DIE_ON_ERROR);
402 create_base_index();
403 add_remove_files(&partial);
404 refresh_cache(REFRESH_QUIET);
406 if (write_cache(fd, active_cache, active_nr) ||
407 close_lock_file(&false_lock))
408 die("unable to write temporary index file");
410 discard_cache();
411 read_cache_from(false_lock.filename);
413 return false_lock.filename;
416 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
417 struct wt_status *s)
419 unsigned char sha1[20];
421 if (s->relative_paths)
422 s->prefix = prefix;
424 if (amend) {
425 s->amend = 1;
426 s->reference = "HEAD^1";
428 s->verbose = verbose;
429 s->index_file = index_file;
430 s->fp = fp;
431 s->nowarn = nowarn;
432 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
434 wt_status_collect(s);
436 switch (status_format) {
437 case STATUS_FORMAT_SHORT:
438 wt_shortstatus_print(s, null_termination, status_show_branch);
439 break;
440 case STATUS_FORMAT_PORCELAIN:
441 wt_porcelain_print(s, null_termination);
442 break;
443 case STATUS_FORMAT_LONG:
444 wt_status_print(s);
445 break;
448 return s->commitable;
451 static int is_a_merge(const unsigned char *sha1)
453 struct commit *commit = lookup_commit(sha1);
454 if (!commit || parse_commit(commit))
455 die("could not parse HEAD commit");
456 return !!(commit->parents && commit->parents->next);
459 static const char sign_off_header[] = "Signed-off-by: ";
461 static void determine_author_info(void)
463 char *name, *email, *date;
465 name = getenv("GIT_AUTHOR_NAME");
466 email = getenv("GIT_AUTHOR_EMAIL");
467 date = getenv("GIT_AUTHOR_DATE");
469 if (use_message && !renew_authorship) {
470 const char *a, *lb, *rb, *eol;
472 a = strstr(use_message_buffer, "\nauthor ");
473 if (!a)
474 die("invalid commit: %s", use_message);
476 lb = strchrnul(a + strlen("\nauthor "), '<');
477 rb = strchrnul(lb, '>');
478 eol = strchrnul(rb, '\n');
479 if (!*lb || !*rb || !*eol)
480 die("invalid commit: %s", use_message);
482 if (lb == a + strlen("\nauthor "))
483 /* \nauthor <foo@example.com> */
484 name = xcalloc(1, 1);
485 else
486 name = xmemdupz(a + strlen("\nauthor "),
487 (lb - strlen(" ") -
488 (a + strlen("\nauthor "))));
489 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
490 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
493 if (force_author) {
494 const char *lb = strstr(force_author, " <");
495 const char *rb = strchr(force_author, '>');
497 if (!lb || !rb)
498 die("malformed --author parameter");
499 name = xstrndup(force_author, lb - force_author);
500 email = xstrndup(lb + 2, rb - (lb + 2));
503 if (force_date)
504 date = force_date;
506 author_name = name;
507 author_email = email;
508 author_date = date;
511 static int ends_rfc2822_footer(struct strbuf *sb)
513 int ch;
514 int hit = 0;
515 int i, j, k;
516 int len = sb->len;
517 int first = 1;
518 const char *buf = sb->buf;
520 for (i = len - 1; i > 0; i--) {
521 if (hit && buf[i] == '\n')
522 break;
523 hit = (buf[i] == '\n');
526 while (i < len - 1 && buf[i] == '\n')
527 i++;
529 for (; i < len; i = k) {
530 for (k = i; k < len && buf[k] != '\n'; k++)
531 ; /* do nothing */
532 k++;
534 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
535 continue;
537 first = 0;
539 for (j = 0; i + j < len; j++) {
540 ch = buf[i + j];
541 if (ch == ':')
542 break;
543 if (isalnum(ch) ||
544 (ch == '-'))
545 continue;
546 return 0;
549 return 1;
552 static int prepare_to_commit(const char *index_file, const char *prefix,
553 struct wt_status *s)
555 struct stat statbuf;
556 int commitable, saved_color_setting;
557 struct strbuf sb = STRBUF_INIT;
558 char *buffer;
559 FILE *fp;
560 const char *hook_arg1 = NULL;
561 const char *hook_arg2 = NULL;
562 int ident_shown = 0;
564 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
565 return 0;
567 if (message.len) {
568 strbuf_addbuf(&sb, &message);
569 hook_arg1 = "message";
570 } else if (logfile && !strcmp(logfile, "-")) {
571 if (isatty(0))
572 fprintf(stderr, "(reading log message from standard input)\n");
573 if (strbuf_read(&sb, 0, 0) < 0)
574 die_errno("could not read log from standard input");
575 hook_arg1 = "message";
576 } else if (logfile) {
577 if (strbuf_read_file(&sb, logfile, 0) < 0)
578 die_errno("could not read log file '%s'",
579 logfile);
580 hook_arg1 = "message";
581 } else if (use_message) {
582 buffer = strstr(use_message_buffer, "\n\n");
583 if (!buffer || buffer[2] == '\0')
584 die("commit has empty message");
585 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
586 hook_arg1 = "commit";
587 hook_arg2 = use_message;
588 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
589 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
590 die_errno("could not read MERGE_MSG");
591 hook_arg1 = "merge";
592 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
593 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
594 die_errno("could not read SQUASH_MSG");
595 hook_arg1 = "squash";
596 } else if (template_file && !stat(template_file, &statbuf)) {
597 if (strbuf_read_file(&sb, template_file, 0) < 0)
598 die_errno("could not read '%s'", template_file);
599 hook_arg1 = "template";
603 * This final case does not modify the template message,
604 * it just sets the argument to the prepare-commit-msg hook.
606 else if (in_merge)
607 hook_arg1 = "merge";
609 fp = fopen(git_path(commit_editmsg), "w");
610 if (fp == NULL)
611 die_errno("could not open '%s'", git_path(commit_editmsg));
613 if (cleanup_mode != CLEANUP_NONE)
614 stripspace(&sb, 0);
616 if (signoff) {
617 struct strbuf sob = STRBUF_INIT;
618 int i;
620 strbuf_addstr(&sob, sign_off_header);
621 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
622 getenv("GIT_COMMITTER_EMAIL")));
623 strbuf_addch(&sob, '\n');
624 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
625 ; /* do nothing */
626 if (prefixcmp(sb.buf + i, sob.buf)) {
627 if (!i || !ends_rfc2822_footer(&sb))
628 strbuf_addch(&sb, '\n');
629 strbuf_addbuf(&sb, &sob);
631 strbuf_release(&sob);
634 if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
635 die_errno("could not write commit template");
637 strbuf_release(&sb);
639 determine_author_info();
641 /* This checks if committer ident is explicitly given */
642 git_committer_info(0);
643 if (use_editor && include_status) {
644 char *author_ident;
645 const char *committer_ident;
647 if (in_merge)
648 fprintf(fp,
649 "#\n"
650 "# It looks like you may be committing a MERGE.\n"
651 "# If this is not correct, please remove the file\n"
652 "# %s\n"
653 "# and try again.\n"
654 "#\n",
655 git_path("MERGE_HEAD"));
657 fprintf(fp,
658 "\n"
659 "# Please enter the commit message for your changes.");
660 if (cleanup_mode == CLEANUP_ALL)
661 fprintf(fp,
662 " Lines starting\n"
663 "# with '#' will be ignored, and an empty"
664 " message aborts the commit.\n");
665 else /* CLEANUP_SPACE, that is. */
666 fprintf(fp,
667 " Lines starting\n"
668 "# with '#' will be kept; you may remove them"
669 " yourself if you want to.\n"
670 "# An empty message aborts the commit.\n");
671 if (only_include_assumed)
672 fprintf(fp, "# %s\n", only_include_assumed);
674 author_ident = xstrdup(fmt_name(author_name, author_email));
675 committer_ident = fmt_name(getenv("GIT_COMMITTER_NAME"),
676 getenv("GIT_COMMITTER_EMAIL"));
677 if (strcmp(author_ident, committer_ident))
678 fprintf(fp,
679 "%s"
680 "# Author: %s\n",
681 ident_shown++ ? "" : "#\n",
682 author_ident);
683 free(author_ident);
685 if (!user_ident_sufficiently_given())
686 fprintf(fp,
687 "%s"
688 "# Committer: %s\n",
689 ident_shown++ ? "" : "#\n",
690 committer_ident);
692 if (ident_shown)
693 fprintf(fp, "#\n");
695 saved_color_setting = s->use_color;
696 s->use_color = 0;
697 commitable = run_status(fp, index_file, prefix, 1, s);
698 s->use_color = saved_color_setting;
699 } else {
700 unsigned char sha1[20];
701 const char *parent = "HEAD";
703 if (!active_nr && read_cache() < 0)
704 die("Cannot read index");
706 if (amend)
707 parent = "HEAD^1";
709 if (get_sha1(parent, sha1))
710 commitable = !!active_nr;
711 else
712 commitable = index_differs_from(parent, 0);
715 fclose(fp);
717 if (!commitable && !in_merge && !allow_empty &&
718 !(amend && is_a_merge(head_sha1))) {
719 run_status(stdout, index_file, prefix, 0, s);
720 if (amend)
721 fputs(empty_amend_advice, stderr);
722 return 0;
726 * Re-read the index as pre-commit hook could have updated it,
727 * and write it out as a tree. We must do this before we invoke
728 * the editor and after we invoke run_status above.
730 discard_cache();
731 read_cache_from(index_file);
732 if (!active_cache_tree)
733 active_cache_tree = cache_tree();
734 if (cache_tree_update(active_cache_tree,
735 active_cache, active_nr, 0, 0) < 0) {
736 error("Error building trees");
737 return 0;
740 if (run_hook(index_file, "prepare-commit-msg",
741 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
742 return 0;
744 if (use_editor) {
745 char index[PATH_MAX];
746 const char *env[2] = { NULL };
747 env[0] = index;
748 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
749 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
750 fprintf(stderr,
751 "Please supply the message using either -m or -F option.\n");
752 exit(1);
756 if (!no_verify &&
757 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
758 return 0;
761 return 1;
765 * Find out if the message in the strbuf contains only whitespace and
766 * Signed-off-by lines.
768 static int message_is_empty(struct strbuf *sb)
770 struct strbuf tmpl = STRBUF_INIT;
771 const char *nl;
772 int eol, i, start = 0;
774 if (cleanup_mode == CLEANUP_NONE && sb->len)
775 return 0;
777 /* See if the template is just a prefix of the message. */
778 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
779 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
780 if (start + tmpl.len <= sb->len &&
781 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
782 start += tmpl.len;
784 strbuf_release(&tmpl);
786 /* Check if the rest is just whitespace and Signed-of-by's. */
787 for (i = start; i < sb->len; i++) {
788 nl = memchr(sb->buf + i, '\n', sb->len - i);
789 if (nl)
790 eol = nl - sb->buf;
791 else
792 eol = sb->len;
794 if (strlen(sign_off_header) <= eol - i &&
795 !prefixcmp(sb->buf + i, sign_off_header)) {
796 i = eol;
797 continue;
799 while (i < eol)
800 if (!isspace(sb->buf[i++]))
801 return 0;
804 return 1;
807 static const char *find_author_by_nickname(const char *name)
809 struct rev_info revs;
810 struct commit *commit;
811 struct strbuf buf = STRBUF_INIT;
812 const char *av[20];
813 int ac = 0;
815 init_revisions(&revs, NULL);
816 strbuf_addf(&buf, "--author=%s", name);
817 av[++ac] = "--all";
818 av[++ac] = "-i";
819 av[++ac] = buf.buf;
820 av[++ac] = NULL;
821 setup_revisions(ac, av, &revs, NULL);
822 prepare_revision_walk(&revs);
823 commit = get_revision(&revs);
824 if (commit) {
825 struct pretty_print_context ctx = {0};
826 ctx.date_mode = DATE_NORMAL;
827 strbuf_release(&buf);
828 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
829 return strbuf_detach(&buf, NULL);
831 die("No existing author found with '%s'", name);
835 static void handle_untracked_files_arg(struct wt_status *s)
837 if (!untracked_files_arg)
838 ; /* default already initialized */
839 else if (!strcmp(untracked_files_arg, "no"))
840 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
841 else if (!strcmp(untracked_files_arg, "normal"))
842 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
843 else if (!strcmp(untracked_files_arg, "all"))
844 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
845 else
846 die("Invalid untracked files mode '%s'", untracked_files_arg);
849 static int parse_and_validate_options(int argc, const char *argv[],
850 const char * const usage[],
851 const char *prefix,
852 struct wt_status *s)
854 int f = 0;
856 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
859 if (force_author && !strchr(force_author, '>'))
860 force_author = find_author_by_nickname(force_author);
862 if (force_author && renew_authorship)
863 die("Using both --reset-author and --author does not make sense");
865 if (logfile || message.len || use_message)
866 use_editor = 0;
867 if (edit_flag)
868 use_editor = 1;
869 if (!use_editor)
870 setenv("GIT_EDITOR", ":", 1);
872 if (get_sha1("HEAD", head_sha1))
873 initial_commit = 1;
875 /* Sanity check options */
876 if (amend && initial_commit)
877 die("You have nothing to amend.");
878 if (amend && in_merge)
879 die("You are in the middle of a merge -- cannot amend.");
881 if (use_message)
882 f++;
883 if (edit_message)
884 f++;
885 if (logfile)
886 f++;
887 if (f > 1)
888 die("Only one of -c/-C/-F can be used.");
889 if (message.len && f > 0)
890 die("Option -m cannot be combined with -c/-C/-F.");
891 if (edit_message)
892 use_message = edit_message;
893 if (amend && !use_message)
894 use_message = "HEAD";
895 if (!use_message && renew_authorship)
896 die("--reset-author can be used only with -C, -c or --amend.");
897 if (use_message) {
898 unsigned char sha1[20];
899 static char utf8[] = "UTF-8";
900 const char *out_enc;
901 char *enc, *end;
902 struct commit *commit;
904 if (get_sha1(use_message, sha1))
905 die("could not lookup commit %s", use_message);
906 commit = lookup_commit_reference(sha1);
907 if (!commit || parse_commit(commit))
908 die("could not parse commit %s", use_message);
910 enc = strstr(commit->buffer, "\nencoding");
911 if (enc) {
912 end = strchr(enc + 10, '\n');
913 enc = xstrndup(enc + 10, end - (enc + 10));
914 } else {
915 enc = utf8;
917 out_enc = git_commit_encoding ? git_commit_encoding : utf8;
919 if (strcmp(out_enc, enc))
920 use_message_buffer =
921 reencode_string(commit->buffer, out_enc, enc);
924 * If we failed to reencode the buffer, just copy it
925 * byte for byte so the user can try to fix it up.
926 * This also handles the case where input and output
927 * encodings are identical.
929 if (use_message_buffer == NULL)
930 use_message_buffer = xstrdup(commit->buffer);
931 if (enc != utf8)
932 free(enc);
935 if (!!also + !!only + !!all + !!interactive > 1)
936 die("Only one of --include/--only/--all/--interactive can be used.");
937 if (argc == 0 && (also || (only && !amend)))
938 die("No paths with --include/--only does not make sense.");
939 if (argc == 0 && only && amend)
940 only_include_assumed = "Clever... amending the last one with dirty index.";
941 if (argc > 0 && !also && !only)
942 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
943 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
944 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
945 else if (!strcmp(cleanup_arg, "verbatim"))
946 cleanup_mode = CLEANUP_NONE;
947 else if (!strcmp(cleanup_arg, "whitespace"))
948 cleanup_mode = CLEANUP_SPACE;
949 else if (!strcmp(cleanup_arg, "strip"))
950 cleanup_mode = CLEANUP_ALL;
951 else
952 die("Invalid cleanup mode %s", cleanup_arg);
954 handle_untracked_files_arg(s);
956 if (all && argc > 0)
957 die("Paths with -a does not make sense.");
958 else if (interactive && argc > 0)
959 die("Paths with --interactive does not make sense.");
961 if (null_termination && status_format == STATUS_FORMAT_LONG)
962 status_format = STATUS_FORMAT_PORCELAIN;
963 if (status_format != STATUS_FORMAT_LONG)
964 dry_run = 1;
966 return argc;
969 static int dry_run_commit(int argc, const char **argv, const char *prefix,
970 struct wt_status *s)
972 int commitable;
973 const char *index_file;
975 index_file = prepare_index(argc, argv, prefix, 1);
976 commitable = run_status(stdout, index_file, prefix, 0, s);
977 rollback_index_files();
979 return commitable ? 0 : 1;
982 static int parse_status_slot(const char *var, int offset)
984 if (!strcasecmp(var+offset, "header"))
985 return WT_STATUS_HEADER;
986 if (!strcasecmp(var+offset, "updated")
987 || !strcasecmp(var+offset, "added"))
988 return WT_STATUS_UPDATED;
989 if (!strcasecmp(var+offset, "changed"))
990 return WT_STATUS_CHANGED;
991 if (!strcasecmp(var+offset, "untracked"))
992 return WT_STATUS_UNTRACKED;
993 if (!strcasecmp(var+offset, "nobranch"))
994 return WT_STATUS_NOBRANCH;
995 if (!strcasecmp(var+offset, "unmerged"))
996 return WT_STATUS_UNMERGED;
997 return -1;
1000 static int git_status_config(const char *k, const char *v, void *cb)
1002 struct wt_status *s = cb;
1004 if (!strcmp(k, "status.submodulesummary")) {
1005 int is_bool;
1006 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1007 if (is_bool && s->submodule_summary)
1008 s->submodule_summary = -1;
1009 return 0;
1011 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1012 s->use_color = git_config_colorbool(k, v, -1);
1013 return 0;
1015 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1016 int slot = parse_status_slot(k, 13);
1017 if (slot < 0)
1018 return 0;
1019 if (!v)
1020 return config_error_nonbool(k);
1021 color_parse(v, k, s->color_palette[slot]);
1022 return 0;
1024 if (!strcmp(k, "status.relativepaths")) {
1025 s->relative_paths = git_config_bool(k, v);
1026 return 0;
1028 if (!strcmp(k, "status.showuntrackedfiles")) {
1029 if (!v)
1030 return config_error_nonbool(k);
1031 else if (!strcmp(v, "no"))
1032 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1033 else if (!strcmp(v, "normal"))
1034 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1035 else if (!strcmp(v, "all"))
1036 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1037 else
1038 return error("Invalid untracked files mode '%s'", v);
1039 return 0;
1041 return git_diff_ui_config(k, v, NULL);
1044 int cmd_status(int argc, const char **argv, const char *prefix)
1046 struct wt_status s;
1047 int fd;
1048 unsigned char sha1[20];
1049 static struct option builtin_status_options[] = {
1050 OPT__VERBOSE(&verbose),
1051 OPT_SET_INT('s', "short", &status_format,
1052 "show status concisely", STATUS_FORMAT_SHORT),
1053 OPT_BOOLEAN('b', "branch", &status_show_branch,
1054 "show branch information"),
1055 OPT_SET_INT(0, "porcelain", &status_format,
1056 "show porcelain output format",
1057 STATUS_FORMAT_PORCELAIN),
1058 OPT_BOOLEAN('z', "null", &null_termination,
1059 "terminate entries with NUL"),
1060 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1061 "mode",
1062 "show untracked files, optional modes: all, normal, no. (Default: all)",
1063 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1064 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1065 "show ignored files"),
1066 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1067 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1068 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1069 OPT_END(),
1072 if (null_termination && status_format == STATUS_FORMAT_LONG)
1073 status_format = STATUS_FORMAT_PORCELAIN;
1075 wt_status_prepare(&s);
1076 git_config(git_status_config, &s);
1077 in_merge = file_exists(git_path("MERGE_HEAD"));
1078 argc = parse_options(argc, argv, prefix,
1079 builtin_status_options,
1080 builtin_status_usage, 0);
1081 handle_untracked_files_arg(&s);
1082 if (show_ignored_in_status)
1083 s.show_ignored_files = 1;
1084 if (*argv)
1085 s.pathspec = get_pathspec(prefix, argv);
1087 read_cache_preload(s.pathspec);
1088 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1090 fd = hold_locked_index(&index_lock, 0);
1091 if (0 <= fd) {
1092 if (active_cache_changed &&
1093 !write_cache(fd, active_cache, active_nr))
1094 commit_locked_index(&index_lock);
1095 else
1096 rollback_lock_file(&index_lock);
1099 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1100 s.in_merge = in_merge;
1101 s.ignore_submodule_arg = ignore_submodule_arg;
1102 wt_status_collect(&s);
1104 if (s.relative_paths)
1105 s.prefix = prefix;
1106 if (s.use_color == -1)
1107 s.use_color = git_use_color_default;
1108 if (diff_use_color_default == -1)
1109 diff_use_color_default = git_use_color_default;
1111 switch (status_format) {
1112 case STATUS_FORMAT_SHORT:
1113 wt_shortstatus_print(&s, null_termination, status_show_branch);
1114 break;
1115 case STATUS_FORMAT_PORCELAIN:
1116 wt_porcelain_print(&s, null_termination);
1117 break;
1118 case STATUS_FORMAT_LONG:
1119 s.verbose = verbose;
1120 s.ignore_submodule_arg = ignore_submodule_arg;
1121 wt_status_print(&s);
1122 break;
1124 return 0;
1127 static void print_summary(const char *prefix, const unsigned char *sha1)
1129 struct rev_info rev;
1130 struct commit *commit;
1131 struct strbuf format = STRBUF_INIT;
1132 unsigned char junk_sha1[20];
1133 const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1134 struct pretty_print_context pctx = {0};
1135 struct strbuf author_ident = STRBUF_INIT;
1136 struct strbuf committer_ident = STRBUF_INIT;
1138 commit = lookup_commit(sha1);
1139 if (!commit)
1140 die("couldn't look up newly created commit");
1141 if (!commit || parse_commit(commit))
1142 die("could not parse newly created commit");
1144 strbuf_addstr(&format, "format:%h] %s");
1146 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1147 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1148 if (strbuf_cmp(&author_ident, &committer_ident)) {
1149 strbuf_addstr(&format, "\n Author: ");
1150 strbuf_addbuf_percentquote(&format, &author_ident);
1152 if (!user_ident_sufficiently_given()) {
1153 strbuf_addstr(&format, "\n Committer: ");
1154 strbuf_addbuf_percentquote(&format, &committer_ident);
1155 if (advice_implicit_identity) {
1156 strbuf_addch(&format, '\n');
1157 strbuf_addstr(&format, implicit_ident_advice);
1160 strbuf_release(&author_ident);
1161 strbuf_release(&committer_ident);
1163 init_revisions(&rev, prefix);
1164 setup_revisions(0, NULL, &rev, NULL);
1166 rev.abbrev = 0;
1167 rev.diff = 1;
1168 rev.diffopt.output_format =
1169 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1171 rev.verbose_header = 1;
1172 rev.show_root_diff = 1;
1173 get_commit_format(format.buf, &rev);
1174 rev.always_show_header = 0;
1175 rev.diffopt.detect_rename = 1;
1176 rev.diffopt.rename_limit = 100;
1177 rev.diffopt.break_opt = 0;
1178 diff_setup_done(&rev.diffopt);
1180 printf("[%s%s ",
1181 !prefixcmp(head, "refs/heads/") ?
1182 head + 11 :
1183 !strcmp(head, "HEAD") ?
1184 "detached HEAD" :
1185 head,
1186 initial_commit ? " (root-commit)" : "");
1188 if (!log_tree_commit(&rev, commit)) {
1189 rev.always_show_header = 1;
1190 rev.use_terminator = 1;
1191 log_tree_commit(&rev, commit);
1194 strbuf_release(&format);
1197 static int git_commit_config(const char *k, const char *v, void *cb)
1199 struct wt_status *s = cb;
1201 if (!strcmp(k, "commit.template"))
1202 return git_config_pathname(&template_file, k, v);
1203 if (!strcmp(k, "commit.status")) {
1204 include_status = git_config_bool(k, v);
1205 return 0;
1208 return git_status_config(k, v, s);
1211 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1213 static int run_rewrite_hook(const unsigned char *oldsha1,
1214 const unsigned char *newsha1)
1216 /* oldsha1 SP newsha1 LF NUL */
1217 static char buf[2*40 + 3];
1218 struct child_process proc;
1219 const char *argv[3];
1220 int code;
1221 size_t n;
1223 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1224 return 0;
1226 argv[0] = git_path(post_rewrite_hook);
1227 argv[1] = "amend";
1228 argv[2] = NULL;
1230 memset(&proc, 0, sizeof(proc));
1231 proc.argv = argv;
1232 proc.in = -1;
1233 proc.stdout_to_stderr = 1;
1235 code = start_command(&proc);
1236 if (code)
1237 return code;
1238 n = snprintf(buf, sizeof(buf), "%s %s\n",
1239 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1240 write_in_full(proc.in, buf, n);
1241 close(proc.in);
1242 return finish_command(&proc);
1245 int cmd_commit(int argc, const char **argv, const char *prefix)
1247 struct strbuf sb = STRBUF_INIT;
1248 const char *index_file, *reflog_msg;
1249 char *nl, *p;
1250 unsigned char commit_sha1[20];
1251 struct ref_lock *ref_lock;
1252 struct commit_list *parents = NULL, **pptr = &parents;
1253 struct stat statbuf;
1254 int allow_fast_forward = 1;
1255 struct wt_status s;
1257 wt_status_prepare(&s);
1258 git_config(git_commit_config, &s);
1259 in_merge = file_exists(git_path("MERGE_HEAD"));
1260 s.in_merge = in_merge;
1262 if (s.use_color == -1)
1263 s.use_color = git_use_color_default;
1264 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1265 prefix, &s);
1266 if (dry_run) {
1267 if (diff_use_color_default == -1)
1268 diff_use_color_default = git_use_color_default;
1269 return dry_run_commit(argc, argv, prefix, &s);
1271 index_file = prepare_index(argc, argv, prefix, 0);
1273 /* Set up everything for writing the commit object. This includes
1274 running hooks, writing the trees, and interacting with the user. */
1275 if (!prepare_to_commit(index_file, prefix, &s)) {
1276 rollback_index_files();
1277 return 1;
1280 /* Determine parents */
1281 reflog_msg = getenv("GIT_REFLOG_ACTION");
1282 if (initial_commit) {
1283 if (!reflog_msg)
1284 reflog_msg = "commit (initial)";
1285 } else if (amend) {
1286 struct commit_list *c;
1287 struct commit *commit;
1289 if (!reflog_msg)
1290 reflog_msg = "commit (amend)";
1291 commit = lookup_commit(head_sha1);
1292 if (!commit || parse_commit(commit))
1293 die("could not parse HEAD commit");
1295 for (c = commit->parents; c; c = c->next)
1296 pptr = &commit_list_insert(c->item, pptr)->next;
1297 } else if (in_merge) {
1298 struct strbuf m = STRBUF_INIT;
1299 FILE *fp;
1301 if (!reflog_msg)
1302 reflog_msg = "commit (merge)";
1303 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1304 fp = fopen(git_path("MERGE_HEAD"), "r");
1305 if (fp == NULL)
1306 die_errno("could not open '%s' for reading",
1307 git_path("MERGE_HEAD"));
1308 while (strbuf_getline(&m, fp, '\n') != EOF) {
1309 unsigned char sha1[20];
1310 if (get_sha1_hex(m.buf, sha1) < 0)
1311 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1312 pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1314 fclose(fp);
1315 strbuf_release(&m);
1316 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1317 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1318 die_errno("could not read MERGE_MODE");
1319 if (!strcmp(sb.buf, "no-ff"))
1320 allow_fast_forward = 0;
1322 if (allow_fast_forward)
1323 parents = reduce_heads(parents);
1324 } else {
1325 if (!reflog_msg)
1326 reflog_msg = "commit";
1327 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1330 /* Finally, get the commit message */
1331 strbuf_reset(&sb);
1332 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1333 int saved_errno = errno;
1334 rollback_index_files();
1335 die("could not read commit message: %s", strerror(saved_errno));
1338 /* Truncate the message just before the diff, if any. */
1339 if (verbose) {
1340 p = strstr(sb.buf, "\ndiff --git ");
1341 if (p != NULL)
1342 strbuf_setlen(&sb, p - sb.buf + 1);
1345 if (cleanup_mode != CLEANUP_NONE)
1346 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1347 if (message_is_empty(&sb) && !allow_empty_message) {
1348 rollback_index_files();
1349 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1350 exit(1);
1353 if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1354 fmt_ident(author_name, author_email, author_date,
1355 IDENT_ERROR_ON_NO_NAME))) {
1356 rollback_index_files();
1357 die("failed to write commit object");
1360 ref_lock = lock_any_ref_for_update("HEAD",
1361 initial_commit ? NULL : head_sha1,
1364 nl = strchr(sb.buf, '\n');
1365 if (nl)
1366 strbuf_setlen(&sb, nl + 1 - sb.buf);
1367 else
1368 strbuf_addch(&sb, '\n');
1369 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1370 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1372 if (!ref_lock) {
1373 rollback_index_files();
1374 die("cannot lock HEAD ref");
1376 if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1377 rollback_index_files();
1378 die("cannot update HEAD ref");
1381 unlink(git_path("MERGE_HEAD"));
1382 unlink(git_path("MERGE_MSG"));
1383 unlink(git_path("MERGE_MODE"));
1384 unlink(git_path("SQUASH_MSG"));
1386 if (commit_index_files())
1387 die ("Repository has been updated, but unable to write\n"
1388 "new_index file. Check that disk is not full or quota is\n"
1389 "not exceeded, and then \"git reset HEAD\" to recover.");
1391 rerere(0);
1392 run_hook(get_index_file(), "post-commit", NULL);
1393 if (amend && !no_post_rewrite) {
1394 struct notes_rewrite_cfg *cfg;
1395 cfg = init_copy_notes_for_rewrite("amend");
1396 if (cfg) {
1397 copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1398 finish_copy_notes_for_rewrite(cfg);
1400 run_rewrite_hook(head_sha1, commit_sha1);
1402 if (!quiet)
1403 print_summary(prefix, commit_sha1);
1405 return 0;