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