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