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