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