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