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