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