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