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