Merge branch 'rs/ref-transaction-1'
[git/git.git] / builtin / commit.c
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 */
7
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"
30 #include "column.h"
31 #include "sequencer.h"
32 #include "notes-utils.h"
33 #include "mailmap.h"
34
35 static const char * const builtin_commit_usage[] = {
36 N_("git commit [options] [--] <pathspec>..."),
37 NULL
38 };
39
40 static const char * const builtin_status_usage[] = {
41 N_("git status [options] [--] <pathspec>..."),
42 NULL
43 };
44
45 static const char implicit_ident_advice_noconfig[] =
46 N_("Your name and email address were configured automatically based\n"
47 "on your username and hostname. Please check that they are accurate.\n"
48 "You can suppress this message by setting them explicitly. Run the\n"
49 "following command and follow the instructions in your editor to edit\n"
50 "your configuration file:\n"
51 "\n"
52 " git config --global --edit\n"
53 "\n"
54 "After doing this, you may fix the identity used for this commit with:\n"
55 "\n"
56 " git commit --amend --reset-author\n");
57
58 static const char implicit_ident_advice_config[] =
59 N_("Your name and email address were configured automatically based\n"
60 "on your username and hostname. Please check that they are accurate.\n"
61 "You can suppress this message by setting them explicitly:\n"
62 "\n"
63 " git config --global user.name \"Your Name\"\n"
64 " git config --global user.email you@example.com\n"
65 "\n"
66 "After doing this, you may fix the identity used for this commit with:\n"
67 "\n"
68 " git commit --amend --reset-author\n");
69
70 static const char empty_amend_advice[] =
71 N_("You asked to amend the most recent commit, but doing so would make\n"
72 "it empty. You can repeat your command with --allow-empty, or you can\n"
73 "remove the commit entirely with \"git reset HEAD^\".\n");
74
75 static const char empty_cherry_pick_advice[] =
76 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
77 "If you wish to commit it anyway, use:\n"
78 "\n"
79 " git commit --allow-empty\n"
80 "\n");
81
82 static const char empty_cherry_pick_advice_single[] =
83 N_("Otherwise, please use 'git reset'\n");
84
85 static const char empty_cherry_pick_advice_multi[] =
86 N_("If you wish to skip this commit, use:\n"
87 "\n"
88 " git reset\n"
89 "\n"
90 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
91 "the remaining commits.\n");
92
93 static const char *use_message_buffer;
94 static const char commit_editmsg[] = "COMMIT_EDITMSG";
95 static struct lock_file index_lock; /* real index */
96 static struct lock_file false_lock; /* used only for partial commits */
97 static enum {
98 COMMIT_AS_IS = 1,
99 COMMIT_NORMAL,
100 COMMIT_PARTIAL
101 } commit_style;
102
103 static const char *logfile, *force_author;
104 static const char *template_file;
105 /*
106 * The _message variables are commit names from which to take
107 * the commit message and/or authorship.
108 */
109 static const char *author_message, *author_message_buffer;
110 static char *edit_message, *use_message;
111 static char *fixup_message, *squash_message;
112 static int all, also, interactive, patch_interactive, only, amend, signoff;
113 static int edit_flag = -1; /* unspecified */
114 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
115 static int no_post_rewrite, allow_empty_message;
116 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
117 static char *sign_commit;
118
119 /*
120 * The default commit message cleanup mode will remove the lines
121 * beginning with # (shell comments) and leading and trailing
122 * whitespaces (empty lines or containing only whitespaces)
123 * if editor is used, and only the whitespaces if the message
124 * is specified explicitly.
125 */
126 static enum {
127 CLEANUP_SPACE,
128 CLEANUP_NONE,
129 CLEANUP_SCISSORS,
130 CLEANUP_ALL
131 } cleanup_mode;
132 static const char *cleanup_arg;
133
134 static enum commit_whence whence;
135 static int sequencer_in_use;
136 static int use_editor = 1, include_status = 1;
137 static int show_ignored_in_status, have_option_m;
138 static const char *only_include_assumed;
139 static struct strbuf message = STRBUF_INIT;
140
141 static enum status_format {
142 STATUS_FORMAT_NONE = 0,
143 STATUS_FORMAT_LONG,
144 STATUS_FORMAT_SHORT,
145 STATUS_FORMAT_PORCELAIN,
146
147 STATUS_FORMAT_UNSPECIFIED
148 } status_format = STATUS_FORMAT_UNSPECIFIED;
149
150 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
151 {
152 struct strbuf *buf = opt->value;
153 if (unset) {
154 have_option_m = 0;
155 strbuf_setlen(buf, 0);
156 } else {
157 have_option_m = 1;
158 if (buf->len)
159 strbuf_addch(buf, '\n');
160 strbuf_addstr(buf, arg);
161 strbuf_complete_line(buf);
162 }
163 return 0;
164 }
165
166 static void determine_whence(struct wt_status *s)
167 {
168 if (file_exists(git_path("MERGE_HEAD")))
169 whence = FROM_MERGE;
170 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
171 whence = FROM_CHERRY_PICK;
172 if (file_exists(git_path("sequencer")))
173 sequencer_in_use = 1;
174 }
175 else
176 whence = FROM_COMMIT;
177 if (s)
178 s->whence = whence;
179 }
180
181 static void status_init_config(struct wt_status *s, config_fn_t fn)
182 {
183 wt_status_prepare(s);
184 gitmodules_config();
185 git_config(fn, s);
186 determine_whence(s);
187 s->hints = advice_status_hints; /* must come after git_config() */
188 }
189
190 static void rollback_index_files(void)
191 {
192 switch (commit_style) {
193 case COMMIT_AS_IS:
194 break; /* nothing to do */
195 case COMMIT_NORMAL:
196 rollback_lock_file(&index_lock);
197 break;
198 case COMMIT_PARTIAL:
199 rollback_lock_file(&index_lock);
200 rollback_lock_file(&false_lock);
201 break;
202 }
203 }
204
205 static int commit_index_files(void)
206 {
207 int err = 0;
208
209 switch (commit_style) {
210 case COMMIT_AS_IS:
211 break; /* nothing to do */
212 case COMMIT_NORMAL:
213 err = commit_lock_file(&index_lock);
214 break;
215 case COMMIT_PARTIAL:
216 err = commit_lock_file(&index_lock);
217 rollback_lock_file(&false_lock);
218 break;
219 }
220
221 return err;
222 }
223
224 /*
225 * Take a union of paths in the index and the named tree (typically, "HEAD"),
226 * and return the paths that match the given pattern in list.
227 */
228 static int list_paths(struct string_list *list, const char *with_tree,
229 const char *prefix, const struct pathspec *pattern)
230 {
231 int i;
232 char *m;
233
234 if (!pattern->nr)
235 return 0;
236
237 m = xcalloc(1, pattern->nr);
238
239 if (with_tree) {
240 char *max_prefix = common_prefix(pattern);
241 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
242 free(max_prefix);
243 }
244
245 for (i = 0; i < active_nr; i++) {
246 const struct cache_entry *ce = active_cache[i];
247 struct string_list_item *item;
248
249 if (ce->ce_flags & CE_UPDATE)
250 continue;
251 if (!ce_path_match(ce, pattern, m))
252 continue;
253 item = string_list_insert(list, ce->name);
254 if (ce_skip_worktree(ce))
255 item->util = item; /* better a valid pointer than a fake one */
256 }
257
258 return report_path_error(m, pattern, prefix);
259 }
260
261 static void add_remove_files(struct string_list *list)
262 {
263 int i;
264 for (i = 0; i < list->nr; i++) {
265 struct stat st;
266 struct string_list_item *p = &(list->items[i]);
267
268 /* p->util is skip-worktree */
269 if (p->util)
270 continue;
271
272 if (!lstat(p->string, &st)) {
273 if (add_to_cache(p->string, &st, 0))
274 die(_("updating files failed"));
275 } else
276 remove_file_from_cache(p->string);
277 }
278 }
279
280 static void create_base_index(const struct commit *current_head)
281 {
282 struct tree *tree;
283 struct unpack_trees_options opts;
284 struct tree_desc t;
285
286 if (!current_head) {
287 discard_cache();
288 return;
289 }
290
291 memset(&opts, 0, sizeof(opts));
292 opts.head_idx = 1;
293 opts.index_only = 1;
294 opts.merge = 1;
295 opts.src_index = &the_index;
296 opts.dst_index = &the_index;
297
298 opts.fn = oneway_merge;
299 tree = parse_tree_indirect(current_head->object.sha1);
300 if (!tree)
301 die(_("failed to unpack HEAD tree object"));
302 parse_tree(tree);
303 init_tree_desc(&t, tree->buffer, tree->size);
304 if (unpack_trees(1, &t, &opts))
305 exit(128); /* We've already reported the error, finish dying */
306 }
307
308 static void refresh_cache_or_die(int refresh_flags)
309 {
310 /*
311 * refresh_flags contains REFRESH_QUIET, so the only errors
312 * are for unmerged entries.
313 */
314 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
315 die_resolve_conflict("commit");
316 }
317
318 static char *prepare_index(int argc, const char **argv, const char *prefix,
319 const struct commit *current_head, int is_status)
320 {
321 struct string_list partial;
322 struct pathspec pathspec;
323 int refresh_flags = REFRESH_QUIET;
324
325 if (is_status)
326 refresh_flags |= REFRESH_UNMERGED;
327 parse_pathspec(&pathspec, 0,
328 PATHSPEC_PREFER_FULL,
329 prefix, argv);
330
331 if (read_cache_preload(&pathspec) < 0)
332 die(_("index file corrupt"));
333
334 if (interactive) {
335 char *old_index_env = NULL;
336 hold_locked_index(&index_lock, 1);
337
338 refresh_cache_or_die(refresh_flags);
339
340 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
341 die(_("unable to create temporary index"));
342
343 old_index_env = getenv(INDEX_ENVIRONMENT);
344 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
345
346 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
347 die(_("interactive add failed"));
348
349 if (old_index_env && *old_index_env)
350 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
351 else
352 unsetenv(INDEX_ENVIRONMENT);
353
354 discard_cache();
355 read_cache_from(index_lock.filename);
356
357 commit_style = COMMIT_NORMAL;
358 return index_lock.filename;
359 }
360
361 /*
362 * Non partial, non as-is commit.
363 *
364 * (1) get the real index;
365 * (2) update the_index as necessary;
366 * (3) write the_index out to the real index (still locked);
367 * (4) return the name of the locked index file.
368 *
369 * The caller should run hooks on the locked real index, and
370 * (A) if all goes well, commit the real index;
371 * (B) on failure, rollback the real index.
372 */
373 if (all || (also && pathspec.nr)) {
374 hold_locked_index(&index_lock, 1);
375 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
376 refresh_cache_or_die(refresh_flags);
377 update_main_cache_tree(WRITE_TREE_SILENT);
378 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
379 die(_("unable to write new_index file"));
380 commit_style = COMMIT_NORMAL;
381 return index_lock.filename;
382 }
383
384 /*
385 * As-is commit.
386 *
387 * (1) return the name of the real index file.
388 *
389 * The caller should run hooks on the real index,
390 * and create commit from the_index.
391 * We still need to refresh the index here.
392 */
393 if (!only && !pathspec.nr) {
394 hold_locked_index(&index_lock, 1);
395 refresh_cache_or_die(refresh_flags);
396 if (active_cache_changed) {
397 update_main_cache_tree(WRITE_TREE_SILENT);
398 if (write_locked_index(&the_index, &index_lock,
399 COMMIT_LOCK))
400 die(_("unable to write new_index file"));
401 } else {
402 rollback_lock_file(&index_lock);
403 }
404 commit_style = COMMIT_AS_IS;
405 return get_index_file();
406 }
407
408 /*
409 * A partial commit.
410 *
411 * (0) find the set of affected paths;
412 * (1) get lock on the real index file;
413 * (2) update the_index with the given paths;
414 * (3) write the_index out to the real index (still locked);
415 * (4) get lock on the false index file;
416 * (5) reset the_index from HEAD;
417 * (6) update the_index the same way as (2);
418 * (7) write the_index out to the false index file;
419 * (8) return the name of the false index file (still locked);
420 *
421 * The caller should run hooks on the locked false index, and
422 * create commit from it. Then
423 * (A) if all goes well, commit the real index;
424 * (B) on failure, rollback the real index;
425 * In either case, rollback the false index.
426 */
427 commit_style = COMMIT_PARTIAL;
428
429 if (whence != FROM_COMMIT) {
430 if (whence == FROM_MERGE)
431 die(_("cannot do a partial commit during a merge."));
432 else if (whence == FROM_CHERRY_PICK)
433 die(_("cannot do a partial commit during a cherry-pick."));
434 }
435
436 string_list_init(&partial, 1);
437 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
438 exit(1);
439
440 discard_cache();
441 if (read_cache() < 0)
442 die(_("cannot read the index"));
443
444 hold_locked_index(&index_lock, 1);
445 add_remove_files(&partial);
446 refresh_cache(REFRESH_QUIET);
447 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
448 die(_("unable to write new_index file"));
449
450 hold_lock_file_for_update(&false_lock,
451 git_path("next-index-%"PRIuMAX,
452 (uintmax_t) getpid()),
453 LOCK_DIE_ON_ERROR);
454
455 create_base_index(current_head);
456 add_remove_files(&partial);
457 refresh_cache(REFRESH_QUIET);
458
459 if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))
460 die(_("unable to write temporary index file"));
461
462 discard_cache();
463 read_cache_from(false_lock.filename);
464
465 return false_lock.filename;
466 }
467
468 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
469 struct wt_status *s)
470 {
471 unsigned char sha1[20];
472
473 if (s->relative_paths)
474 s->prefix = prefix;
475
476 if (amend) {
477 s->amend = 1;
478 s->reference = "HEAD^1";
479 }
480 s->verbose = verbose;
481 s->index_file = index_file;
482 s->fp = fp;
483 s->nowarn = nowarn;
484 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
485
486 wt_status_collect(s);
487
488 switch (status_format) {
489 case STATUS_FORMAT_SHORT:
490 wt_shortstatus_print(s);
491 break;
492 case STATUS_FORMAT_PORCELAIN:
493 wt_porcelain_print(s);
494 break;
495 case STATUS_FORMAT_UNSPECIFIED:
496 die("BUG: finalize_deferred_config() should have been called");
497 break;
498 case STATUS_FORMAT_NONE:
499 case STATUS_FORMAT_LONG:
500 wt_status_print(s);
501 break;
502 }
503
504 return s->commitable;
505 }
506
507 static int is_a_merge(const struct commit *current_head)
508 {
509 return !!(current_head->parents && current_head->parents->next);
510 }
511
512 static void export_one(const char *var, const char *s, const char *e, int hack)
513 {
514 struct strbuf buf = STRBUF_INIT;
515 if (hack)
516 strbuf_addch(&buf, hack);
517 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
518 setenv(var, buf.buf, 1);
519 strbuf_release(&buf);
520 }
521
522 static int sane_ident_split(struct ident_split *person)
523 {
524 if (!person->name_begin || !person->name_end ||
525 person->name_begin == person->name_end)
526 return 0; /* no human readable name */
527 if (!person->mail_begin || !person->mail_end ||
528 person->mail_begin == person->mail_end)
529 return 0; /* no usable mail */
530 if (!person->date_begin || !person->date_end ||
531 !person->tz_begin || !person->tz_end)
532 return 0;
533 return 1;
534 }
535
536 static int parse_force_date(const char *in, char *out, int len)
537 {
538 if (len < 1)
539 return -1;
540 *out++ = '@';
541 len--;
542
543 if (parse_date(in, out, len) < 0) {
544 int errors = 0;
545 unsigned long t = approxidate_careful(in, &errors);
546 if (errors)
547 return -1;
548 snprintf(out, len, "%lu", t);
549 }
550
551 return 0;
552 }
553
554 static void determine_author_info(struct strbuf *author_ident)
555 {
556 char *name, *email, *date;
557 struct ident_split author;
558 char date_buf[64];
559
560 name = getenv("GIT_AUTHOR_NAME");
561 email = getenv("GIT_AUTHOR_EMAIL");
562 date = getenv("GIT_AUTHOR_DATE");
563
564 if (author_message) {
565 const char *a, *lb, *rb, *eol;
566 size_t len;
567
568 a = strstr(author_message_buffer, "\nauthor ");
569 if (!a)
570 die(_("invalid commit: %s"), author_message);
571
572 lb = strchrnul(a + strlen("\nauthor "), '<');
573 rb = strchrnul(lb, '>');
574 eol = strchrnul(rb, '\n');
575 if (!*lb || !*rb || !*eol)
576 die(_("invalid commit: %s"), author_message);
577
578 if (lb == a + strlen("\nauthor "))
579 /* \nauthor <foo@example.com> */
580 name = xcalloc(1, 1);
581 else
582 name = xmemdupz(a + strlen("\nauthor "),
583 (lb - strlen(" ") -
584 (a + strlen("\nauthor "))));
585 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
586 len = eol - (rb + strlen("> "));
587 date = xmalloc(len + 2);
588 *date = '@';
589 memcpy(date + 1, rb + strlen("> "), len);
590 date[len + 1] = '\0';
591 }
592
593 if (force_author) {
594 const char *lb = strstr(force_author, " <");
595 const char *rb = strchr(force_author, '>');
596
597 if (!lb || !rb)
598 die(_("malformed --author parameter"));
599 name = xstrndup(force_author, lb - force_author);
600 email = xstrndup(lb + 2, rb - (lb + 2));
601 }
602
603 if (force_date) {
604 if (parse_force_date(force_date, date_buf, sizeof(date_buf)))
605 die(_("invalid date format: %s"), force_date);
606 date = date_buf;
607 }
608
609 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
610 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
611 sane_ident_split(&author)) {
612 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
613 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
614 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
615 }
616 }
617
618 static void split_ident_or_die(struct ident_split *id, const struct strbuf *buf)
619 {
620 if (split_ident_line(id, buf->buf, buf->len) ||
621 !sane_ident_split(id))
622 die(_("Malformed ident string: '%s'"), buf->buf);
623 }
624
625 static int author_date_is_interesting(void)
626 {
627 return author_message || force_date;
628 }
629
630 static void adjust_comment_line_char(const struct strbuf *sb)
631 {
632 char candidates[] = "#;@!$%^&|:";
633 char *candidate;
634 const char *p;
635
636 comment_line_char = candidates[0];
637 if (!memchr(sb->buf, comment_line_char, sb->len))
638 return;
639
640 p = sb->buf;
641 candidate = strchr(candidates, *p);
642 if (candidate)
643 *candidate = ' ';
644 for (p = sb->buf; *p; p++) {
645 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
646 candidate = strchr(candidates, p[1]);
647 if (candidate)
648 *candidate = ' ';
649 }
650 }
651
652 for (p = candidates; *p == ' '; p++)
653 ;
654 if (!*p)
655 die(_("unable to select a comment character that is not used\n"
656 "in the current commit message"));
657 comment_line_char = *p;
658 }
659
660 static int prepare_to_commit(const char *index_file, const char *prefix,
661 struct commit *current_head,
662 struct wt_status *s,
663 struct strbuf *author_ident)
664 {
665 struct stat statbuf;
666 struct strbuf committer_ident = STRBUF_INIT;
667 int commitable;
668 struct strbuf sb = STRBUF_INIT;
669 const char *hook_arg1 = NULL;
670 const char *hook_arg2 = NULL;
671 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
672 int old_display_comment_prefix;
673
674 /* This checks and barfs if author is badly specified */
675 determine_author_info(author_ident);
676
677 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
678 return 0;
679
680 if (squash_message) {
681 /*
682 * Insert the proper subject line before other commit
683 * message options add their content.
684 */
685 if (use_message && !strcmp(use_message, squash_message))
686 strbuf_addstr(&sb, "squash! ");
687 else {
688 struct pretty_print_context ctx = {0};
689 struct commit *c;
690 c = lookup_commit_reference_by_name(squash_message);
691 if (!c)
692 die(_("could not lookup commit %s"), squash_message);
693 ctx.output_encoding = get_commit_output_encoding();
694 format_commit_message(c, "squash! %s\n\n", &sb,
695 &ctx);
696 }
697 }
698
699 if (message.len) {
700 strbuf_addbuf(&sb, &message);
701 hook_arg1 = "message";
702 } else if (logfile && !strcmp(logfile, "-")) {
703 if (isatty(0))
704 fprintf(stderr, _("(reading log message from standard input)\n"));
705 if (strbuf_read(&sb, 0, 0) < 0)
706 die_errno(_("could not read log from standard input"));
707 hook_arg1 = "message";
708 } else if (logfile) {
709 if (strbuf_read_file(&sb, logfile, 0) < 0)
710 die_errno(_("could not read log file '%s'"),
711 logfile);
712 hook_arg1 = "message";
713 } else if (use_message) {
714 char *buffer;
715 buffer = strstr(use_message_buffer, "\n\n");
716 if (buffer)
717 strbuf_addstr(&sb, buffer + 2);
718 hook_arg1 = "commit";
719 hook_arg2 = use_message;
720 } else if (fixup_message) {
721 struct pretty_print_context ctx = {0};
722 struct commit *commit;
723 commit = lookup_commit_reference_by_name(fixup_message);
724 if (!commit)
725 die(_("could not lookup commit %s"), fixup_message);
726 ctx.output_encoding = get_commit_output_encoding();
727 format_commit_message(commit, "fixup! %s\n\n",
728 &sb, &ctx);
729 hook_arg1 = "message";
730 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
731 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
732 die_errno(_("could not read MERGE_MSG"));
733 hook_arg1 = "merge";
734 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
735 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
736 die_errno(_("could not read SQUASH_MSG"));
737 hook_arg1 = "squash";
738 } else if (template_file) {
739 if (strbuf_read_file(&sb, template_file, 0) < 0)
740 die_errno(_("could not read '%s'"), template_file);
741 hook_arg1 = "template";
742 clean_message_contents = 0;
743 }
744
745 /*
746 * The remaining cases don't modify the template message, but
747 * just set the argument(s) to the prepare-commit-msg hook.
748 */
749 else if (whence == FROM_MERGE)
750 hook_arg1 = "merge";
751 else if (whence == FROM_CHERRY_PICK) {
752 hook_arg1 = "commit";
753 hook_arg2 = "CHERRY_PICK_HEAD";
754 }
755
756 if (squash_message) {
757 /*
758 * If squash_commit was used for the commit subject,
759 * then we're possibly hijacking other commit log options.
760 * Reset the hook args to tell the real story.
761 */
762 hook_arg1 = "message";
763 hook_arg2 = "";
764 }
765
766 s->fp = fopen(git_path(commit_editmsg), "w");
767 if (s->fp == NULL)
768 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
769
770 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
771 old_display_comment_prefix = s->display_comment_prefix;
772 s->display_comment_prefix = 1;
773
774 /*
775 * Most hints are counter-productive when the commit has
776 * already started.
777 */
778 s->hints = 0;
779
780 if (clean_message_contents)
781 stripspace(&sb, 0);
782
783 if (signoff) {
784 /*
785 * See if we have a Conflicts: block at the end. If yes, count
786 * its size, so we can ignore it.
787 */
788 int ignore_footer = 0;
789 int i, eol, previous = 0;
790 const char *nl;
791
792 for (i = 0; i < sb.len; i++) {
793 nl = memchr(sb.buf + i, '\n', sb.len - i);
794 if (nl)
795 eol = nl - sb.buf;
796 else
797 eol = sb.len;
798 if (starts_with(sb.buf + previous, "\nConflicts:\n")) {
799 ignore_footer = sb.len - previous;
800 break;
801 }
802 while (i < eol)
803 i++;
804 previous = eol;
805 }
806
807 append_signoff(&sb, ignore_footer, 0);
808 }
809
810 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
811 die_errno(_("could not write commit template"));
812
813 if (auto_comment_line_char)
814 adjust_comment_line_char(&sb);
815 strbuf_release(&sb);
816
817 /* This checks if committer ident is explicitly given */
818 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
819 if (use_editor && include_status) {
820 int ident_shown = 0;
821 int saved_color_setting;
822 struct ident_split ci, ai;
823
824 if (whence != FROM_COMMIT) {
825 if (cleanup_mode == CLEANUP_SCISSORS)
826 wt_status_add_cut_line(s->fp);
827 status_printf_ln(s, GIT_COLOR_NORMAL,
828 whence == FROM_MERGE
829 ? _("\n"
830 "It looks like you may be committing a merge.\n"
831 "If this is not correct, please remove the file\n"
832 " %s\n"
833 "and try again.\n")
834 : _("\n"
835 "It looks like you may be committing a cherry-pick.\n"
836 "If this is not correct, please remove the file\n"
837 " %s\n"
838 "and try again.\n"),
839 git_path(whence == FROM_MERGE
840 ? "MERGE_HEAD"
841 : "CHERRY_PICK_HEAD"));
842 }
843
844 fprintf(s->fp, "\n");
845 if (cleanup_mode == CLEANUP_ALL)
846 status_printf(s, GIT_COLOR_NORMAL,
847 _("Please enter the commit message for your changes."
848 " Lines starting\nwith '%c' will be ignored, and an empty"
849 " message aborts the commit.\n"), comment_line_char);
850 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
851 wt_status_add_cut_line(s->fp);
852 else /* CLEANUP_SPACE, that is. */
853 status_printf(s, GIT_COLOR_NORMAL,
854 _("Please enter the commit message for your changes."
855 " Lines starting\n"
856 "with '%c' will be kept; you may remove them"
857 " yourself if you want to.\n"
858 "An empty message aborts the commit.\n"), comment_line_char);
859 if (only_include_assumed)
860 status_printf_ln(s, GIT_COLOR_NORMAL,
861 "%s", only_include_assumed);
862
863 split_ident_or_die(&ai, author_ident);
864 split_ident_or_die(&ci, &committer_ident);
865
866 if (ident_cmp(&ai, &ci))
867 status_printf_ln(s, GIT_COLOR_NORMAL,
868 _("%s"
869 "Author: %.*s <%.*s>"),
870 ident_shown++ ? "" : "\n",
871 (int)(ai.name_end - ai.name_begin), ai.name_begin,
872 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
873
874 if (author_date_is_interesting())
875 status_printf_ln(s, GIT_COLOR_NORMAL,
876 _("%s"
877 "Date: %s"),
878 ident_shown++ ? "" : "\n",
879 show_ident_date(&ai, DATE_NORMAL));
880
881 if (!committer_ident_sufficiently_given())
882 status_printf_ln(s, GIT_COLOR_NORMAL,
883 _("%s"
884 "Committer: %.*s <%.*s>"),
885 ident_shown++ ? "" : "\n",
886 (int)(ci.name_end - ci.name_begin), ci.name_begin,
887 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
888
889 if (ident_shown)
890 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
891
892 saved_color_setting = s->use_color;
893 s->use_color = 0;
894 commitable = run_status(s->fp, index_file, prefix, 1, s);
895 s->use_color = saved_color_setting;
896 } else {
897 unsigned char sha1[20];
898 const char *parent = "HEAD";
899
900 if (!active_nr && read_cache() < 0)
901 die(_("Cannot read index"));
902
903 if (amend)
904 parent = "HEAD^1";
905
906 if (get_sha1(parent, sha1))
907 commitable = !!active_nr;
908 else {
909 /*
910 * Unless the user did explicitly request a submodule
911 * ignore mode by passing a command line option we do
912 * not ignore any changed submodule SHA-1s when
913 * comparing index and parent, no matter what is
914 * configured. Otherwise we won't commit any
915 * submodules which were manually staged, which would
916 * be really confusing.
917 */
918 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
919 if (ignore_submodule_arg &&
920 !strcmp(ignore_submodule_arg, "all"))
921 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
922 commitable = index_differs_from(parent, diff_flags);
923 }
924 }
925 strbuf_release(&committer_ident);
926
927 fclose(s->fp);
928
929 /*
930 * Reject an attempt to record a non-merge empty commit without
931 * explicit --allow-empty. In the cherry-pick case, it may be
932 * empty due to conflict resolution, which the user should okay.
933 */
934 if (!commitable && whence != FROM_MERGE && !allow_empty &&
935 !(amend && is_a_merge(current_head))) {
936 s->display_comment_prefix = old_display_comment_prefix;
937 run_status(stdout, index_file, prefix, 0, s);
938 if (amend)
939 fputs(_(empty_amend_advice), stderr);
940 else if (whence == FROM_CHERRY_PICK) {
941 fputs(_(empty_cherry_pick_advice), stderr);
942 if (!sequencer_in_use)
943 fputs(_(empty_cherry_pick_advice_single), stderr);
944 else
945 fputs(_(empty_cherry_pick_advice_multi), stderr);
946 }
947 return 0;
948 }
949
950 /*
951 * Re-read the index as pre-commit hook could have updated it,
952 * and write it out as a tree. We must do this before we invoke
953 * the editor and after we invoke run_status above.
954 */
955 discard_cache();
956 read_cache_from(index_file);
957 if (update_main_cache_tree(0)) {
958 error(_("Error building trees"));
959 return 0;
960 }
961
962 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
963 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
964 return 0;
965
966 if (use_editor) {
967 char index[PATH_MAX];
968 const char *env[2] = { NULL };
969 env[0] = index;
970 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
971 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
972 fprintf(stderr,
973 _("Please supply the message using either -m or -F option.\n"));
974 exit(1);
975 }
976 }
977
978 if (!no_verify &&
979 run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
980 return 0;
981 }
982
983 return 1;
984 }
985
986 static int rest_is_empty(struct strbuf *sb, int start)
987 {
988 int i, eol;
989 const char *nl;
990
991 /* Check if the rest is just whitespace and Signed-of-by's. */
992 for (i = start; i < sb->len; i++) {
993 nl = memchr(sb->buf + i, '\n', sb->len - i);
994 if (nl)
995 eol = nl - sb->buf;
996 else
997 eol = sb->len;
998
999 if (strlen(sign_off_header) <= eol - i &&
1000 starts_with(sb->buf + i, sign_off_header)) {
1001 i = eol;
1002 continue;
1003 }
1004 while (i < eol)
1005 if (!isspace(sb->buf[i++]))
1006 return 0;
1007 }
1008
1009 return 1;
1010 }
1011
1012 /*
1013 * Find out if the message in the strbuf contains only whitespace and
1014 * Signed-off-by lines.
1015 */
1016 static int message_is_empty(struct strbuf *sb)
1017 {
1018 if (cleanup_mode == CLEANUP_NONE && sb->len)
1019 return 0;
1020 return rest_is_empty(sb, 0);
1021 }
1022
1023 /*
1024 * See if the user edited the message in the editor or left what
1025 * was in the template intact
1026 */
1027 static int template_untouched(struct strbuf *sb)
1028 {
1029 struct strbuf tmpl = STRBUF_INIT;
1030 const char *start;
1031
1032 if (cleanup_mode == CLEANUP_NONE && sb->len)
1033 return 0;
1034
1035 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1036 return 0;
1037
1038 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1039 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1040 start = sb->buf;
1041 strbuf_release(&tmpl);
1042 return rest_is_empty(sb, start - sb->buf);
1043 }
1044
1045 static const char *find_author_by_nickname(const char *name)
1046 {
1047 struct rev_info revs;
1048 struct commit *commit;
1049 struct strbuf buf = STRBUF_INIT;
1050 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1051 const char *av[20];
1052 int ac = 0;
1053
1054 init_revisions(&revs, NULL);
1055 strbuf_addf(&buf, "--author=%s", name);
1056 av[++ac] = "--all";
1057 av[++ac] = "-i";
1058 av[++ac] = buf.buf;
1059 av[++ac] = NULL;
1060 setup_revisions(ac, av, &revs, NULL);
1061 revs.mailmap = &mailmap;
1062 read_mailmap(revs.mailmap, NULL);
1063
1064 if (prepare_revision_walk(&revs))
1065 die(_("revision walk setup failed"));
1066 commit = get_revision(&revs);
1067 if (commit) {
1068 struct pretty_print_context ctx = {0};
1069 ctx.date_mode = DATE_NORMAL;
1070 strbuf_release(&buf);
1071 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1072 clear_mailmap(&mailmap);
1073 return strbuf_detach(&buf, NULL);
1074 }
1075 die(_("No existing author found with '%s'"), name);
1076 }
1077
1078
1079 static void handle_untracked_files_arg(struct wt_status *s)
1080 {
1081 if (!untracked_files_arg)
1082 ; /* default already initialized */
1083 else if (!strcmp(untracked_files_arg, "no"))
1084 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1085 else if (!strcmp(untracked_files_arg, "normal"))
1086 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1087 else if (!strcmp(untracked_files_arg, "all"))
1088 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1089 else
1090 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1091 }
1092
1093 static const char *read_commit_message(const char *name)
1094 {
1095 const char *out_enc;
1096 struct commit *commit;
1097
1098 commit = lookup_commit_reference_by_name(name);
1099 if (!commit)
1100 die(_("could not lookup commit %s"), name);
1101 out_enc = get_commit_output_encoding();
1102 return logmsg_reencode(commit, NULL, out_enc);
1103 }
1104
1105 /*
1106 * Enumerate what needs to be propagated when --porcelain
1107 * is not in effect here.
1108 */
1109 static struct status_deferred_config {
1110 enum status_format status_format;
1111 int show_branch;
1112 } status_deferred_config = {
1113 STATUS_FORMAT_UNSPECIFIED,
1114 -1 /* unspecified */
1115 };
1116
1117 static void finalize_deferred_config(struct wt_status *s)
1118 {
1119 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1120 !s->null_termination);
1121
1122 if (s->null_termination) {
1123 if (status_format == STATUS_FORMAT_NONE ||
1124 status_format == STATUS_FORMAT_UNSPECIFIED)
1125 status_format = STATUS_FORMAT_PORCELAIN;
1126 else if (status_format == STATUS_FORMAT_LONG)
1127 die(_("--long and -z are incompatible"));
1128 }
1129
1130 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1131 status_format = status_deferred_config.status_format;
1132 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1133 status_format = STATUS_FORMAT_NONE;
1134
1135 if (use_deferred_config && s->show_branch < 0)
1136 s->show_branch = status_deferred_config.show_branch;
1137 if (s->show_branch < 0)
1138 s->show_branch = 0;
1139 }
1140
1141 static int parse_and_validate_options(int argc, const char *argv[],
1142 const struct option *options,
1143 const char * const usage[],
1144 const char *prefix,
1145 struct commit *current_head,
1146 struct wt_status *s)
1147 {
1148 int f = 0;
1149
1150 argc = parse_options(argc, argv, prefix, options, usage, 0);
1151 finalize_deferred_config(s);
1152
1153 if (force_author && !strchr(force_author, '>'))
1154 force_author = find_author_by_nickname(force_author);
1155
1156 if (force_author && renew_authorship)
1157 die(_("Using both --reset-author and --author does not make sense"));
1158
1159 if (logfile || have_option_m || use_message || fixup_message)
1160 use_editor = 0;
1161 if (0 <= edit_flag)
1162 use_editor = edit_flag;
1163
1164 /* Sanity check options */
1165 if (amend && !current_head)
1166 die(_("You have nothing to amend."));
1167 if (amend && whence != FROM_COMMIT) {
1168 if (whence == FROM_MERGE)
1169 die(_("You are in the middle of a merge -- cannot amend."));
1170 else if (whence == FROM_CHERRY_PICK)
1171 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1172 }
1173 if (fixup_message && squash_message)
1174 die(_("Options --squash and --fixup cannot be used together"));
1175 if (use_message)
1176 f++;
1177 if (edit_message)
1178 f++;
1179 if (fixup_message)
1180 f++;
1181 if (logfile)
1182 f++;
1183 if (f > 1)
1184 die(_("Only one of -c/-C/-F/--fixup can be used."));
1185 if (message.len && f > 0)
1186 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1187 if (f || message.len)
1188 template_file = NULL;
1189 if (edit_message)
1190 use_message = edit_message;
1191 if (amend && !use_message && !fixup_message)
1192 use_message = "HEAD";
1193 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1194 die(_("--reset-author can be used only with -C, -c or --amend."));
1195 if (use_message) {
1196 use_message_buffer = read_commit_message(use_message);
1197 if (!renew_authorship) {
1198 author_message = use_message;
1199 author_message_buffer = use_message_buffer;
1200 }
1201 }
1202 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1203 author_message = "CHERRY_PICK_HEAD";
1204 author_message_buffer = read_commit_message(author_message);
1205 }
1206
1207 if (patch_interactive)
1208 interactive = 1;
1209
1210 if (also + only + all + interactive > 1)
1211 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1212 if (argc == 0 && (also || (only && !amend)))
1213 die(_("No paths with --include/--only does not make sense."));
1214 if (argc == 0 && only && amend)
1215 only_include_assumed = _("Clever... amending the last one with dirty index.");
1216 if (argc > 0 && !also && !only)
1217 only_include_assumed = _("Explicit paths specified without -i or -o; assuming --only paths...");
1218 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1219 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1220 else if (!strcmp(cleanup_arg, "verbatim"))
1221 cleanup_mode = CLEANUP_NONE;
1222 else if (!strcmp(cleanup_arg, "whitespace"))
1223 cleanup_mode = CLEANUP_SPACE;
1224 else if (!strcmp(cleanup_arg, "strip"))
1225 cleanup_mode = CLEANUP_ALL;
1226 else if (!strcmp(cleanup_arg, "scissors"))
1227 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1228 else
1229 die(_("Invalid cleanup mode %s"), cleanup_arg);
1230
1231 handle_untracked_files_arg(s);
1232
1233 if (all && argc > 0)
1234 die(_("Paths with -a does not make sense."));
1235
1236 if (status_format != STATUS_FORMAT_NONE)
1237 dry_run = 1;
1238
1239 return argc;
1240 }
1241
1242 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1243 const struct commit *current_head, struct wt_status *s)
1244 {
1245 int commitable;
1246 const char *index_file;
1247
1248 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1249 commitable = run_status(stdout, index_file, prefix, 0, s);
1250 rollback_index_files();
1251
1252 return commitable ? 0 : 1;
1253 }
1254
1255 static int parse_status_slot(const char *var, int offset)
1256 {
1257 if (!strcasecmp(var+offset, "header"))
1258 return WT_STATUS_HEADER;
1259 if (!strcasecmp(var+offset, "branch"))
1260 return WT_STATUS_ONBRANCH;
1261 if (!strcasecmp(var+offset, "updated")
1262 || !strcasecmp(var+offset, "added"))
1263 return WT_STATUS_UPDATED;
1264 if (!strcasecmp(var+offset, "changed"))
1265 return WT_STATUS_CHANGED;
1266 if (!strcasecmp(var+offset, "untracked"))
1267 return WT_STATUS_UNTRACKED;
1268 if (!strcasecmp(var+offset, "nobranch"))
1269 return WT_STATUS_NOBRANCH;
1270 if (!strcasecmp(var+offset, "unmerged"))
1271 return WT_STATUS_UNMERGED;
1272 return -1;
1273 }
1274
1275 static int git_status_config(const char *k, const char *v, void *cb)
1276 {
1277 struct wt_status *s = cb;
1278
1279 if (starts_with(k, "column."))
1280 return git_column_config(k, v, "status", &s->colopts);
1281 if (!strcmp(k, "status.submodulesummary")) {
1282 int is_bool;
1283 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1284 if (is_bool && s->submodule_summary)
1285 s->submodule_summary = -1;
1286 return 0;
1287 }
1288 if (!strcmp(k, "status.short")) {
1289 if (git_config_bool(k, v))
1290 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1291 else
1292 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1293 return 0;
1294 }
1295 if (!strcmp(k, "status.branch")) {
1296 status_deferred_config.show_branch = git_config_bool(k, v);
1297 return 0;
1298 }
1299 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1300 s->use_color = git_config_colorbool(k, v);
1301 return 0;
1302 }
1303 if (!strcmp(k, "status.displaycommentprefix")) {
1304 s->display_comment_prefix = git_config_bool(k, v);
1305 return 0;
1306 }
1307 if (starts_with(k, "status.color.") || starts_with(k, "color.status.")) {
1308 int slot = parse_status_slot(k, 13);
1309 if (slot < 0)
1310 return 0;
1311 if (!v)
1312 return config_error_nonbool(k);
1313 color_parse(v, k, s->color_palette[slot]);
1314 return 0;
1315 }
1316 if (!strcmp(k, "status.relativepaths")) {
1317 s->relative_paths = git_config_bool(k, v);
1318 return 0;
1319 }
1320 if (!strcmp(k, "status.showuntrackedfiles")) {
1321 if (!v)
1322 return config_error_nonbool(k);
1323 else if (!strcmp(v, "no"))
1324 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1325 else if (!strcmp(v, "normal"))
1326 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1327 else if (!strcmp(v, "all"))
1328 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1329 else
1330 return error(_("Invalid untracked files mode '%s'"), v);
1331 return 0;
1332 }
1333 return git_diff_ui_config(k, v, NULL);
1334 }
1335
1336 int cmd_status(int argc, const char **argv, const char *prefix)
1337 {
1338 static struct wt_status s;
1339 int fd;
1340 unsigned char sha1[20];
1341 static struct option builtin_status_options[] = {
1342 OPT__VERBOSE(&verbose, N_("be verbose")),
1343 OPT_SET_INT('s', "short", &status_format,
1344 N_("show status concisely"), STATUS_FORMAT_SHORT),
1345 OPT_BOOL('b', "branch", &s.show_branch,
1346 N_("show branch information")),
1347 OPT_SET_INT(0, "porcelain", &status_format,
1348 N_("machine-readable output"),
1349 STATUS_FORMAT_PORCELAIN),
1350 OPT_SET_INT(0, "long", &status_format,
1351 N_("show status in long format (default)"),
1352 STATUS_FORMAT_LONG),
1353 OPT_BOOL('z', "null", &s.null_termination,
1354 N_("terminate entries with NUL")),
1355 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1356 N_("mode"),
1357 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1358 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1359 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1360 N_("show ignored files")),
1361 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1362 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1363 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1364 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1365 OPT_END(),
1366 };
1367
1368 if (argc == 2 && !strcmp(argv[1], "-h"))
1369 usage_with_options(builtin_status_usage, builtin_status_options);
1370
1371 status_init_config(&s, git_status_config);
1372 argc = parse_options(argc, argv, prefix,
1373 builtin_status_options,
1374 builtin_status_usage, 0);
1375 finalize_colopts(&s.colopts, -1);
1376 finalize_deferred_config(&s);
1377
1378 handle_untracked_files_arg(&s);
1379 if (show_ignored_in_status)
1380 s.show_ignored_files = 1;
1381 parse_pathspec(&s.pathspec, 0,
1382 PATHSPEC_PREFER_FULL,
1383 prefix, argv);
1384
1385 read_cache_preload(&s.pathspec);
1386 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1387
1388 fd = hold_locked_index(&index_lock, 0);
1389 if (0 <= fd)
1390 update_index_if_able(&the_index, &index_lock);
1391
1392 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1393 s.ignore_submodule_arg = ignore_submodule_arg;
1394 wt_status_collect(&s);
1395
1396 if (s.relative_paths)
1397 s.prefix = prefix;
1398
1399 switch (status_format) {
1400 case STATUS_FORMAT_SHORT:
1401 wt_shortstatus_print(&s);
1402 break;
1403 case STATUS_FORMAT_PORCELAIN:
1404 wt_porcelain_print(&s);
1405 break;
1406 case STATUS_FORMAT_UNSPECIFIED:
1407 die("BUG: finalize_deferred_config() should have been called");
1408 break;
1409 case STATUS_FORMAT_NONE:
1410 case STATUS_FORMAT_LONG:
1411 s.verbose = verbose;
1412 s.ignore_submodule_arg = ignore_submodule_arg;
1413 wt_status_print(&s);
1414 break;
1415 }
1416 return 0;
1417 }
1418
1419 static const char *implicit_ident_advice(void)
1420 {
1421 char *user_config = NULL;
1422 char *xdg_config = NULL;
1423 int config_exists;
1424
1425 home_config_paths(&user_config, &xdg_config, "config");
1426 config_exists = file_exists(user_config) || file_exists(xdg_config);
1427 free(user_config);
1428 free(xdg_config);
1429
1430 if (config_exists)
1431 return _(implicit_ident_advice_config);
1432 else
1433 return _(implicit_ident_advice_noconfig);
1434
1435 }
1436
1437 static void print_summary(const char *prefix, const unsigned char *sha1,
1438 int initial_commit)
1439 {
1440 struct rev_info rev;
1441 struct commit *commit;
1442 struct strbuf format = STRBUF_INIT;
1443 unsigned char junk_sha1[20];
1444 const char *head;
1445 struct pretty_print_context pctx = {0};
1446 struct strbuf author_ident = STRBUF_INIT;
1447 struct strbuf committer_ident = STRBUF_INIT;
1448
1449 commit = lookup_commit(sha1);
1450 if (!commit)
1451 die(_("couldn't look up newly created commit"));
1452 if (parse_commit(commit))
1453 die(_("could not parse newly created commit"));
1454
1455 strbuf_addstr(&format, "format:%h] %s");
1456
1457 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1458 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1459 if (strbuf_cmp(&author_ident, &committer_ident)) {
1460 strbuf_addstr(&format, "\n Author: ");
1461 strbuf_addbuf_percentquote(&format, &author_ident);
1462 }
1463 if (author_date_is_interesting()) {
1464 struct strbuf date = STRBUF_INIT;
1465 format_commit_message(commit, "%ad", &date, &pctx);
1466 strbuf_addstr(&format, "\n Date: ");
1467 strbuf_addbuf_percentquote(&format, &date);
1468 strbuf_release(&date);
1469 }
1470 if (!committer_ident_sufficiently_given()) {
1471 strbuf_addstr(&format, "\n Committer: ");
1472 strbuf_addbuf_percentquote(&format, &committer_ident);
1473 if (advice_implicit_identity) {
1474 strbuf_addch(&format, '\n');
1475 strbuf_addstr(&format, implicit_ident_advice());
1476 }
1477 }
1478 strbuf_release(&author_ident);
1479 strbuf_release(&committer_ident);
1480
1481 init_revisions(&rev, prefix);
1482 setup_revisions(0, NULL, &rev, NULL);
1483
1484 rev.diff = 1;
1485 rev.diffopt.output_format =
1486 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1487
1488 rev.verbose_header = 1;
1489 rev.show_root_diff = 1;
1490 get_commit_format(format.buf, &rev);
1491 rev.always_show_header = 0;
1492 rev.diffopt.detect_rename = 1;
1493 rev.diffopt.break_opt = 0;
1494 diff_setup_done(&rev.diffopt);
1495
1496 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1497 printf("[%s%s ",
1498 starts_with(head, "refs/heads/") ?
1499 head + 11 :
1500 !strcmp(head, "HEAD") ?
1501 _("detached HEAD") :
1502 head,
1503 initial_commit ? _(" (root-commit)") : "");
1504
1505 if (!log_tree_commit(&rev, commit)) {
1506 rev.always_show_header = 1;
1507 rev.use_terminator = 1;
1508 log_tree_commit(&rev, commit);
1509 }
1510
1511 strbuf_release(&format);
1512 }
1513
1514 static int git_commit_config(const char *k, const char *v, void *cb)
1515 {
1516 struct wt_status *s = cb;
1517 int status;
1518
1519 if (!strcmp(k, "commit.template"))
1520 return git_config_pathname(&template_file, k, v);
1521 if (!strcmp(k, "commit.status")) {
1522 include_status = git_config_bool(k, v);
1523 return 0;
1524 }
1525 if (!strcmp(k, "commit.cleanup"))
1526 return git_config_string(&cleanup_arg, k, v);
1527 if (!strcmp(k, "commit.gpgsign")) {
1528 sign_commit = git_config_bool(k, v) ? "" : NULL;
1529 return 0;
1530 }
1531
1532 status = git_gpg_config(k, v, NULL);
1533 if (status)
1534 return status;
1535 return git_status_config(k, v, s);
1536 }
1537
1538 static int run_rewrite_hook(const unsigned char *oldsha1,
1539 const unsigned char *newsha1)
1540 {
1541 /* oldsha1 SP newsha1 LF NUL */
1542 static char buf[2*40 + 3];
1543 struct child_process proc = CHILD_PROCESS_INIT;
1544 const char *argv[3];
1545 int code;
1546 size_t n;
1547
1548 argv[0] = find_hook("post-rewrite");
1549 if (!argv[0])
1550 return 0;
1551
1552 argv[1] = "amend";
1553 argv[2] = NULL;
1554
1555 proc.argv = argv;
1556 proc.in = -1;
1557 proc.stdout_to_stderr = 1;
1558
1559 code = start_command(&proc);
1560 if (code)
1561 return code;
1562 n = snprintf(buf, sizeof(buf), "%s %s\n",
1563 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1564 write_in_full(proc.in, buf, n);
1565 close(proc.in);
1566 return finish_command(&proc);
1567 }
1568
1569 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1570 {
1571 const char *hook_env[3] = { NULL };
1572 char index[PATH_MAX];
1573 va_list args;
1574 int ret;
1575
1576 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1577 hook_env[0] = index;
1578
1579 /*
1580 * Let the hook know that no editor will be launched.
1581 */
1582 if (!editor_is_used)
1583 hook_env[1] = "GIT_EDITOR=:";
1584
1585 va_start(args, name);
1586 ret = run_hook_ve(hook_env, name, args);
1587 va_end(args);
1588
1589 return ret;
1590 }
1591
1592 int cmd_commit(int argc, const char **argv, const char *prefix)
1593 {
1594 static struct wt_status s;
1595 static struct option builtin_commit_options[] = {
1596 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1597 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1598
1599 OPT_GROUP(N_("Commit message options")),
1600 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1601 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1602 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1603 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1604 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1605 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1606 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1607 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1608 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1609 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1610 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1611 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1612 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1613 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1614 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1615 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1616 /* end commit message options */
1617
1618 OPT_GROUP(N_("Commit contents options")),
1619 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1620 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1621 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1622 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1623 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1624 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1625 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1626 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1627 STATUS_FORMAT_SHORT),
1628 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1629 OPT_SET_INT(0, "porcelain", &status_format,
1630 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1631 OPT_SET_INT(0, "long", &status_format,
1632 N_("show status in long format (default)"),
1633 STATUS_FORMAT_LONG),
1634 OPT_BOOL('z', "null", &s.null_termination,
1635 N_("terminate entries with NUL")),
1636 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1637 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1638 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, N_("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)"), PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1639 /* end commit contents options */
1640
1641 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1642 N_("ok to record an empty change")),
1643 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1644 N_("ok to record a change with an empty message")),
1645
1646 OPT_END()
1647 };
1648
1649 struct strbuf sb = STRBUF_INIT;
1650 struct strbuf author_ident = STRBUF_INIT;
1651 const char *index_file, *reflog_msg;
1652 char *nl;
1653 unsigned char sha1[20];
1654 struct commit_list *parents = NULL, **pptr = &parents;
1655 struct stat statbuf;
1656 struct commit *current_head = NULL;
1657 struct commit_extra_header *extra = NULL;
1658 struct ref_transaction *transaction;
1659 struct strbuf err = STRBUF_INIT;
1660
1661 if (argc == 2 && !strcmp(argv[1], "-h"))
1662 usage_with_options(builtin_commit_usage, builtin_commit_options);
1663
1664 status_init_config(&s, git_commit_config);
1665 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1666 s.colopts = 0;
1667
1668 if (get_sha1("HEAD", sha1))
1669 current_head = NULL;
1670 else {
1671 current_head = lookup_commit_or_die(sha1, "HEAD");
1672 if (parse_commit(current_head))
1673 die(_("could not parse HEAD commit"));
1674 }
1675 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1676 builtin_commit_usage,
1677 prefix, current_head, &s);
1678 if (dry_run)
1679 return dry_run_commit(argc, argv, prefix, current_head, &s);
1680 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1681
1682 /* Set up everything for writing the commit object. This includes
1683 running hooks, writing the trees, and interacting with the user. */
1684 if (!prepare_to_commit(index_file, prefix,
1685 current_head, &s, &author_ident)) {
1686 rollback_index_files();
1687 return 1;
1688 }
1689
1690 /* Determine parents */
1691 reflog_msg = getenv("GIT_REFLOG_ACTION");
1692 if (!current_head) {
1693 if (!reflog_msg)
1694 reflog_msg = "commit (initial)";
1695 } else if (amend) {
1696 struct commit_list *c;
1697
1698 if (!reflog_msg)
1699 reflog_msg = "commit (amend)";
1700 for (c = current_head->parents; c; c = c->next)
1701 pptr = &commit_list_insert(c->item, pptr)->next;
1702 } else if (whence == FROM_MERGE) {
1703 struct strbuf m = STRBUF_INIT;
1704 FILE *fp;
1705 int allow_fast_forward = 1;
1706
1707 if (!reflog_msg)
1708 reflog_msg = "commit (merge)";
1709 pptr = &commit_list_insert(current_head, pptr)->next;
1710 fp = fopen(git_path("MERGE_HEAD"), "r");
1711 if (fp == NULL)
1712 die_errno(_("could not open '%s' for reading"),
1713 git_path("MERGE_HEAD"));
1714 while (strbuf_getline(&m, fp, '\n') != EOF) {
1715 struct commit *parent;
1716
1717 parent = get_merge_parent(m.buf);
1718 if (!parent)
1719 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1720 pptr = &commit_list_insert(parent, pptr)->next;
1721 }
1722 fclose(fp);
1723 strbuf_release(&m);
1724 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1725 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1726 die_errno(_("could not read MERGE_MODE"));
1727 if (!strcmp(sb.buf, "no-ff"))
1728 allow_fast_forward = 0;
1729 }
1730 if (allow_fast_forward)
1731 parents = reduce_heads(parents);
1732 } else {
1733 if (!reflog_msg)
1734 reflog_msg = (whence == FROM_CHERRY_PICK)
1735 ? "commit (cherry-pick)"
1736 : "commit";
1737 pptr = &commit_list_insert(current_head, pptr)->next;
1738 }
1739
1740 /* Finally, get the commit message */
1741 strbuf_reset(&sb);
1742 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1743 int saved_errno = errno;
1744 rollback_index_files();
1745 die(_("could not read commit message: %s"), strerror(saved_errno));
1746 }
1747
1748 if (verbose || /* Truncate the message just before the diff, if any. */
1749 cleanup_mode == CLEANUP_SCISSORS)
1750 wt_status_truncate_message_at_cut_line(&sb);
1751
1752 if (cleanup_mode != CLEANUP_NONE)
1753 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1754 if (template_untouched(&sb) && !allow_empty_message) {
1755 rollback_index_files();
1756 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1757 exit(1);
1758 }
1759 if (message_is_empty(&sb) && !allow_empty_message) {
1760 rollback_index_files();
1761 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1762 exit(1);
1763 }
1764
1765 if (amend) {
1766 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1767 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1768 } else {
1769 struct commit_extra_header **tail = &extra;
1770 append_merge_tag_headers(parents, &tail);
1771 }
1772
1773 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->sha1,
1774 parents, sha1, author_ident.buf, sign_commit, extra)) {
1775 rollback_index_files();
1776 die(_("failed to write commit object"));
1777 }
1778 strbuf_release(&author_ident);
1779 free_commit_extra_headers(extra);
1780
1781 nl = strchr(sb.buf, '\n');
1782 if (nl)
1783 strbuf_setlen(&sb, nl + 1 - sb.buf);
1784 else
1785 strbuf_addch(&sb, '\n');
1786 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1787 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1788
1789 transaction = ref_transaction_begin(&err);
1790 if (!transaction ||
1791 ref_transaction_update(transaction, "HEAD", sha1,
1792 current_head
1793 ? current_head->object.sha1 : NULL,
1794 0, !!current_head, &err) ||
1795 ref_transaction_commit(transaction, sb.buf, &err)) {
1796 rollback_index_files();
1797 die("%s", err.buf);
1798 }
1799 ref_transaction_free(transaction);
1800
1801 unlink(git_path("CHERRY_PICK_HEAD"));
1802 unlink(git_path("REVERT_HEAD"));
1803 unlink(git_path("MERGE_HEAD"));
1804 unlink(git_path("MERGE_MSG"));
1805 unlink(git_path("MERGE_MODE"));
1806 unlink(git_path("SQUASH_MSG"));
1807
1808 if (commit_index_files())
1809 die (_("Repository has been updated, but unable to write\n"
1810 "new_index file. Check that disk is not full or quota is\n"
1811 "not exceeded, and then \"git reset HEAD\" to recover."));
1812
1813 rerere(0);
1814 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1815 if (amend && !no_post_rewrite) {
1816 struct notes_rewrite_cfg *cfg;
1817 cfg = init_copy_notes_for_rewrite("amend");
1818 if (cfg) {
1819 /* we are amending, so current_head is not NULL */
1820 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1821 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1822 }
1823 run_rewrite_hook(current_head->object.sha1, sha1);
1824 }
1825 if (!quiet)
1826 print_summary(prefix, sha1, !current_head);
1827
1828 strbuf_release(&err);
1829 return 0;
1830 }