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