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