doc: prefer 'stash push' over 'stash save'
[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 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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
916 if (ignore_submodule_arg &&
917 !strcmp(ignore_submodule_arg, "all"))
918 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
919 commitable = index_differs_from(parent, diff_flags, 1);
920 }
921 }
922 strbuf_release(&committer_ident);
923
924 fclose(s->fp);
925
926 /*
927 * Reject an attempt to record a non-merge empty commit without
928 * explicit --allow-empty. In the cherry-pick case, it may be
929 * empty due to conflict resolution, which the user should okay.
930 */
931 if (!commitable && whence != FROM_MERGE && !allow_empty &&
932 !(amend && is_a_merge(current_head))) {
933 s->display_comment_prefix = old_display_comment_prefix;
934 run_status(stdout, index_file, prefix, 0, s);
935 if (amend)
936 fputs(_(empty_amend_advice), stderr);
937 else if (whence == FROM_CHERRY_PICK) {
938 fputs(_(empty_cherry_pick_advice), stderr);
939 if (!sequencer_in_use)
940 fputs(_(empty_cherry_pick_advice_single), stderr);
941 else
942 fputs(_(empty_cherry_pick_advice_multi), stderr);
943 }
944 return 0;
945 }
946
947 if (!no_verify && find_hook("pre-commit")) {
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 }
955 read_cache_from(index_file);
956
957 if (update_main_cache_tree(0)) {
958 error(_("Error building trees"));
959 return 0;
960 }
961
962 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
963 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
964 return 0;
965
966 if (use_editor) {
967 struct argv_array env = ARGV_ARRAY_INIT;
968
969 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
970 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
971 fprintf(stderr,
972 _("Please supply the message using either -m or -F option.\n"));
973 exit(1);
974 }
975 argv_array_clear(&env);
976 }
977
978 if (!no_verify &&
979 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
980 return 0;
981 }
982
983 return 1;
984 }
985
986 static int rest_is_empty(struct strbuf *sb, int start)
987 {
988 int i, eol;
989 const char *nl;
990
991 /* Check if the rest is just whitespace and Signed-off-by's. */
992 for (i = start; i < sb->len; i++) {
993 nl = memchr(sb->buf + i, '\n', sb->len - i);
994 if (nl)
995 eol = nl - sb->buf;
996 else
997 eol = sb->len;
998
999 if (strlen(sign_off_header) <= eol - i &&
1000 starts_with(sb->buf + i, sign_off_header)) {
1001 i = eol;
1002 continue;
1003 }
1004 while (i < eol)
1005 if (!isspace(sb->buf[i++]))
1006 return 0;
1007 }
1008
1009 return 1;
1010 }
1011
1012 /*
1013 * Find out if the message in the strbuf contains only whitespace and
1014 * Signed-off-by lines.
1015 */
1016 static int message_is_empty(struct strbuf *sb)
1017 {
1018 if (cleanup_mode == CLEANUP_NONE && sb->len)
1019 return 0;
1020 return rest_is_empty(sb, 0);
1021 }
1022
1023 /*
1024 * See if the user edited the message in the editor or left what
1025 * was in the template intact
1026 */
1027 static int template_untouched(struct strbuf *sb)
1028 {
1029 struct strbuf tmpl = STRBUF_INIT;
1030 const char *start;
1031
1032 if (cleanup_mode == CLEANUP_NONE && sb->len)
1033 return 0;
1034
1035 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1036 return 0;
1037
1038 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1039 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1040 start = sb->buf;
1041 strbuf_release(&tmpl);
1042 return rest_is_empty(sb, start - sb->buf);
1043 }
1044
1045 static const char *find_author_by_nickname(const char *name)
1046 {
1047 struct rev_info revs;
1048 struct commit *commit;
1049 struct strbuf buf = STRBUF_INIT;
1050 struct string_list mailmap = STRING_LIST_INIT_NODUP;
1051 const char *av[20];
1052 int ac = 0;
1053
1054 init_revisions(&revs, NULL);
1055 strbuf_addf(&buf, "--author=%s", name);
1056 av[++ac] = "--all";
1057 av[++ac] = "-i";
1058 av[++ac] = buf.buf;
1059 av[++ac] = NULL;
1060 setup_revisions(ac, av, &revs, NULL);
1061 revs.mailmap = &mailmap;
1062 read_mailmap(revs.mailmap, NULL);
1063
1064 if (prepare_revision_walk(&revs))
1065 die(_("revision walk setup failed"));
1066 commit = get_revision(&revs);
1067 if (commit) {
1068 struct pretty_print_context ctx = {0};
1069 ctx.date_mode.type = DATE_NORMAL;
1070 strbuf_release(&buf);
1071 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1072 clear_mailmap(&mailmap);
1073 return strbuf_detach(&buf, NULL);
1074 }
1075 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1076 }
1077
1078
1079 static void handle_untracked_files_arg(struct wt_status *s)
1080 {
1081 if (!untracked_files_arg)
1082 ; /* default already initialized */
1083 else if (!strcmp(untracked_files_arg, "no"))
1084 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1085 else if (!strcmp(untracked_files_arg, "normal"))
1086 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1087 else if (!strcmp(untracked_files_arg, "all"))
1088 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1089 else
1090 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1091 }
1092
1093 static const char *read_commit_message(const char *name)
1094 {
1095 const char *out_enc;
1096 struct commit *commit;
1097
1098 commit = lookup_commit_reference_by_name(name);
1099 if (!commit)
1100 die(_("could not lookup commit %s"), name);
1101 out_enc = get_commit_output_encoding();
1102 return logmsg_reencode(commit, NULL, out_enc);
1103 }
1104
1105 /*
1106 * Enumerate what needs to be propagated when --porcelain
1107 * is not in effect here.
1108 */
1109 static struct status_deferred_config {
1110 enum wt_status_format status_format;
1111 int show_branch;
1112 } status_deferred_config = {
1113 STATUS_FORMAT_UNSPECIFIED,
1114 -1 /* unspecified */
1115 };
1116
1117 static void finalize_deferred_config(struct wt_status *s)
1118 {
1119 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1120 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1121 !s->null_termination);
1122
1123 if (s->null_termination) {
1124 if (status_format == STATUS_FORMAT_NONE ||
1125 status_format == STATUS_FORMAT_UNSPECIFIED)
1126 status_format = STATUS_FORMAT_PORCELAIN;
1127 else if (status_format == STATUS_FORMAT_LONG)
1128 die(_("--long and -z are incompatible"));
1129 }
1130
1131 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1132 status_format = status_deferred_config.status_format;
1133 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1134 status_format = STATUS_FORMAT_NONE;
1135
1136 if (use_deferred_config && s->show_branch < 0)
1137 s->show_branch = status_deferred_config.show_branch;
1138 if (s->show_branch < 0)
1139 s->show_branch = 0;
1140 }
1141
1142 static int parse_and_validate_options(int argc, const char *argv[],
1143 const struct option *options,
1144 const char * const usage[],
1145 const char *prefix,
1146 struct commit *current_head,
1147 struct wt_status *s)
1148 {
1149 int f = 0;
1150
1151 argc = parse_options(argc, argv, prefix, options, usage, 0);
1152 finalize_deferred_config(s);
1153
1154 if (force_author && !strchr(force_author, '>'))
1155 force_author = find_author_by_nickname(force_author);
1156
1157 if (force_author && renew_authorship)
1158 die(_("Using both --reset-author and --author does not make sense"));
1159
1160 if (logfile || have_option_m || use_message || fixup_message)
1161 use_editor = 0;
1162 if (0 <= edit_flag)
1163 use_editor = edit_flag;
1164
1165 /* Sanity check options */
1166 if (amend && !current_head)
1167 die(_("You have nothing to amend."));
1168 if (amend && whence != FROM_COMMIT) {
1169 if (whence == FROM_MERGE)
1170 die(_("You are in the middle of a merge -- cannot amend."));
1171 else if (whence == FROM_CHERRY_PICK)
1172 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1173 }
1174 if (fixup_message && squash_message)
1175 die(_("Options --squash and --fixup cannot be used together"));
1176 if (use_message)
1177 f++;
1178 if (edit_message)
1179 f++;
1180 if (fixup_message)
1181 f++;
1182 if (logfile)
1183 f++;
1184 if (f > 1)
1185 die(_("Only one of -c/-C/-F/--fixup can be used."));
1186 if (have_option_m && f > 0)
1187 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1188 if (f || have_option_m)
1189 template_file = NULL;
1190 if (edit_message)
1191 use_message = edit_message;
1192 if (amend && !use_message && !fixup_message)
1193 use_message = "HEAD";
1194 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1195 die(_("--reset-author can be used only with -C, -c or --amend."));
1196 if (use_message) {
1197 use_message_buffer = read_commit_message(use_message);
1198 if (!renew_authorship) {
1199 author_message = use_message;
1200 author_message_buffer = use_message_buffer;
1201 }
1202 }
1203 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1204 author_message = "CHERRY_PICK_HEAD";
1205 author_message_buffer = read_commit_message(author_message);
1206 }
1207
1208 if (patch_interactive)
1209 interactive = 1;
1210
1211 if (also + only + all + interactive > 1)
1212 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1213 if (argc == 0 && (also || (only && !amend && !allow_empty)))
1214 die(_("No paths with --include/--only does not make sense."));
1215 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1216 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1217 else if (!strcmp(cleanup_arg, "verbatim"))
1218 cleanup_mode = CLEANUP_NONE;
1219 else if (!strcmp(cleanup_arg, "whitespace"))
1220 cleanup_mode = CLEANUP_SPACE;
1221 else if (!strcmp(cleanup_arg, "strip"))
1222 cleanup_mode = CLEANUP_ALL;
1223 else if (!strcmp(cleanup_arg, "scissors"))
1224 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1225 else
1226 die(_("Invalid cleanup mode %s"), cleanup_arg);
1227
1228 handle_untracked_files_arg(s);
1229
1230 if (all && argc > 0)
1231 die(_("Paths with -a does not make sense."));
1232
1233 if (status_format != STATUS_FORMAT_NONE)
1234 dry_run = 1;
1235
1236 return argc;
1237 }
1238
1239 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1240 const struct commit *current_head, struct wt_status *s)
1241 {
1242 int commitable;
1243 const char *index_file;
1244
1245 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1246 commitable = run_status(stdout, index_file, prefix, 0, s);
1247 rollback_index_files();
1248
1249 return commitable ? 0 : 1;
1250 }
1251
1252 static int parse_status_slot(const char *slot)
1253 {
1254 if (!strcasecmp(slot, "header"))
1255 return WT_STATUS_HEADER;
1256 if (!strcasecmp(slot, "branch"))
1257 return WT_STATUS_ONBRANCH;
1258 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1259 return WT_STATUS_UPDATED;
1260 if (!strcasecmp(slot, "changed"))
1261 return WT_STATUS_CHANGED;
1262 if (!strcasecmp(slot, "untracked"))
1263 return WT_STATUS_UNTRACKED;
1264 if (!strcasecmp(slot, "nobranch"))
1265 return WT_STATUS_NOBRANCH;
1266 if (!strcasecmp(slot, "unmerged"))
1267 return WT_STATUS_UNMERGED;
1268 if (!strcasecmp(slot, "localBranch"))
1269 return WT_STATUS_LOCAL_BRANCH;
1270 if (!strcasecmp(slot, "remoteBranch"))
1271 return WT_STATUS_REMOTE_BRANCH;
1272 return -1;
1273 }
1274
1275 static int git_status_config(const char *k, const char *v, void *cb)
1276 {
1277 struct wt_status *s = cb;
1278 const char *slot_name;
1279
1280 if (starts_with(k, "column."))
1281 return git_column_config(k, v, "status", &s->colopts);
1282 if (!strcmp(k, "status.submodulesummary")) {
1283 int is_bool;
1284 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1285 if (is_bool && s->submodule_summary)
1286 s->submodule_summary = -1;
1287 return 0;
1288 }
1289 if (!strcmp(k, "status.short")) {
1290 if (git_config_bool(k, v))
1291 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1292 else
1293 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1294 return 0;
1295 }
1296 if (!strcmp(k, "status.branch")) {
1297 status_deferred_config.show_branch = git_config_bool(k, v);
1298 return 0;
1299 }
1300 if (!strcmp(k, "status.showstash")) {
1301 s->show_stash = git_config_bool(k, v);
1302 return 0;
1303 }
1304 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1305 s->use_color = git_config_colorbool(k, v);
1306 return 0;
1307 }
1308 if (!strcmp(k, "status.displaycommentprefix")) {
1309 s->display_comment_prefix = git_config_bool(k, v);
1310 return 0;
1311 }
1312 if (skip_prefix(k, "status.color.", &slot_name) ||
1313 skip_prefix(k, "color.status.", &slot_name)) {
1314 int slot = parse_status_slot(slot_name);
1315 if (slot < 0)
1316 return 0;
1317 if (!v)
1318 return config_error_nonbool(k);
1319 return color_parse(v, s->color_palette[slot]);
1320 }
1321 if (!strcmp(k, "status.relativepaths")) {
1322 s->relative_paths = git_config_bool(k, v);
1323 return 0;
1324 }
1325 if (!strcmp(k, "status.showuntrackedfiles")) {
1326 if (!v)
1327 return config_error_nonbool(k);
1328 else if (!strcmp(v, "no"))
1329 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1330 else if (!strcmp(v, "normal"))
1331 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1332 else if (!strcmp(v, "all"))
1333 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1334 else
1335 return error(_("Invalid untracked files mode '%s'"), v);
1336 return 0;
1337 }
1338 return git_diff_ui_config(k, v, NULL);
1339 }
1340
1341 int cmd_status(int argc, const char **argv, const char *prefix)
1342 {
1343 static struct wt_status s;
1344 int fd;
1345 struct object_id oid;
1346 static struct option builtin_status_options[] = {
1347 OPT__VERBOSE(&verbose, N_("be verbose")),
1348 OPT_SET_INT('s', "short", &status_format,
1349 N_("show status concisely"), STATUS_FORMAT_SHORT),
1350 OPT_BOOL('b', "branch", &s.show_branch,
1351 N_("show branch information")),
1352 OPT_BOOL(0, "show-stash", &s.show_stash,
1353 N_("show stash information")),
1354 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1355 N_("version"), N_("machine-readable output"),
1356 PARSE_OPT_OPTARG, opt_parse_porcelain },
1357 OPT_SET_INT(0, "long", &status_format,
1358 N_("show status in long format (default)"),
1359 STATUS_FORMAT_LONG),
1360 OPT_BOOL('z', "null", &s.null_termination,
1361 N_("terminate entries with NUL")),
1362 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1363 N_("mode"),
1364 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1365 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1366 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1367 N_("show ignored files")),
1368 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1369 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1370 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1371 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1372 OPT_END(),
1373 };
1374
1375 if (argc == 2 && !strcmp(argv[1], "-h"))
1376 usage_with_options(builtin_status_usage, builtin_status_options);
1377
1378 status_init_config(&s, git_status_config);
1379 argc = parse_options(argc, argv, prefix,
1380 builtin_status_options,
1381 builtin_status_usage, 0);
1382 finalize_colopts(&s.colopts, -1);
1383 finalize_deferred_config(&s);
1384
1385 handle_untracked_files_arg(&s);
1386 if (show_ignored_in_status)
1387 s.show_ignored_files = 1;
1388 parse_pathspec(&s.pathspec, 0,
1389 PATHSPEC_PREFER_FULL,
1390 prefix, argv);
1391
1392 read_cache_preload(&s.pathspec);
1393 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1394
1395 if (use_optional_locks())
1396 fd = hold_locked_index(&index_lock, 0);
1397 else
1398 fd = -1;
1399
1400 s.is_initial = get_oid(s.reference, &oid) ? 1 : 0;
1401 if (!s.is_initial)
1402 hashcpy(s.sha1_commit, oid.hash);
1403
1404 s.ignore_submodule_arg = ignore_submodule_arg;
1405 s.status_format = status_format;
1406 s.verbose = verbose;
1407
1408 wt_status_collect(&s);
1409
1410 if (0 <= fd)
1411 update_index_if_able(&the_index, &index_lock);
1412
1413 if (s.relative_paths)
1414 s.prefix = prefix;
1415
1416 wt_status_print(&s);
1417 return 0;
1418 }
1419
1420 static const char *implicit_ident_advice(void)
1421 {
1422 char *user_config = expand_user_path("~/.gitconfig", 0);
1423 char *xdg_config = xdg_config_home("config");
1424 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1425
1426 free(user_config);
1427 free(xdg_config);
1428
1429 if (config_exists)
1430 return _(implicit_ident_advice_config);
1431 else
1432 return _(implicit_ident_advice_noconfig);
1433
1434 }
1435
1436 static void print_summary(const char *prefix, const struct object_id *oid,
1437 int initial_commit)
1438 {
1439 struct rev_info rev;
1440 struct commit *commit;
1441 struct strbuf format = STRBUF_INIT;
1442 const char *head;
1443 struct pretty_print_context pctx = {0};
1444 struct strbuf author_ident = STRBUF_INIT;
1445 struct strbuf committer_ident = STRBUF_INIT;
1446
1447 commit = lookup_commit(oid);
1448 if (!commit)
1449 die(_("couldn't look up newly created commit"));
1450 if (parse_commit(commit))
1451 die(_("could not parse newly created commit"));
1452
1453 strbuf_addstr(&format, "format:%h] %s");
1454
1455 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1456 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1457 if (strbuf_cmp(&author_ident, &committer_ident)) {
1458 strbuf_addstr(&format, "\n Author: ");
1459 strbuf_addbuf_percentquote(&format, &author_ident);
1460 }
1461 if (author_date_is_interesting()) {
1462 struct strbuf date = STRBUF_INIT;
1463 format_commit_message(commit, "%ad", &date, &pctx);
1464 strbuf_addstr(&format, "\n Date: ");
1465 strbuf_addbuf_percentquote(&format, &date);
1466 strbuf_release(&date);
1467 }
1468 if (!committer_ident_sufficiently_given()) {
1469 strbuf_addstr(&format, "\n Committer: ");
1470 strbuf_addbuf_percentquote(&format, &committer_ident);
1471 if (advice_implicit_identity) {
1472 strbuf_addch(&format, '\n');
1473 strbuf_addstr(&format, implicit_ident_advice());
1474 }
1475 }
1476 strbuf_release(&author_ident);
1477 strbuf_release(&committer_ident);
1478
1479 init_revisions(&rev, prefix);
1480 setup_revisions(0, NULL, &rev, NULL);
1481
1482 rev.diff = 1;
1483 rev.diffopt.output_format =
1484 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1485
1486 rev.verbose_header = 1;
1487 rev.show_root_diff = 1;
1488 get_commit_format(format.buf, &rev);
1489 rev.always_show_header = 0;
1490 rev.diffopt.detect_rename = 1;
1491 rev.diffopt.break_opt = 0;
1492 diff_setup_done(&rev.diffopt);
1493
1494 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1495 if (!strcmp(head, "HEAD"))
1496 head = _("detached HEAD");
1497 else
1498 skip_prefix(head, "refs/heads/", &head);
1499 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1500
1501 if (!log_tree_commit(&rev, commit)) {
1502 rev.always_show_header = 1;
1503 rev.use_terminator = 1;
1504 log_tree_commit(&rev, commit);
1505 }
1506
1507 strbuf_release(&format);
1508 }
1509
1510 static int git_commit_config(const char *k, const char *v, void *cb)
1511 {
1512 struct wt_status *s = cb;
1513 int status;
1514
1515 if (!strcmp(k, "commit.template"))
1516 return git_config_pathname(&template_file, k, v);
1517 if (!strcmp(k, "commit.status")) {
1518 include_status = git_config_bool(k, v);
1519 return 0;
1520 }
1521 if (!strcmp(k, "commit.cleanup"))
1522 return git_config_string(&cleanup_arg, k, v);
1523 if (!strcmp(k, "commit.gpgsign")) {
1524 sign_commit = git_config_bool(k, v) ? "" : NULL;
1525 return 0;
1526 }
1527 if (!strcmp(k, "commit.verbose")) {
1528 int is_bool;
1529 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1530 return 0;
1531 }
1532
1533 status = git_gpg_config(k, v, NULL);
1534 if (status)
1535 return status;
1536 return git_status_config(k, v, s);
1537 }
1538
1539 static int run_rewrite_hook(const struct object_id *oldoid,
1540 const struct object_id *newoid)
1541 {
1542 struct child_process proc = CHILD_PROCESS_INIT;
1543 const char *argv[3];
1544 int code;
1545 struct strbuf sb = STRBUF_INIT;
1546
1547 argv[0] = find_hook("post-rewrite");
1548 if (!argv[0])
1549 return 0;
1550
1551 argv[1] = "amend";
1552 argv[2] = NULL;
1553
1554 proc.argv = argv;
1555 proc.in = -1;
1556 proc.stdout_to_stderr = 1;
1557
1558 code = start_command(&proc);
1559 if (code)
1560 return code;
1561 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1562 sigchain_push(SIGPIPE, SIG_IGN);
1563 write_in_full(proc.in, sb.buf, sb.len);
1564 close(proc.in);
1565 strbuf_release(&sb);
1566 sigchain_pop(SIGPIPE);
1567 return finish_command(&proc);
1568 }
1569
1570 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1571 {
1572 struct argv_array hook_env = ARGV_ARRAY_INIT;
1573 va_list args;
1574 int ret;
1575
1576 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1577
1578 /*
1579 * Let the hook know that no editor will be launched.
1580 */
1581 if (!editor_is_used)
1582 argv_array_push(&hook_env, "GIT_EDITOR=:");
1583
1584 va_start(args, name);
1585 ret = run_hook_ve(hook_env.argv,name, args);
1586 va_end(args);
1587 argv_array_clear(&hook_env);
1588
1589 return ret;
1590 }
1591
1592 int cmd_commit(int argc, const char **argv, const char *prefix)
1593 {
1594 static struct wt_status s;
1595 static struct option builtin_commit_options[] = {
1596 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1597 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1598
1599 OPT_GROUP(N_("Commit message options")),
1600 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1601 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1602 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1603 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1604 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1605 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1606 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1607 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1608 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1609 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1610 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1611 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1612 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1613 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1614 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1615 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1616 /* end commit message options */
1617
1618 OPT_GROUP(N_("Commit contents options")),
1619 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1620 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1621 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1622 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1623 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1624 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1625 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1626 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1627 STATUS_FORMAT_SHORT),
1628 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1629 OPT_SET_INT(0, "porcelain", &status_format,
1630 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1631 OPT_SET_INT(0, "long", &status_format,
1632 N_("show status in long format (default)"),
1633 STATUS_FORMAT_LONG),
1634 OPT_BOOL('z', "null", &s.null_termination,
1635 N_("terminate entries with NUL")),
1636 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1637 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1638 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, N_("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)"), PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1639 /* end commit contents options */
1640
1641 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1642 N_("ok to record an empty change")),
1643 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1644 N_("ok to record a change with an empty message")),
1645
1646 OPT_END()
1647 };
1648
1649 struct strbuf sb = STRBUF_INIT;
1650 struct strbuf author_ident = STRBUF_INIT;
1651 const char *index_file, *reflog_msg;
1652 char *nl;
1653 struct object_id oid;
1654 struct commit_list *parents = NULL;
1655 struct stat statbuf;
1656 struct commit *current_head = NULL;
1657 struct commit_extra_header *extra = NULL;
1658 struct ref_transaction *transaction;
1659 struct strbuf err = STRBUF_INIT;
1660
1661 if (argc == 2 && !strcmp(argv[1], "-h"))
1662 usage_with_options(builtin_commit_usage, builtin_commit_options);
1663
1664 status_init_config(&s, git_commit_config);
1665 s.commit_template = 1;
1666 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1667 s.colopts = 0;
1668
1669 if (get_oid("HEAD", &oid))
1670 current_head = NULL;
1671 else {
1672 current_head = lookup_commit_or_die(&oid, "HEAD");
1673 if (parse_commit(current_head))
1674 die(_("could not parse HEAD commit"));
1675 }
1676 verbose = -1; /* unspecified */
1677 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1678 builtin_commit_usage,
1679 prefix, current_head, &s);
1680 if (verbose == -1)
1681 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1682
1683 if (dry_run)
1684 return dry_run_commit(argc, argv, prefix, current_head, &s);
1685 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1686
1687 /* Set up everything for writing the commit object. This includes
1688 running hooks, writing the trees, and interacting with the user. */
1689 if (!prepare_to_commit(index_file, prefix,
1690 current_head, &s, &author_ident)) {
1691 rollback_index_files();
1692 return 1;
1693 }
1694
1695 /* Determine parents */
1696 reflog_msg = getenv("GIT_REFLOG_ACTION");
1697 if (!current_head) {
1698 if (!reflog_msg)
1699 reflog_msg = "commit (initial)";
1700 } else if (amend) {
1701 if (!reflog_msg)
1702 reflog_msg = "commit (amend)";
1703 parents = copy_commit_list(current_head->parents);
1704 } else if (whence == FROM_MERGE) {
1705 struct strbuf m = STRBUF_INIT;
1706 FILE *fp;
1707 int allow_fast_forward = 1;
1708 struct commit_list **pptr = &parents;
1709
1710 if (!reflog_msg)
1711 reflog_msg = "commit (merge)";
1712 pptr = commit_list_append(current_head, pptr);
1713 fp = xfopen(git_path_merge_head(), "r");
1714 while (strbuf_getline_lf(&m, fp) != EOF) {
1715 struct commit *parent;
1716
1717 parent = get_merge_parent(m.buf);
1718 if (!parent)
1719 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1720 pptr = commit_list_append(parent, pptr);
1721 }
1722 fclose(fp);
1723 strbuf_release(&m);
1724 if (!stat(git_path_merge_mode(), &statbuf)) {
1725 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1726 die_errno(_("could not read MERGE_MODE"));
1727 if (!strcmp(sb.buf, "no-ff"))
1728 allow_fast_forward = 0;
1729 }
1730 if (allow_fast_forward)
1731 parents = reduce_heads(parents);
1732 } else {
1733 if (!reflog_msg)
1734 reflog_msg = (whence == FROM_CHERRY_PICK)
1735 ? "commit (cherry-pick)"
1736 : "commit";
1737 commit_list_insert(current_head, &parents);
1738 }
1739
1740 /* Finally, get the commit message */
1741 strbuf_reset(&sb);
1742 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1743 int saved_errno = errno;
1744 rollback_index_files();
1745 die(_("could not read commit message: %s"), strerror(saved_errno));
1746 }
1747
1748 if (verbose || /* Truncate the message just before the diff, if any. */
1749 cleanup_mode == CLEANUP_SCISSORS)
1750 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
1751 if (cleanup_mode != CLEANUP_NONE)
1752 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1753
1754 if (message_is_empty(&sb) && !allow_empty_message) {
1755 rollback_index_files();
1756 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1757 exit(1);
1758 }
1759 if (template_untouched(&sb) && !allow_empty_message) {
1760 rollback_index_files();
1761 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1762 exit(1);
1763 }
1764
1765 if (amend) {
1766 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1767 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1768 } else {
1769 struct commit_extra_header **tail = &extra;
1770 append_merge_tag_headers(parents, &tail);
1771 }
1772
1773 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
1774 parents, oid.hash, author_ident.buf, sign_commit, extra)) {
1775 rollback_index_files();
1776 die(_("failed to write commit object"));
1777 }
1778 strbuf_release(&author_ident);
1779 free_commit_extra_headers(extra);
1780
1781 nl = strchr(sb.buf, '\n');
1782 if (nl)
1783 strbuf_setlen(&sb, nl + 1 - sb.buf);
1784 else
1785 strbuf_addch(&sb, '\n');
1786 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1787 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1788
1789 transaction = ref_transaction_begin(&err);
1790 if (!transaction ||
1791 ref_transaction_update(transaction, "HEAD", oid.hash,
1792 current_head
1793 ? current_head->object.oid.hash : null_sha1,
1794 0, sb.buf, &err) ||
1795 ref_transaction_commit(transaction, &err)) {
1796 rollback_index_files();
1797 die("%s", err.buf);
1798 }
1799 ref_transaction_free(transaction);
1800
1801 unlink(git_path_cherry_pick_head());
1802 unlink(git_path_revert_head());
1803 unlink(git_path_merge_head());
1804 unlink(git_path_merge_msg());
1805 unlink(git_path_merge_mode());
1806 unlink(git_path_squash_msg());
1807
1808 if (commit_index_files())
1809 die (_("Repository has been updated, but unable to write\n"
1810 "new_index file. Check that disk is not full and quota is\n"
1811 "not exceeded, and then \"git reset HEAD\" to recover."));
1812
1813 rerere(0);
1814 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1815 if (amend && !no_post_rewrite) {
1816 struct notes_rewrite_cfg *cfg;
1817 cfg = init_copy_notes_for_rewrite("amend");
1818 if (cfg) {
1819 /* we are amending, so current_head is not NULL */
1820 copy_note_for_rewrite(cfg, &current_head->object.oid, &oid);
1821 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1822 }
1823 run_rewrite_hook(&current_head->object.oid, &oid);
1824 }
1825 if (!quiet)
1826 print_summary(prefix, &oid, !current_head);
1827
1828 UNLEAK(err);
1829 UNLEAK(sb);
1830 return 0;
1831 }