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