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