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