Merge branch 'cb/maint-orphan-merge-noclobber'
[git/kirr.git] / builtin / commit.c
blob4fd1a1692f867e54eddd406d505e584ee0451cf8
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"
28 #include "submodule.h"
30 static const char * const builtin_commit_usage[] = {
31 "git commit [options] [--] <filepattern>...",
32 NULL
35 static const char * const builtin_status_usage[] = {
36 "git status [options] [--] <filepattern>...",
37 NULL
40 static const char implicit_ident_advice[] =
41 "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 "If the identity used for this commit is wrong, you can fix it with:\n"
49 "\n"
50 " git commit --amend --author='Your Name <you@example.com>'\n";
52 static const char empty_amend_advice[] =
53 "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 unsigned char head_sha1[20];
59 static char *use_message_buffer;
60 static const char commit_editmsg[] = "COMMIT_EDITMSG";
61 static struct lock_file index_lock; /* real index */
62 static struct lock_file false_lock; /* used only for partial commits */
63 static enum {
64 COMMIT_AS_IS = 1,
65 COMMIT_NORMAL,
66 COMMIT_PARTIAL
67 } commit_style;
69 static const char *logfile, *force_author;
70 static const char *template_file;
71 static char *edit_message, *use_message;
72 static char *author_name, *author_email, *author_date;
73 static int all, edit_flag, also, interactive, only, amend, signoff;
74 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
75 static int no_post_rewrite, allow_empty_message;
76 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
78 * The default commit message cleanup mode will remove the lines
79 * beginning with # (shell comments) and leading and trailing
80 * whitespaces (empty lines or containing only whitespaces)
81 * if editor is used, and only the whitespaces if the message
82 * is specified explicitly.
84 static enum {
85 CLEANUP_SPACE,
86 CLEANUP_NONE,
87 CLEANUP_ALL
88 } cleanup_mode;
89 static char *cleanup_arg;
91 static int use_editor = 1, initial_commit, in_merge, include_status = 1;
92 static int show_ignored_in_status;
93 static const char *only_include_assumed;
94 static struct strbuf message;
96 static int null_termination;
97 static enum {
98 STATUS_FORMAT_LONG,
99 STATUS_FORMAT_SHORT,
100 STATUS_FORMAT_PORCELAIN
101 } status_format = STATUS_FORMAT_LONG;
102 static int status_show_branch;
104 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
106 struct strbuf *buf = opt->value;
107 if (unset)
108 strbuf_setlen(buf, 0);
109 else {
110 strbuf_addstr(buf, arg);
111 strbuf_addstr(buf, "\n\n");
113 return 0;
116 static struct option builtin_commit_options[] = {
117 OPT__QUIET(&quiet, "suppress summary after successful commit"),
118 OPT__VERBOSE(&verbose, "show diff in commit message template"),
120 OPT_GROUP("Commit message options"),
121 OPT_FILENAME('F', "file", &logfile, "read log from file"),
122 OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
123 OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
124 OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
125 OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
126 OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
127 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
128 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
129 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
130 OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
131 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
132 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
133 /* end commit message options */
135 OPT_GROUP("Commit contents options"),
136 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
137 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
138 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
139 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
140 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
141 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
142 OPT_SET_INT(0, "short", &status_format, "show status concisely",
143 STATUS_FORMAT_SHORT),
144 OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
145 OPT_SET_INT(0, "porcelain", &status_format,
146 "show porcelain output format", STATUS_FORMAT_PORCELAIN),
147 OPT_BOOLEAN('z', "null", &null_termination,
148 "terminate entries with NUL"),
149 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
150 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
151 { 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" },
152 /* end commit contents options */
154 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
155 "ok to record an empty change",
156 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
157 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
158 "ok to record a change with an empty message",
159 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
161 OPT_END()
164 static void rollback_index_files(void)
166 switch (commit_style) {
167 case COMMIT_AS_IS:
168 break; /* nothing to do */
169 case COMMIT_NORMAL:
170 rollback_lock_file(&index_lock);
171 break;
172 case COMMIT_PARTIAL:
173 rollback_lock_file(&index_lock);
174 rollback_lock_file(&false_lock);
175 break;
179 static int commit_index_files(void)
181 int err = 0;
183 switch (commit_style) {
184 case COMMIT_AS_IS:
185 break; /* nothing to do */
186 case COMMIT_NORMAL:
187 err = commit_lock_file(&index_lock);
188 break;
189 case COMMIT_PARTIAL:
190 err = commit_lock_file(&index_lock);
191 rollback_lock_file(&false_lock);
192 break;
195 return err;
199 * Take a union of paths in the index and the named tree (typically, "HEAD"),
200 * and return the paths that match the given pattern in list.
202 static int list_paths(struct string_list *list, const char *with_tree,
203 const char *prefix, const char **pattern)
205 int i;
206 char *m;
208 for (i = 0; pattern[i]; i++)
210 m = xcalloc(1, i);
212 if (with_tree)
213 overlay_tree_on_cache(with_tree, prefix);
215 for (i = 0; i < active_nr; i++) {
216 struct cache_entry *ce = active_cache[i];
217 struct string_list_item *item;
219 if (ce->ce_flags & CE_UPDATE)
220 continue;
221 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
222 continue;
223 item = string_list_insert(list, ce->name);
224 if (ce_skip_worktree(ce))
225 item->util = item; /* better a valid pointer than a fake one */
228 return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
231 static void add_remove_files(struct string_list *list)
233 int i;
234 for (i = 0; i < list->nr; i++) {
235 struct stat st;
236 struct string_list_item *p = &(list->items[i]);
238 /* p->util is skip-worktree */
239 if (p->util)
240 continue;
242 if (!lstat(p->string, &st)) {
243 if (add_to_cache(p->string, &st, 0))
244 die("updating files failed");
245 } else
246 remove_file_from_cache(p->string);
250 static void create_base_index(void)
252 struct tree *tree;
253 struct unpack_trees_options opts;
254 struct tree_desc t;
256 if (initial_commit) {
257 discard_cache();
258 return;
261 memset(&opts, 0, sizeof(opts));
262 opts.head_idx = 1;
263 opts.index_only = 1;
264 opts.merge = 1;
265 opts.src_index = &the_index;
266 opts.dst_index = &the_index;
268 opts.fn = oneway_merge;
269 tree = parse_tree_indirect(head_sha1);
270 if (!tree)
271 die("failed to unpack HEAD tree object");
272 parse_tree(tree);
273 init_tree_desc(&t, tree->buffer, tree->size);
274 if (unpack_trees(1, &t, &opts))
275 exit(128); /* We've already reported the error, finish dying */
278 static void refresh_cache_or_die(int refresh_flags)
281 * refresh_flags contains REFRESH_QUIET, so the only errors
282 * are for unmerged entries.
284 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
285 die_resolve_conflict("commit");
288 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
290 int fd;
291 struct string_list partial;
292 const char **pathspec = NULL;
293 int refresh_flags = REFRESH_QUIET;
295 if (is_status)
296 refresh_flags |= REFRESH_UNMERGED;
297 if (interactive) {
298 if (interactive_add(argc, argv, prefix) != 0)
299 die("interactive add failed");
300 if (read_cache_preload(NULL) < 0)
301 die("index file corrupt");
302 commit_style = COMMIT_AS_IS;
303 return get_index_file();
306 if (*argv)
307 pathspec = get_pathspec(prefix, argv);
309 if (read_cache_preload(pathspec) < 0)
310 die("index file corrupt");
313 * Non partial, non as-is commit.
315 * (1) get the real index;
316 * (2) update the_index as necessary;
317 * (3) write the_index out to the real index (still locked);
318 * (4) return the name of the locked index file.
320 * The caller should run hooks on the locked real index, and
321 * (A) if all goes well, commit the real index;
322 * (B) on failure, rollback the real index.
324 if (all || (also && pathspec && *pathspec)) {
325 fd = hold_locked_index(&index_lock, 1);
326 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
327 refresh_cache_or_die(refresh_flags);
328 if (write_cache(fd, active_cache, active_nr) ||
329 close_lock_file(&index_lock))
330 die("unable to write new_index file");
331 commit_style = COMMIT_NORMAL;
332 return index_lock.filename;
336 * As-is commit.
338 * (1) return the name of the real index file.
340 * The caller should run hooks on the real index,
341 * and create commit from the_index.
342 * We still need to refresh the index here.
344 if (!pathspec || !*pathspec) {
345 fd = hold_locked_index(&index_lock, 1);
346 refresh_cache_or_die(refresh_flags);
347 if (active_cache_changed) {
348 if (write_cache(fd, active_cache, active_nr) ||
349 commit_locked_index(&index_lock))
350 die("unable to write new_index file");
351 } else {
352 rollback_lock_file(&index_lock);
354 commit_style = COMMIT_AS_IS;
355 return get_index_file();
359 * A partial commit.
361 * (0) find the set of affected paths;
362 * (1) get lock on the real index file;
363 * (2) update the_index with the given paths;
364 * (3) write the_index out to the real index (still locked);
365 * (4) get lock on the false index file;
366 * (5) reset the_index from HEAD;
367 * (6) update the_index the same way as (2);
368 * (7) write the_index out to the false index file;
369 * (8) return the name of the false index file (still locked);
371 * The caller should run hooks on the locked false index, and
372 * create commit from it. Then
373 * (A) if all goes well, commit the real index;
374 * (B) on failure, rollback the real index;
375 * In either case, rollback the false index.
377 commit_style = COMMIT_PARTIAL;
379 if (in_merge)
380 die("cannot do a partial commit during a merge.");
382 memset(&partial, 0, sizeof(partial));
383 partial.strdup_strings = 1;
384 if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
385 exit(1);
387 discard_cache();
388 if (read_cache() < 0)
389 die("cannot read the index");
391 fd = hold_locked_index(&index_lock, 1);
392 add_remove_files(&partial);
393 refresh_cache(REFRESH_QUIET);
394 if (write_cache(fd, active_cache, active_nr) ||
395 close_lock_file(&index_lock))
396 die("unable to write new_index file");
398 fd = hold_lock_file_for_update(&false_lock,
399 git_path("next-index-%"PRIuMAX,
400 (uintmax_t) getpid()),
401 LOCK_DIE_ON_ERROR);
403 create_base_index();
404 add_remove_files(&partial);
405 refresh_cache(REFRESH_QUIET);
407 if (write_cache(fd, active_cache, active_nr) ||
408 close_lock_file(&false_lock))
409 die("unable to write temporary index file");
411 discard_cache();
412 read_cache_from(false_lock.filename);
414 return false_lock.filename;
417 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
418 struct wt_status *s)
420 unsigned char sha1[20];
422 if (s->relative_paths)
423 s->prefix = prefix;
425 if (amend) {
426 s->amend = 1;
427 s->reference = "HEAD^1";
429 s->verbose = verbose;
430 s->index_file = index_file;
431 s->fp = fp;
432 s->nowarn = nowarn;
433 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
435 wt_status_collect(s);
437 switch (status_format) {
438 case STATUS_FORMAT_SHORT:
439 wt_shortstatus_print(s, null_termination, status_show_branch);
440 break;
441 case STATUS_FORMAT_PORCELAIN:
442 wt_porcelain_print(s, null_termination);
443 break;
444 case STATUS_FORMAT_LONG:
445 wt_status_print(s);
446 break;
449 return s->commitable;
452 static int is_a_merge(const unsigned char *sha1)
454 struct commit *commit = lookup_commit(sha1);
455 if (!commit || parse_commit(commit))
456 die("could not parse HEAD commit");
457 return !!(commit->parents && commit->parents->next);
460 static const char sign_off_header[] = "Signed-off-by: ";
462 static void determine_author_info(void)
464 char *name, *email, *date;
466 name = getenv("GIT_AUTHOR_NAME");
467 email = getenv("GIT_AUTHOR_EMAIL");
468 date = getenv("GIT_AUTHOR_DATE");
470 if (use_message && !renew_authorship) {
471 const char *a, *lb, *rb, *eol;
473 a = strstr(use_message_buffer, "\nauthor ");
474 if (!a)
475 die("invalid commit: %s", use_message);
477 lb = strchrnul(a + strlen("\nauthor "), '<');
478 rb = strchrnul(lb, '>');
479 eol = strchrnul(rb, '\n');
480 if (!*lb || !*rb || !*eol)
481 die("invalid commit: %s", use_message);
483 if (lb == a + strlen("\nauthor "))
484 /* \nauthor <foo@example.com> */
485 name = xcalloc(1, 1);
486 else
487 name = xmemdupz(a + strlen("\nauthor "),
488 (lb - strlen(" ") -
489 (a + strlen("\nauthor "))));
490 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
491 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
494 if (force_author) {
495 const char *lb = strstr(force_author, " <");
496 const char *rb = strchr(force_author, '>');
498 if (!lb || !rb)
499 die("malformed --author parameter");
500 name = xstrndup(force_author, lb - force_author);
501 email = xstrndup(lb + 2, rb - (lb + 2));
504 if (force_date)
505 date = force_date;
507 author_name = name;
508 author_email = email;
509 author_date = date;
512 static int ends_rfc2822_footer(struct strbuf *sb)
514 int ch;
515 int hit = 0;
516 int i, j, k;
517 int len = sb->len;
518 int first = 1;
519 const char *buf = sb->buf;
521 for (i = len - 1; i > 0; i--) {
522 if (hit && buf[i] == '\n')
523 break;
524 hit = (buf[i] == '\n');
527 while (i < len - 1 && buf[i] == '\n')
528 i++;
530 for (; i < len; i = k) {
531 for (k = i; k < len && buf[k] != '\n'; k++)
532 ; /* do nothing */
533 k++;
535 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
536 continue;
538 first = 0;
540 for (j = 0; i + j < len; j++) {
541 ch = buf[i + j];
542 if (ch == ':')
543 break;
544 if (isalnum(ch) ||
545 (ch == '-'))
546 continue;
547 return 0;
550 return 1;
553 static int prepare_to_commit(const char *index_file, const char *prefix,
554 struct wt_status *s)
556 struct stat statbuf;
557 int commitable, saved_color_setting;
558 struct strbuf sb = STRBUF_INIT;
559 char *buffer;
560 FILE *fp;
561 const char *hook_arg1 = NULL;
562 const char *hook_arg2 = NULL;
563 int ident_shown = 0;
565 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
566 return 0;
568 if (message.len) {
569 strbuf_addbuf(&sb, &message);
570 hook_arg1 = "message";
571 } else if (logfile && !strcmp(logfile, "-")) {
572 if (isatty(0))
573 fprintf(stderr, "(reading log message from standard input)\n");
574 if (strbuf_read(&sb, 0, 0) < 0)
575 die_errno("could not read log from standard input");
576 hook_arg1 = "message";
577 } else if (logfile) {
578 if (strbuf_read_file(&sb, logfile, 0) < 0)
579 die_errno("could not read log file '%s'",
580 logfile);
581 hook_arg1 = "message";
582 } else if (use_message) {
583 buffer = strstr(use_message_buffer, "\n\n");
584 if (!buffer || buffer[2] == '\0')
585 die("commit has empty message");
586 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
587 hook_arg1 = "commit";
588 hook_arg2 = use_message;
589 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
590 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
591 die_errno("could not read MERGE_MSG");
592 hook_arg1 = "merge";
593 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
594 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
595 die_errno("could not read SQUASH_MSG");
596 hook_arg1 = "squash";
597 } else if (template_file && !stat(template_file, &statbuf)) {
598 if (strbuf_read_file(&sb, template_file, 0) < 0)
599 die_errno("could not read '%s'", template_file);
600 hook_arg1 = "template";
604 * This final case does not modify the template message,
605 * it just sets the argument to the prepare-commit-msg hook.
607 else if (in_merge)
608 hook_arg1 = "merge";
610 fp = fopen(git_path(commit_editmsg), "w");
611 if (fp == NULL)
612 die_errno("could not open '%s'", git_path(commit_editmsg));
614 if (cleanup_mode != CLEANUP_NONE)
615 stripspace(&sb, 0);
617 if (signoff) {
618 struct strbuf sob = STRBUF_INIT;
619 int i;
621 strbuf_addstr(&sob, sign_off_header);
622 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
623 getenv("GIT_COMMITTER_EMAIL")));
624 strbuf_addch(&sob, '\n');
625 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
626 ; /* do nothing */
627 if (prefixcmp(sb.buf + i, sob.buf)) {
628 if (!i || !ends_rfc2822_footer(&sb))
629 strbuf_addch(&sb, '\n');
630 strbuf_addbuf(&sb, &sob);
632 strbuf_release(&sob);
635 if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
636 die_errno("could not write commit template");
638 strbuf_release(&sb);
640 determine_author_info();
642 /* This checks if committer ident is explicitly given */
643 git_committer_info(0);
644 if (use_editor && include_status) {
645 char *author_ident;
646 const char *committer_ident;
648 if (in_merge)
649 fprintf(fp,
650 "#\n"
651 "# It looks like you may be committing a MERGE.\n"
652 "# If this is not correct, please remove the file\n"
653 "# %s\n"
654 "# and try again.\n"
655 "#\n",
656 git_path("MERGE_HEAD"));
658 fprintf(fp,
659 "\n"
660 "# Please enter the commit message for your changes.");
661 if (cleanup_mode == CLEANUP_ALL)
662 fprintf(fp,
663 " Lines starting\n"
664 "# with '#' will be ignored, and an empty"
665 " message aborts the commit.\n");
666 else /* CLEANUP_SPACE, that is. */
667 fprintf(fp,
668 " Lines starting\n"
669 "# with '#' will be kept; you may remove them"
670 " yourself if you want to.\n"
671 "# An empty message aborts the commit.\n");
672 if (only_include_assumed)
673 fprintf(fp, "# %s\n", only_include_assumed);
675 author_ident = xstrdup(fmt_name(author_name, author_email));
676 committer_ident = fmt_name(getenv("GIT_COMMITTER_NAME"),
677 getenv("GIT_COMMITTER_EMAIL"));
678 if (strcmp(author_ident, committer_ident))
679 fprintf(fp,
680 "%s"
681 "# Author: %s\n",
682 ident_shown++ ? "" : "#\n",
683 author_ident);
684 free(author_ident);
686 if (!user_ident_sufficiently_given())
687 fprintf(fp,
688 "%s"
689 "# Committer: %s\n",
690 ident_shown++ ? "" : "#\n",
691 committer_ident);
693 if (ident_shown)
694 fprintf(fp, "#\n");
696 saved_color_setting = s->use_color;
697 s->use_color = 0;
698 commitable = run_status(fp, index_file, prefix, 1, s);
699 s->use_color = saved_color_setting;
700 } else {
701 unsigned char sha1[20];
702 const char *parent = "HEAD";
704 if (!active_nr && read_cache() < 0)
705 die("Cannot read index");
707 if (amend)
708 parent = "HEAD^1";
710 if (get_sha1(parent, sha1))
711 commitable = !!active_nr;
712 else
713 commitable = index_differs_from(parent, 0);
716 fclose(fp);
718 if (!commitable && !in_merge && !allow_empty &&
719 !(amend && is_a_merge(head_sha1))) {
720 run_status(stdout, index_file, prefix, 0, s);
721 if (amend)
722 fputs(empty_amend_advice, stderr);
723 return 0;
727 * Re-read the index as pre-commit hook could have updated it,
728 * and write it out as a tree. We must do this before we invoke
729 * the editor and after we invoke run_status above.
731 discard_cache();
732 read_cache_from(index_file);
733 if (!active_cache_tree)
734 active_cache_tree = cache_tree();
735 if (cache_tree_update(active_cache_tree,
736 active_cache, active_nr, 0, 0) < 0) {
737 error("Error building trees");
738 return 0;
741 if (run_hook(index_file, "prepare-commit-msg",
742 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
743 return 0;
745 if (use_editor) {
746 char index[PATH_MAX];
747 const char *env[2] = { NULL };
748 env[0] = index;
749 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
750 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
751 fprintf(stderr,
752 "Please supply the message using either -m or -F option.\n");
753 exit(1);
757 if (!no_verify &&
758 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
759 return 0;
762 return 1;
766 * Find out if the message in the strbuf contains only whitespace and
767 * Signed-off-by lines.
769 static int message_is_empty(struct strbuf *sb)
771 struct strbuf tmpl = STRBUF_INIT;
772 const char *nl;
773 int eol, i, start = 0;
775 if (cleanup_mode == CLEANUP_NONE && sb->len)
776 return 0;
778 /* See if the template is just a prefix of the message. */
779 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
780 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
781 if (start + tmpl.len <= sb->len &&
782 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
783 start += tmpl.len;
785 strbuf_release(&tmpl);
787 /* Check if the rest is just whitespace and Signed-of-by's. */
788 for (i = start; i < sb->len; i++) {
789 nl = memchr(sb->buf + i, '\n', sb->len - i);
790 if (nl)
791 eol = nl - sb->buf;
792 else
793 eol = sb->len;
795 if (strlen(sign_off_header) <= eol - i &&
796 !prefixcmp(sb->buf + i, sign_off_header)) {
797 i = eol;
798 continue;
800 while (i < eol)
801 if (!isspace(sb->buf[i++]))
802 return 0;
805 return 1;
808 static const char *find_author_by_nickname(const char *name)
810 struct rev_info revs;
811 struct commit *commit;
812 struct strbuf buf = STRBUF_INIT;
813 const char *av[20];
814 int ac = 0;
816 init_revisions(&revs, NULL);
817 strbuf_addf(&buf, "--author=%s", name);
818 av[++ac] = "--all";
819 av[++ac] = "-i";
820 av[++ac] = buf.buf;
821 av[++ac] = NULL;
822 setup_revisions(ac, av, &revs, NULL);
823 prepare_revision_walk(&revs);
824 commit = get_revision(&revs);
825 if (commit) {
826 struct pretty_print_context ctx = {0};
827 ctx.date_mode = DATE_NORMAL;
828 strbuf_release(&buf);
829 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
830 return strbuf_detach(&buf, NULL);
832 die("No existing author found with '%s'", name);
836 static void handle_untracked_files_arg(struct wt_status *s)
838 if (!untracked_files_arg)
839 ; /* default already initialized */
840 else if (!strcmp(untracked_files_arg, "no"))
841 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
842 else if (!strcmp(untracked_files_arg, "normal"))
843 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
844 else if (!strcmp(untracked_files_arg, "all"))
845 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
846 else
847 die("Invalid untracked files mode '%s'", untracked_files_arg);
850 static int parse_and_validate_options(int argc, const char *argv[],
851 const char * const usage[],
852 const char *prefix,
853 struct wt_status *s)
855 int f = 0;
857 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
860 if (force_author && !strchr(force_author, '>'))
861 force_author = find_author_by_nickname(force_author);
863 if (force_author && renew_authorship)
864 die("Using both --reset-author and --author does not make sense");
866 if (logfile || message.len || use_message)
867 use_editor = 0;
868 if (edit_flag)
869 use_editor = 1;
870 if (!use_editor)
871 setenv("GIT_EDITOR", ":", 1);
873 if (get_sha1("HEAD", head_sha1))
874 initial_commit = 1;
876 /* Sanity check options */
877 if (amend && initial_commit)
878 die("You have nothing to amend.");
879 if (amend && in_merge)
880 die("You are in the middle of a merge -- cannot amend.");
882 if (use_message)
883 f++;
884 if (edit_message)
885 f++;
886 if (logfile)
887 f++;
888 if (f > 1)
889 die("Only one of -c/-C/-F can be used.");
890 if (message.len && f > 0)
891 die("Option -m cannot be combined with -c/-C/-F.");
892 if (edit_message)
893 use_message = edit_message;
894 if (amend && !use_message)
895 use_message = "HEAD";
896 if (!use_message && renew_authorship)
897 die("--reset-author can be used only with -C, -c or --amend.");
898 if (use_message) {
899 unsigned char sha1[20];
900 static char utf8[] = "UTF-8";
901 const char *out_enc;
902 char *enc, *end;
903 struct commit *commit;
905 if (get_sha1(use_message, sha1))
906 die("could not lookup commit %s", use_message);
907 commit = lookup_commit_reference(sha1);
908 if (!commit || parse_commit(commit))
909 die("could not parse commit %s", use_message);
911 enc = strstr(commit->buffer, "\nencoding");
912 if (enc) {
913 end = strchr(enc + 10, '\n');
914 enc = xstrndup(enc + 10, end - (enc + 10));
915 } else {
916 enc = utf8;
918 out_enc = git_commit_encoding ? git_commit_encoding : utf8;
920 if (strcmp(out_enc, enc))
921 use_message_buffer =
922 reencode_string(commit->buffer, out_enc, enc);
925 * If we failed to reencode the buffer, just copy it
926 * byte for byte so the user can try to fix it up.
927 * This also handles the case where input and output
928 * encodings are identical.
930 if (use_message_buffer == NULL)
931 use_message_buffer = xstrdup(commit->buffer);
932 if (enc != utf8)
933 free(enc);
936 if (!!also + !!only + !!all + !!interactive > 1)
937 die("Only one of --include/--only/--all/--interactive can be used.");
938 if (argc == 0 && (also || (only && !amend)))
939 die("No paths with --include/--only does not make sense.");
940 if (argc == 0 && only && amend)
941 only_include_assumed = "Clever... amending the last one with dirty index.";
942 if (argc > 0 && !also && !only)
943 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
944 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
945 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
946 else if (!strcmp(cleanup_arg, "verbatim"))
947 cleanup_mode = CLEANUP_NONE;
948 else if (!strcmp(cleanup_arg, "whitespace"))
949 cleanup_mode = CLEANUP_SPACE;
950 else if (!strcmp(cleanup_arg, "strip"))
951 cleanup_mode = CLEANUP_ALL;
952 else
953 die("Invalid cleanup mode %s", cleanup_arg);
955 handle_untracked_files_arg(s);
957 if (all && argc > 0)
958 die("Paths with -a does not make sense.");
959 else if (interactive && argc > 0)
960 die("Paths with --interactive does not make sense.");
962 if (null_termination && status_format == STATUS_FORMAT_LONG)
963 status_format = STATUS_FORMAT_PORCELAIN;
964 if (status_format != STATUS_FORMAT_LONG)
965 dry_run = 1;
967 return argc;
970 static int dry_run_commit(int argc, const char **argv, const char *prefix,
971 struct wt_status *s)
973 int commitable;
974 const char *index_file;
976 index_file = prepare_index(argc, argv, prefix, 1);
977 commitable = run_status(stdout, index_file, prefix, 0, s);
978 rollback_index_files();
980 return commitable ? 0 : 1;
983 static int parse_status_slot(const char *var, int offset)
985 if (!strcasecmp(var+offset, "header"))
986 return WT_STATUS_HEADER;
987 if (!strcasecmp(var+offset, "updated")
988 || !strcasecmp(var+offset, "added"))
989 return WT_STATUS_UPDATED;
990 if (!strcasecmp(var+offset, "changed"))
991 return WT_STATUS_CHANGED;
992 if (!strcasecmp(var+offset, "untracked"))
993 return WT_STATUS_UNTRACKED;
994 if (!strcasecmp(var+offset, "nobranch"))
995 return WT_STATUS_NOBRANCH;
996 if (!strcasecmp(var+offset, "unmerged"))
997 return WT_STATUS_UNMERGED;
998 return -1;
1001 static int git_status_config(const char *k, const char *v, void *cb)
1003 struct wt_status *s = cb;
1005 if (!strcmp(k, "status.submodulesummary")) {
1006 int is_bool;
1007 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1008 if (is_bool && s->submodule_summary)
1009 s->submodule_summary = -1;
1010 return 0;
1012 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1013 s->use_color = git_config_colorbool(k, v, -1);
1014 return 0;
1016 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1017 int slot = parse_status_slot(k, 13);
1018 if (slot < 0)
1019 return 0;
1020 if (!v)
1021 return config_error_nonbool(k);
1022 color_parse(v, k, s->color_palette[slot]);
1023 return 0;
1025 if (!strcmp(k, "status.relativepaths")) {
1026 s->relative_paths = git_config_bool(k, v);
1027 return 0;
1029 if (!strcmp(k, "status.showuntrackedfiles")) {
1030 if (!v)
1031 return config_error_nonbool(k);
1032 else if (!strcmp(v, "no"))
1033 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1034 else if (!strcmp(v, "normal"))
1035 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1036 else if (!strcmp(v, "all"))
1037 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1038 else
1039 return error("Invalid untracked files mode '%s'", v);
1040 return 0;
1042 return git_diff_ui_config(k, v, NULL);
1045 int cmd_status(int argc, const char **argv, const char *prefix)
1047 struct wt_status s;
1048 int fd;
1049 unsigned char sha1[20];
1050 static struct option builtin_status_options[] = {
1051 OPT__VERBOSE(&verbose, "be verbose"),
1052 OPT_SET_INT('s', "short", &status_format,
1053 "show status concisely", STATUS_FORMAT_SHORT),
1054 OPT_BOOLEAN('b', "branch", &status_show_branch,
1055 "show branch information"),
1056 OPT_SET_INT(0, "porcelain", &status_format,
1057 "show porcelain output format",
1058 STATUS_FORMAT_PORCELAIN),
1059 OPT_BOOLEAN('z', "null", &null_termination,
1060 "terminate entries with NUL"),
1061 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1062 "mode",
1063 "show untracked files, optional modes: all, normal, no. (Default: all)",
1064 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1065 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1066 "show ignored files"),
1067 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1068 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1069 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1070 OPT_END(),
1073 if (null_termination && status_format == STATUS_FORMAT_LONG)
1074 status_format = STATUS_FORMAT_PORCELAIN;
1076 wt_status_prepare(&s);
1077 gitmodules_config();
1078 git_config(git_status_config, &s);
1079 in_merge = file_exists(git_path("MERGE_HEAD"));
1080 argc = parse_options(argc, argv, prefix,
1081 builtin_status_options,
1082 builtin_status_usage, 0);
1083 handle_untracked_files_arg(&s);
1084 if (show_ignored_in_status)
1085 s.show_ignored_files = 1;
1086 if (*argv)
1087 s.pathspec = get_pathspec(prefix, argv);
1089 read_cache_preload(s.pathspec);
1090 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1092 fd = hold_locked_index(&index_lock, 0);
1093 if (0 <= fd) {
1094 if (active_cache_changed &&
1095 !write_cache(fd, active_cache, active_nr))
1096 commit_locked_index(&index_lock);
1097 else
1098 rollback_lock_file(&index_lock);
1101 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1102 s.in_merge = in_merge;
1103 s.ignore_submodule_arg = ignore_submodule_arg;
1104 wt_status_collect(&s);
1106 if (s.relative_paths)
1107 s.prefix = prefix;
1108 if (s.use_color == -1)
1109 s.use_color = git_use_color_default;
1110 if (diff_use_color_default == -1)
1111 diff_use_color_default = git_use_color_default;
1113 switch (status_format) {
1114 case STATUS_FORMAT_SHORT:
1115 wt_shortstatus_print(&s, null_termination, status_show_branch);
1116 break;
1117 case STATUS_FORMAT_PORCELAIN:
1118 wt_porcelain_print(&s, null_termination);
1119 break;
1120 case STATUS_FORMAT_LONG:
1121 s.verbose = verbose;
1122 s.ignore_submodule_arg = ignore_submodule_arg;
1123 wt_status_print(&s);
1124 break;
1126 return 0;
1129 static void print_summary(const char *prefix, const unsigned char *sha1)
1131 struct rev_info rev;
1132 struct commit *commit;
1133 struct strbuf format = STRBUF_INIT;
1134 unsigned char junk_sha1[20];
1135 const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1136 struct pretty_print_context pctx = {0};
1137 struct strbuf author_ident = STRBUF_INIT;
1138 struct strbuf committer_ident = STRBUF_INIT;
1140 commit = lookup_commit(sha1);
1141 if (!commit)
1142 die("couldn't look up newly created commit");
1143 if (!commit || parse_commit(commit))
1144 die("could not parse newly created commit");
1146 strbuf_addstr(&format, "format:%h] %s");
1148 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1149 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1150 if (strbuf_cmp(&author_ident, &committer_ident)) {
1151 strbuf_addstr(&format, "\n Author: ");
1152 strbuf_addbuf_percentquote(&format, &author_ident);
1154 if (!user_ident_sufficiently_given()) {
1155 strbuf_addstr(&format, "\n Committer: ");
1156 strbuf_addbuf_percentquote(&format, &committer_ident);
1157 if (advice_implicit_identity) {
1158 strbuf_addch(&format, '\n');
1159 strbuf_addstr(&format, implicit_ident_advice);
1162 strbuf_release(&author_ident);
1163 strbuf_release(&committer_ident);
1165 init_revisions(&rev, prefix);
1166 setup_revisions(0, NULL, &rev, NULL);
1168 rev.diff = 1;
1169 rev.diffopt.output_format =
1170 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1172 rev.verbose_header = 1;
1173 rev.show_root_diff = 1;
1174 get_commit_format(format.buf, &rev);
1175 rev.always_show_header = 0;
1176 rev.diffopt.detect_rename = 1;
1177 rev.diffopt.rename_limit = 100;
1178 rev.diffopt.break_opt = 0;
1179 diff_setup_done(&rev.diffopt);
1181 printf("[%s%s ",
1182 !prefixcmp(head, "refs/heads/") ?
1183 head + 11 :
1184 !strcmp(head, "HEAD") ?
1185 "detached HEAD" :
1186 head,
1187 initial_commit ? " (root-commit)" : "");
1189 if (!log_tree_commit(&rev, commit)) {
1190 rev.always_show_header = 1;
1191 rev.use_terminator = 1;
1192 log_tree_commit(&rev, commit);
1195 strbuf_release(&format);
1198 static int git_commit_config(const char *k, const char *v, void *cb)
1200 struct wt_status *s = cb;
1202 if (!strcmp(k, "commit.template"))
1203 return git_config_pathname(&template_file, k, v);
1204 if (!strcmp(k, "commit.status")) {
1205 include_status = git_config_bool(k, v);
1206 return 0;
1209 return git_status_config(k, v, s);
1212 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1214 static int run_rewrite_hook(const unsigned char *oldsha1,
1215 const unsigned char *newsha1)
1217 /* oldsha1 SP newsha1 LF NUL */
1218 static char buf[2*40 + 3];
1219 struct child_process proc;
1220 const char *argv[3];
1221 int code;
1222 size_t n;
1224 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1225 return 0;
1227 argv[0] = git_path(post_rewrite_hook);
1228 argv[1] = "amend";
1229 argv[2] = NULL;
1231 memset(&proc, 0, sizeof(proc));
1232 proc.argv = argv;
1233 proc.in = -1;
1234 proc.stdout_to_stderr = 1;
1236 code = start_command(&proc);
1237 if (code)
1238 return code;
1239 n = snprintf(buf, sizeof(buf), "%s %s\n",
1240 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1241 write_in_full(proc.in, buf, n);
1242 close(proc.in);
1243 return finish_command(&proc);
1246 int cmd_commit(int argc, const char **argv, const char *prefix)
1248 struct strbuf sb = STRBUF_INIT;
1249 const char *index_file, *reflog_msg;
1250 char *nl, *p;
1251 unsigned char commit_sha1[20];
1252 struct ref_lock *ref_lock;
1253 struct commit_list *parents = NULL, **pptr = &parents;
1254 struct stat statbuf;
1255 int allow_fast_forward = 1;
1256 struct wt_status s;
1258 wt_status_prepare(&s);
1259 git_config(git_commit_config, &s);
1260 in_merge = file_exists(git_path("MERGE_HEAD"));
1261 s.in_merge = in_merge;
1263 if (s.use_color == -1)
1264 s.use_color = git_use_color_default;
1265 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1266 prefix, &s);
1267 if (dry_run) {
1268 if (diff_use_color_default == -1)
1269 diff_use_color_default = git_use_color_default;
1270 return dry_run_commit(argc, argv, prefix, &s);
1272 index_file = prepare_index(argc, argv, prefix, 0);
1274 /* Set up everything for writing the commit object. This includes
1275 running hooks, writing the trees, and interacting with the user. */
1276 if (!prepare_to_commit(index_file, prefix, &s)) {
1277 rollback_index_files();
1278 return 1;
1281 /* Determine parents */
1282 reflog_msg = getenv("GIT_REFLOG_ACTION");
1283 if (initial_commit) {
1284 if (!reflog_msg)
1285 reflog_msg = "commit (initial)";
1286 } else if (amend) {
1287 struct commit_list *c;
1288 struct commit *commit;
1290 if (!reflog_msg)
1291 reflog_msg = "commit (amend)";
1292 commit = lookup_commit(head_sha1);
1293 if (!commit || parse_commit(commit))
1294 die("could not parse HEAD commit");
1296 for (c = commit->parents; c; c = c->next)
1297 pptr = &commit_list_insert(c->item, pptr)->next;
1298 } else if (in_merge) {
1299 struct strbuf m = STRBUF_INIT;
1300 FILE *fp;
1302 if (!reflog_msg)
1303 reflog_msg = "commit (merge)";
1304 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1305 fp = fopen(git_path("MERGE_HEAD"), "r");
1306 if (fp == NULL)
1307 die_errno("could not open '%s' for reading",
1308 git_path("MERGE_HEAD"));
1309 while (strbuf_getline(&m, fp, '\n') != EOF) {
1310 unsigned char sha1[20];
1311 if (get_sha1_hex(m.buf, sha1) < 0)
1312 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1313 pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1315 fclose(fp);
1316 strbuf_release(&m);
1317 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1318 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1319 die_errno("could not read MERGE_MODE");
1320 if (!strcmp(sb.buf, "no-ff"))
1321 allow_fast_forward = 0;
1323 if (allow_fast_forward)
1324 parents = reduce_heads(parents);
1325 } else {
1326 if (!reflog_msg)
1327 reflog_msg = "commit";
1328 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1331 /* Finally, get the commit message */
1332 strbuf_reset(&sb);
1333 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1334 int saved_errno = errno;
1335 rollback_index_files();
1336 die("could not read commit message: %s", strerror(saved_errno));
1339 /* Truncate the message just before the diff, if any. */
1340 if (verbose) {
1341 p = strstr(sb.buf, "\ndiff --git ");
1342 if (p != NULL)
1343 strbuf_setlen(&sb, p - sb.buf + 1);
1346 if (cleanup_mode != CLEANUP_NONE)
1347 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1348 if (message_is_empty(&sb) && !allow_empty_message) {
1349 rollback_index_files();
1350 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1351 exit(1);
1354 if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1355 fmt_ident(author_name, author_email, author_date,
1356 IDENT_ERROR_ON_NO_NAME))) {
1357 rollback_index_files();
1358 die("failed to write commit object");
1361 ref_lock = lock_any_ref_for_update("HEAD",
1362 initial_commit ? NULL : head_sha1,
1365 nl = strchr(sb.buf, '\n');
1366 if (nl)
1367 strbuf_setlen(&sb, nl + 1 - sb.buf);
1368 else
1369 strbuf_addch(&sb, '\n');
1370 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1371 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1373 if (!ref_lock) {
1374 rollback_index_files();
1375 die("cannot lock HEAD ref");
1377 if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1378 rollback_index_files();
1379 die("cannot update HEAD ref");
1382 unlink(git_path("MERGE_HEAD"));
1383 unlink(git_path("MERGE_MSG"));
1384 unlink(git_path("MERGE_MODE"));
1385 unlink(git_path("SQUASH_MSG"));
1387 if (commit_index_files())
1388 die ("Repository has been updated, but unable to write\n"
1389 "new_index file. Check that disk is not full or quota is\n"
1390 "not exceeded, and then \"git reset HEAD\" to recover.");
1392 rerere(0);
1393 run_hook(get_index_file(), "post-commit", NULL);
1394 if (amend && !no_post_rewrite) {
1395 struct notes_rewrite_cfg *cfg;
1396 cfg = init_copy_notes_for_rewrite("amend");
1397 if (cfg) {
1398 copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1399 finish_copy_notes_for_rewrite(cfg);
1401 run_rewrite_hook(head_sha1, commit_sha1);
1403 if (!quiet)
1404 print_summary(prefix, commit_sha1);
1406 return 0;