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