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