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