Merge branch 'jc/doc-checkout'
[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;
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 show_ignored_in_status, 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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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, CLOSE_LOCK))
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                         int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
916                         if (ignore_submodule_arg &&
917                             !strcmp(ignore_submodule_arg, "all"))
918                                 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
919                         commitable = index_differs_from(parent, diff_flags, 1);
920                 }
921         }
922         strbuf_release(&committer_ident);
923
924         fclose(s->fp);
925
926         /*
927          * Reject an attempt to record a non-merge empty commit without
928          * explicit --allow-empty. In the cherry-pick case, it may be
929          * empty due to conflict resolution, which the user should okay.
930          */
931         if (!commitable && whence != FROM_MERGE && !allow_empty &&
932             !(amend && is_a_merge(current_head))) {
933                 s->display_comment_prefix = old_display_comment_prefix;
934                 run_status(stdout, index_file, prefix, 0, s);
935                 if (amend)
936                         fputs(_(empty_amend_advice), stderr);
937                 else if (whence == FROM_CHERRY_PICK) {
938                         fputs(_(empty_cherry_pick_advice), stderr);
939                         if (!sequencer_in_use)
940                                 fputs(_(empty_cherry_pick_advice_single), stderr);
941                         else
942                                 fputs(_(empty_cherry_pick_advice_multi), stderr);
943                 }
944                 return 0;
945         }
946
947         if (!no_verify && find_hook("pre-commit")) {
948                 /*
949                  * Re-read the index as pre-commit hook could have updated it,
950                  * and write it out as a tree.  We must do this before we invoke
951                  * the editor and after we invoke run_status above.
952                  */
953                 discard_cache();
954         }
955         read_cache_from(index_file);
956
957         if (update_main_cache_tree(0)) {
958                 error(_("Error building trees"));
959                 return 0;
960         }
961
962         if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
963                             git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
964                 return 0;
965
966         if (use_editor) {
967                 struct argv_array env = ARGV_ARRAY_INIT;
968
969                 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
970                 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
971                         fprintf(stderr,
972                         _("Please supply the message using either -m or -F option.\n"));
973                         exit(1);
974                 }
975                 argv_array_clear(&env);
976         }
977
978         if (!no_verify &&
979             run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
980                 return 0;
981         }
982
983         return 1;
984 }
985
986 static int rest_is_empty(struct strbuf *sb, int start)
987 {
988         int i, eol;
989         const char *nl;
990
991         /* Check if the rest is just whitespace and Signed-off-by's. */
992         for (i = start; i < sb->len; i++) {
993                 nl = memchr(sb->buf + i, '\n', sb->len - i);
994                 if (nl)
995                         eol = nl - sb->buf;
996                 else
997                         eol = sb->len;
998
999                 if (strlen(sign_off_header) <= eol - i &&
1000                     starts_with(sb->buf + i, sign_off_header)) {
1001                         i = eol;
1002                         continue;
1003                 }
1004                 while (i < eol)
1005                         if (!isspace(sb->buf[i++]))
1006                                 return 0;
1007         }
1008
1009         return 1;
1010 }
1011
1012 /*
1013  * Find out if the message in the strbuf contains only whitespace and
1014  * Signed-off-by lines.
1015  */
1016 static int message_is_empty(struct strbuf *sb)
1017 {
1018         if (cleanup_mode == CLEANUP_NONE && sb->len)
1019                 return 0;
1020         return rest_is_empty(sb, 0);
1021 }
1022
1023 /*
1024  * See if the user edited the message in the editor or left what
1025  * was in the template intact
1026  */
1027 static int template_untouched(struct strbuf *sb)
1028 {
1029         struct strbuf tmpl = STRBUF_INIT;
1030         const char *start;
1031
1032         if (cleanup_mode == CLEANUP_NONE && sb->len)
1033                 return 0;
1034
1035         if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1036                 return 0;
1037
1038         strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1039         if (!skip_prefix(sb->buf, tmpl.buf, &start))
1040                 start = sb->buf;
1041         strbuf_release(&tmpl);
1042         return rest_is_empty(sb, start - sb->buf);
1043 }
1044
1045 static const char *find_author_by_nickname(const char *name)
1046 {
1047         struct rev_info revs;
1048         struct commit *commit;
1049         struct strbuf buf = STRBUF_INIT;
1050         struct string_list mailmap = STRING_LIST_INIT_NODUP;
1051         const char *av[20];
1052         int ac = 0;
1053
1054         init_revisions(&revs, NULL);
1055         strbuf_addf(&buf, "--author=%s", name);
1056         av[++ac] = "--all";
1057         av[++ac] = "-i";
1058         av[++ac] = buf.buf;
1059         av[++ac] = NULL;
1060         setup_revisions(ac, av, &revs, NULL);
1061         revs.mailmap = &mailmap;
1062         read_mailmap(revs.mailmap, NULL);
1063
1064         if (prepare_revision_walk(&revs))
1065                 die(_("revision walk setup failed"));
1066         commit = get_revision(&revs);
1067         if (commit) {
1068                 struct pretty_print_context ctx = {0};
1069                 ctx.date_mode.type = DATE_NORMAL;
1070                 strbuf_release(&buf);
1071                 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1072                 clear_mailmap(&mailmap);
1073                 return strbuf_detach(&buf, NULL);
1074         }
1075         die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1076 }
1077
1078
1079 static void handle_untracked_files_arg(struct wt_status *s)
1080 {
1081         if (!untracked_files_arg)
1082                 ; /* default already initialized */
1083         else if (!strcmp(untracked_files_arg, "no"))
1084                 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1085         else if (!strcmp(untracked_files_arg, "normal"))
1086                 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1087         else if (!strcmp(untracked_files_arg, "all"))
1088                 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1089         else
1090                 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1091 }
1092
1093 static const char *read_commit_message(const char *name)
1094 {
1095         const char *out_enc;
1096         struct commit *commit;
1097
1098         commit = lookup_commit_reference_by_name(name);
1099         if (!commit)
1100                 die(_("could not lookup commit %s"), name);
1101         out_enc = get_commit_output_encoding();
1102         return logmsg_reencode(commit, NULL, out_enc);
1103 }
1104
1105 /*
1106  * Enumerate what needs to be propagated when --porcelain
1107  * is not in effect here.
1108  */
1109 static struct status_deferred_config {
1110         enum wt_status_format status_format;
1111         int show_branch;
1112 } status_deferred_config = {
1113         STATUS_FORMAT_UNSPECIFIED,
1114         -1 /* unspecified */
1115 };
1116
1117 static void finalize_deferred_config(struct wt_status *s)
1118 {
1119         int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1120                                    status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1121                                    !s->null_termination);
1122
1123         if (s->null_termination) {
1124                 if (status_format == STATUS_FORMAT_NONE ||
1125                     status_format == STATUS_FORMAT_UNSPECIFIED)
1126                         status_format = STATUS_FORMAT_PORCELAIN;
1127                 else if (status_format == STATUS_FORMAT_LONG)
1128                         die(_("--long and -z are incompatible"));
1129         }
1130
1131         if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1132                 status_format = status_deferred_config.status_format;
1133         if (status_format == STATUS_FORMAT_UNSPECIFIED)
1134                 status_format = STATUS_FORMAT_NONE;
1135
1136         if (use_deferred_config && s->show_branch < 0)
1137                 s->show_branch = status_deferred_config.show_branch;
1138         if (s->show_branch < 0)
1139                 s->show_branch = 0;
1140 }
1141
1142 static int parse_and_validate_options(int argc, const char *argv[],
1143                                       const struct option *options,
1144                                       const char * const usage[],
1145                                       const char *prefix,
1146                                       struct commit *current_head,
1147                                       struct wt_status *s)
1148 {
1149         int f = 0;
1150
1151         argc = parse_options(argc, argv, prefix, options, usage, 0);
1152         finalize_deferred_config(s);
1153
1154         if (force_author && !strchr(force_author, '>'))
1155                 force_author = find_author_by_nickname(force_author);
1156
1157         if (force_author && renew_authorship)
1158                 die(_("Using both --reset-author and --author does not make sense"));
1159
1160         if (logfile || have_option_m || use_message || fixup_message)
1161                 use_editor = 0;
1162         if (0 <= edit_flag)
1163                 use_editor = edit_flag;
1164
1165         /* Sanity check options */
1166         if (amend && !current_head)
1167                 die(_("You have nothing to amend."));
1168         if (amend && whence != FROM_COMMIT) {
1169                 if (whence == FROM_MERGE)
1170                         die(_("You are in the middle of a merge -- cannot amend."));
1171                 else if (whence == FROM_CHERRY_PICK)
1172                         die(_("You are in the middle of a cherry-pick -- cannot amend."));
1173         }
1174         if (fixup_message && squash_message)
1175                 die(_("Options --squash and --fixup cannot be used together"));
1176         if (use_message)
1177                 f++;
1178         if (edit_message)
1179                 f++;
1180         if (fixup_message)
1181                 f++;
1182         if (logfile)
1183                 f++;
1184         if (f > 1)
1185                 die(_("Only one of -c/-C/-F/--fixup can be used."));
1186         if (have_option_m && f > 0)
1187                 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1188         if (f || have_option_m)
1189                 template_file = NULL;
1190         if (edit_message)
1191                 use_message = edit_message;
1192         if (amend && !use_message && !fixup_message)
1193                 use_message = "HEAD";
1194         if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1195                 die(_("--reset-author can be used only with -C, -c or --amend."));
1196         if (use_message) {
1197                 use_message_buffer = read_commit_message(use_message);
1198                 if (!renew_authorship) {
1199                         author_message = use_message;
1200                         author_message_buffer = use_message_buffer;
1201                 }
1202         }
1203         if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1204                 author_message = "CHERRY_PICK_HEAD";
1205                 author_message_buffer = read_commit_message(author_message);
1206         }
1207
1208         if (patch_interactive)
1209                 interactive = 1;
1210
1211         if (also + only + all + interactive > 1)
1212                 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1213         if (argc == 0 && (also || (only && !amend && !allow_empty)))
1214                 die(_("No paths with --include/--only does not make sense."));
1215         if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1216                 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1217         else if (!strcmp(cleanup_arg, "verbatim"))
1218                 cleanup_mode = CLEANUP_NONE;
1219         else if (!strcmp(cleanup_arg, "whitespace"))
1220                 cleanup_mode = CLEANUP_SPACE;
1221         else if (!strcmp(cleanup_arg, "strip"))
1222                 cleanup_mode = CLEANUP_ALL;
1223         else if (!strcmp(cleanup_arg, "scissors"))
1224                 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1225         else
1226                 die(_("Invalid cleanup mode %s"), cleanup_arg);
1227
1228         handle_untracked_files_arg(s);
1229
1230         if (all && argc > 0)
1231                 die(_("Paths with -a does not make sense."));
1232
1233         if (status_format != STATUS_FORMAT_NONE)
1234                 dry_run = 1;
1235
1236         return argc;
1237 }
1238
1239 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1240                           const struct commit *current_head, struct wt_status *s)
1241 {
1242         int commitable;
1243         const char *index_file;
1244
1245         index_file = prepare_index(argc, argv, prefix, current_head, 1);
1246         commitable = run_status(stdout, index_file, prefix, 0, s);
1247         rollback_index_files();
1248
1249         return commitable ? 0 : 1;
1250 }
1251
1252 static int parse_status_slot(const char *slot)
1253 {
1254         if (!strcasecmp(slot, "header"))
1255                 return WT_STATUS_HEADER;
1256         if (!strcasecmp(slot, "branch"))
1257                 return WT_STATUS_ONBRANCH;
1258         if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1259                 return WT_STATUS_UPDATED;
1260         if (!strcasecmp(slot, "changed"))
1261                 return WT_STATUS_CHANGED;
1262         if (!strcasecmp(slot, "untracked"))
1263                 return WT_STATUS_UNTRACKED;
1264         if (!strcasecmp(slot, "nobranch"))
1265                 return WT_STATUS_NOBRANCH;
1266         if (!strcasecmp(slot, "unmerged"))
1267                 return WT_STATUS_UNMERGED;
1268         if (!strcasecmp(slot, "localBranch"))
1269                 return WT_STATUS_LOCAL_BRANCH;
1270         if (!strcasecmp(slot, "remoteBranch"))
1271                 return WT_STATUS_REMOTE_BRANCH;
1272         return -1;
1273 }
1274
1275 static int git_status_config(const char *k, const char *v, void *cb)
1276 {
1277         struct wt_status *s = cb;
1278         const char *slot_name;
1279
1280         if (starts_with(k, "column."))
1281                 return git_column_config(k, v, "status", &s->colopts);
1282         if (!strcmp(k, "status.submodulesummary")) {
1283                 int is_bool;
1284                 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1285                 if (is_bool && s->submodule_summary)
1286                         s->submodule_summary = -1;
1287                 return 0;
1288         }
1289         if (!strcmp(k, "status.short")) {
1290                 if (git_config_bool(k, v))
1291                         status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1292                 else
1293                         status_deferred_config.status_format = STATUS_FORMAT_NONE;
1294                 return 0;
1295         }
1296         if (!strcmp(k, "status.branch")) {
1297                 status_deferred_config.show_branch = git_config_bool(k, v);
1298                 return 0;
1299         }
1300         if (!strcmp(k, "status.showstash")) {
1301                 s->show_stash = git_config_bool(k, v);
1302                 return 0;
1303         }
1304         if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1305                 s->use_color = git_config_colorbool(k, v);
1306                 return 0;
1307         }
1308         if (!strcmp(k, "status.displaycommentprefix")) {
1309                 s->display_comment_prefix = git_config_bool(k, v);
1310                 return 0;
1311         }
1312         if (skip_prefix(k, "status.color.", &slot_name) ||
1313             skip_prefix(k, "color.status.", &slot_name)) {
1314                 int slot = parse_status_slot(slot_name);
1315                 if (slot < 0)
1316                         return 0;
1317                 if (!v)
1318                         return config_error_nonbool(k);
1319                 return color_parse(v, s->color_palette[slot]);
1320         }
1321         if (!strcmp(k, "status.relativepaths")) {
1322                 s->relative_paths = git_config_bool(k, v);
1323                 return 0;
1324         }
1325         if (!strcmp(k, "status.showuntrackedfiles")) {
1326                 if (!v)
1327                         return config_error_nonbool(k);
1328                 else if (!strcmp(v, "no"))
1329                         s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1330                 else if (!strcmp(v, "normal"))
1331                         s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1332                 else if (!strcmp(v, "all"))
1333                         s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1334                 else
1335                         return error(_("Invalid untracked files mode '%s'"), v);
1336                 return 0;
1337         }
1338         return git_diff_ui_config(k, v, NULL);
1339 }
1340
1341 int cmd_status(int argc, const char **argv, const char *prefix)
1342 {
1343         static struct wt_status s;
1344         int fd;
1345         struct object_id oid;
1346         static struct option builtin_status_options[] = {
1347                 OPT__VERBOSE(&verbose, N_("be verbose")),
1348                 OPT_SET_INT('s', "short", &status_format,
1349                             N_("show status concisely"), STATUS_FORMAT_SHORT),
1350                 OPT_BOOL('b', "branch", &s.show_branch,
1351                          N_("show branch information")),
1352                 OPT_BOOL(0, "show-stash", &s.show_stash,
1353                          N_("show stash information")),
1354                 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1355                   N_("version"), N_("machine-readable output"),
1356                   PARSE_OPT_OPTARG, opt_parse_porcelain },
1357                 OPT_SET_INT(0, "long", &status_format,
1358                             N_("show status in long format (default)"),
1359                             STATUS_FORMAT_LONG),
1360                 OPT_BOOL('z', "null", &s.null_termination,
1361                          N_("terminate entries with NUL")),
1362                 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1363                   N_("mode"),
1364                   N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1365                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1366                 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1367                          N_("show ignored files")),
1368                 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1369                   N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1370                   PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1371                 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1372                 OPT_END(),
1373         };
1374
1375         if (argc == 2 && !strcmp(argv[1], "-h"))
1376                 usage_with_options(builtin_status_usage, builtin_status_options);
1377
1378         status_init_config(&s, git_status_config);
1379         argc = parse_options(argc, argv, prefix,
1380                              builtin_status_options,
1381                              builtin_status_usage, 0);
1382         finalize_colopts(&s.colopts, -1);
1383         finalize_deferred_config(&s);
1384
1385         handle_untracked_files_arg(&s);
1386         if (show_ignored_in_status)
1387                 s.show_ignored_files = 1;
1388         parse_pathspec(&s.pathspec, 0,
1389                        PATHSPEC_PREFER_FULL,
1390                        prefix, argv);
1391
1392         read_cache_preload(&s.pathspec);
1393         refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
1394
1395         if (use_optional_locks())
1396                 fd = hold_locked_index(&index_lock, 0);
1397         else
1398                 fd = -1;
1399
1400         s.is_initial = get_oid(s.reference, &oid) ? 1 : 0;
1401         if (!s.is_initial)
1402                 hashcpy(s.sha1_commit, oid.hash);
1403
1404         s.ignore_submodule_arg = ignore_submodule_arg;
1405         s.status_format = status_format;
1406         s.verbose = verbose;
1407
1408         wt_status_collect(&s);
1409
1410         if (0 <= fd)
1411                 update_index_if_able(&the_index, &index_lock);
1412
1413         if (s.relative_paths)
1414                 s.prefix = prefix;
1415
1416         wt_status_print(&s);
1417         return 0;
1418 }
1419
1420 static const char *implicit_ident_advice(void)
1421 {
1422         char *user_config = expand_user_path("~/.gitconfig", 0);
1423         char *xdg_config = xdg_config_home("config");
1424         int config_exists = file_exists(user_config) || file_exists(xdg_config);
1425
1426         free(user_config);
1427         free(xdg_config);
1428
1429         if (config_exists)
1430                 return _(implicit_ident_advice_config);
1431         else
1432                 return _(implicit_ident_advice_noconfig);
1433
1434 }
1435
1436 static void print_summary(const char *prefix, const struct object_id *oid,
1437                           int initial_commit)
1438 {
1439         struct rev_info rev;
1440         struct commit *commit;
1441         struct strbuf format = STRBUF_INIT;
1442         const char *head;
1443         struct pretty_print_context pctx = {0};
1444         struct strbuf author_ident = STRBUF_INIT;
1445         struct strbuf committer_ident = STRBUF_INIT;
1446
1447         commit = lookup_commit(oid);
1448         if (!commit)
1449                 die(_("couldn't look up newly created commit"));
1450         if (parse_commit(commit))
1451                 die(_("could not parse newly created commit"));
1452
1453         strbuf_addstr(&format, "format:%h] %s");
1454
1455         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1456         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1457         if (strbuf_cmp(&author_ident, &committer_ident)) {
1458                 strbuf_addstr(&format, "\n Author: ");
1459                 strbuf_addbuf_percentquote(&format, &author_ident);
1460         }
1461         if (author_date_is_interesting()) {
1462                 struct strbuf date = STRBUF_INIT;
1463                 format_commit_message(commit, "%ad", &date, &pctx);
1464                 strbuf_addstr(&format, "\n Date: ");
1465                 strbuf_addbuf_percentquote(&format, &date);
1466                 strbuf_release(&date);
1467         }
1468         if (!committer_ident_sufficiently_given()) {
1469                 strbuf_addstr(&format, "\n Committer: ");
1470                 strbuf_addbuf_percentquote(&format, &committer_ident);
1471                 if (advice_implicit_identity) {
1472                         strbuf_addch(&format, '\n');
1473                         strbuf_addstr(&format, implicit_ident_advice());
1474                 }
1475         }
1476         strbuf_release(&author_ident);
1477         strbuf_release(&committer_ident);
1478
1479         init_revisions(&rev, prefix);
1480         setup_revisions(0, NULL, &rev, NULL);
1481
1482         rev.diff = 1;
1483         rev.diffopt.output_format =
1484                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1485
1486         rev.verbose_header = 1;
1487         rev.show_root_diff = 1;
1488         get_commit_format(format.buf, &rev);
1489         rev.always_show_header = 0;
1490         rev.diffopt.detect_rename = 1;
1491         rev.diffopt.break_opt = 0;
1492         diff_setup_done(&rev.diffopt);
1493
1494         head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
1495         if (!strcmp(head, "HEAD"))
1496                 head = _("detached HEAD");
1497         else
1498                 skip_prefix(head, "refs/heads/", &head);
1499         printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1500
1501         if (!log_tree_commit(&rev, commit)) {
1502                 rev.always_show_header = 1;
1503                 rev.use_terminator = 1;
1504                 log_tree_commit(&rev, commit);
1505         }
1506
1507         strbuf_release(&format);
1508 }
1509
1510 static int git_commit_config(const char *k, const char *v, void *cb)
1511 {
1512         struct wt_status *s = cb;
1513         int status;
1514
1515         if (!strcmp(k, "commit.template"))
1516                 return git_config_pathname(&template_file, k, v);
1517         if (!strcmp(k, "commit.status")) {
1518                 include_status = git_config_bool(k, v);
1519                 return 0;
1520         }
1521         if (!strcmp(k, "commit.cleanup"))
1522                 return git_config_string(&cleanup_arg, k, v);
1523         if (!strcmp(k, "commit.gpgsign")) {
1524                 sign_commit = git_config_bool(k, v) ? "" : NULL;
1525                 return 0;
1526         }
1527         if (!strcmp(k, "commit.verbose")) {
1528                 int is_bool;
1529                 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1530                 return 0;
1531         }
1532
1533         status = git_gpg_config(k, v, NULL);
1534         if (status)
1535                 return status;
1536         return git_status_config(k, v, s);
1537 }
1538
1539 static int run_rewrite_hook(const struct object_id *oldoid,
1540                             const struct object_id *newoid)
1541 {
1542         struct child_process proc = CHILD_PROCESS_INIT;
1543         const char *argv[3];
1544         int code;
1545         struct strbuf sb = STRBUF_INIT;
1546
1547         argv[0] = find_hook("post-rewrite");
1548         if (!argv[0])
1549                 return 0;
1550
1551         argv[1] = "amend";
1552         argv[2] = NULL;
1553
1554         proc.argv = argv;
1555         proc.in = -1;
1556         proc.stdout_to_stderr = 1;
1557
1558         code = start_command(&proc);
1559         if (code)
1560                 return code;
1561         strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
1562         sigchain_push(SIGPIPE, SIG_IGN);
1563         write_in_full(proc.in, sb.buf, sb.len);
1564         close(proc.in);
1565         strbuf_release(&sb);
1566         sigchain_pop(SIGPIPE);
1567         return finish_command(&proc);
1568 }
1569
1570 int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1571 {
1572         struct argv_array hook_env = ARGV_ARRAY_INIT;
1573         va_list args;
1574         int ret;
1575
1576         argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1577
1578         /*
1579          * Let the hook know that no editor will be launched.
1580          */
1581         if (!editor_is_used)
1582                 argv_array_push(&hook_env, "GIT_EDITOR=:");
1583
1584         va_start(args, name);
1585         ret = run_hook_ve(hook_env.argv,name, args);
1586         va_end(args);
1587         argv_array_clear(&hook_env);
1588
1589         return ret;
1590 }
1591
1592 int cmd_commit(int argc, const char **argv, const char *prefix)
1593 {
1594         static struct wt_status s;
1595         static struct option builtin_commit_options[] = {
1596                 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1597                 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1598
1599                 OPT_GROUP(N_("Commit message options")),
1600                 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1601                 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1602                 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1603                 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1604                 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1605                 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1606                 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1607                 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1608                 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1609                 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1610                 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1611                 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1612                 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1613                 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1614                 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1615                   N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1616                 /* end commit message options */
1617
1618                 OPT_GROUP(N_("Commit contents options")),
1619                 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1620                 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1621                 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1622                 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1623                 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1624                 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1625                 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1626                 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1627                             STATUS_FORMAT_SHORT),
1628                 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1629                 OPT_SET_INT(0, "porcelain", &status_format,
1630                             N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1631                 OPT_SET_INT(0, "long", &status_format,
1632                             N_("show status in long format (default)"),
1633                             STATUS_FORMAT_LONG),
1634                 OPT_BOOL('z', "null", &s.null_termination,
1635                          N_("terminate entries with NUL")),
1636                 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1637                 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1638                 { 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" },
1639                 /* end commit contents options */
1640
1641                 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1642                                 N_("ok to record an empty change")),
1643                 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1644                                 N_("ok to record a change with an empty message")),
1645
1646                 OPT_END()
1647         };
1648
1649         struct strbuf sb = STRBUF_INIT;
1650         struct strbuf author_ident = STRBUF_INIT;
1651         const char *index_file, *reflog_msg;
1652         char *nl;
1653         struct object_id oid;
1654         struct commit_list *parents = NULL;
1655         struct stat statbuf;
1656         struct commit *current_head = NULL;
1657         struct commit_extra_header *extra = NULL;
1658         struct ref_transaction *transaction;
1659         struct strbuf err = STRBUF_INIT;
1660
1661         if (argc == 2 && !strcmp(argv[1], "-h"))
1662                 usage_with_options(builtin_commit_usage, builtin_commit_options);
1663
1664         status_init_config(&s, git_commit_config);
1665         s.commit_template = 1;
1666         status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1667         s.colopts = 0;
1668
1669         if (get_oid("HEAD", &oid))
1670                 current_head = NULL;
1671         else {
1672                 current_head = lookup_commit_or_die(&oid, "HEAD");
1673                 if (parse_commit(current_head))
1674                         die(_("could not parse HEAD commit"));
1675         }
1676         verbose = -1; /* unspecified */
1677         argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1678                                           builtin_commit_usage,
1679                                           prefix, current_head, &s);
1680         if (verbose == -1)
1681                 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1682
1683         if (dry_run)
1684                 return dry_run_commit(argc, argv, prefix, current_head, &s);
1685         index_file = prepare_index(argc, argv, prefix, current_head, 0);
1686
1687         /* Set up everything for writing the commit object.  This includes
1688            running hooks, writing the trees, and interacting with the user.  */
1689         if (!prepare_to_commit(index_file, prefix,
1690                                current_head, &s, &author_ident)) {
1691                 rollback_index_files();
1692                 return 1;
1693         }
1694
1695         /* Determine parents */
1696         reflog_msg = getenv("GIT_REFLOG_ACTION");
1697         if (!current_head) {
1698                 if (!reflog_msg)
1699                         reflog_msg = "commit (initial)";
1700         } else if (amend) {
1701                 if (!reflog_msg)
1702                         reflog_msg = "commit (amend)";
1703                 parents = copy_commit_list(current_head->parents);
1704         } else if (whence == FROM_MERGE) {
1705                 struct strbuf m = STRBUF_INIT;
1706                 FILE *fp;
1707                 int allow_fast_forward = 1;
1708                 struct commit_list **pptr = &parents;
1709
1710                 if (!reflog_msg)
1711                         reflog_msg = "commit (merge)";
1712                 pptr = commit_list_append(current_head, pptr);
1713                 fp = xfopen(git_path_merge_head(), "r");
1714                 while (strbuf_getline_lf(&m, fp) != EOF) {
1715                         struct commit *parent;
1716
1717                         parent = get_merge_parent(m.buf);
1718                         if (!parent)
1719                                 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1720                         pptr = commit_list_append(parent, pptr);
1721                 }
1722                 fclose(fp);
1723                 strbuf_release(&m);
1724                 if (!stat(git_path_merge_mode(), &statbuf)) {
1725                         if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1726                                 die_errno(_("could not read MERGE_MODE"));
1727                         if (!strcmp(sb.buf, "no-ff"))
1728                                 allow_fast_forward = 0;
1729                 }
1730                 if (allow_fast_forward)
1731                         parents = reduce_heads(parents);
1732         } else {
1733                 if (!reflog_msg)
1734                         reflog_msg = (whence == FROM_CHERRY_PICK)
1735                                         ? "commit (cherry-pick)"
1736                                         : "commit";
1737                 commit_list_insert(current_head, &parents);
1738         }
1739
1740         /* Finally, get the commit message */
1741         strbuf_reset(&sb);
1742         if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1743                 int saved_errno = errno;
1744                 rollback_index_files();
1745                 die(_("could not read commit message: %s"), strerror(saved_errno));
1746         }
1747
1748         if (verbose || /* Truncate the message just before the diff, if any. */
1749             cleanup_mode == CLEANUP_SCISSORS)
1750                 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
1751         if (cleanup_mode != CLEANUP_NONE)
1752                 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1753
1754         if (message_is_empty(&sb) && !allow_empty_message) {
1755                 rollback_index_files();
1756                 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1757                 exit(1);
1758         }
1759         if (template_untouched(&sb) && !allow_empty_message) {
1760                 rollback_index_files();
1761                 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1762                 exit(1);
1763         }
1764
1765         if (amend) {
1766                 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1767                 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1768         } else {
1769                 struct commit_extra_header **tail = &extra;
1770                 append_merge_tag_headers(parents, &tail);
1771         }
1772
1773         if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
1774                          parents, oid.hash, author_ident.buf, sign_commit, extra)) {
1775                 rollback_index_files();
1776                 die(_("failed to write commit object"));
1777         }
1778         strbuf_release(&author_ident);
1779         free_commit_extra_headers(extra);
1780
1781         nl = strchr(sb.buf, '\n');
1782         if (nl)
1783                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1784         else
1785                 strbuf_addch(&sb, '\n');
1786         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1787         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1788
1789         transaction = ref_transaction_begin(&err);
1790         if (!transaction ||
1791             ref_transaction_update(transaction, "HEAD", oid.hash,
1792                                    current_head
1793                                    ? current_head->object.oid.hash : null_sha1,
1794                                    0, sb.buf, &err) ||
1795             ref_transaction_commit(transaction, &err)) {
1796                 rollback_index_files();
1797                 die("%s", err.buf);
1798         }
1799         ref_transaction_free(transaction);
1800
1801         unlink(git_path_cherry_pick_head());
1802         unlink(git_path_revert_head());
1803         unlink(git_path_merge_head());
1804         unlink(git_path_merge_msg());
1805         unlink(git_path_merge_mode());
1806         unlink(git_path_squash_msg());
1807
1808         if (commit_index_files())
1809                 die (_("Repository has been updated, but unable to write\n"
1810                      "new_index file. Check that disk is not full and quota is\n"
1811                      "not exceeded, and then \"git reset HEAD\" to recover."));
1812
1813         rerere(0);
1814         run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1815         if (amend && !no_post_rewrite) {
1816                 struct notes_rewrite_cfg *cfg;
1817                 cfg = init_copy_notes_for_rewrite("amend");
1818                 if (cfg) {
1819                         /* we are amending, so current_head is not NULL */
1820                         copy_note_for_rewrite(cfg, &current_head->object.oid, &oid);
1821                         finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1822                 }
1823                 run_rewrite_hook(&current_head->object.oid, &oid);
1824         }
1825         if (!quiet)
1826                 print_summary(prefix, &oid, !current_head);
1827
1828         UNLEAK(err);
1829         UNLEAK(sb);
1830         return 0;
1831 }