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