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