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