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