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