4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
9 #include "cache-tree.h"
17 #include "wt-status.h"
18 #include "run-command.h"
23 #include "parse-options.h"
24 #include "string-list.h"
26 #include "unpack-trees.h"
28 #include "submodule.h"
29 #include "gpg-interface.h"
31 #include "sequencer.h"
32 #include "notes-utils.h"
35 static const char * const builtin_commit_usage
[] = {
36 N_("git commit [options] [--] <pathspec>..."),
40 static const char * const builtin_status_usage
[] = {
41 N_("git status [options] [--] <pathspec>..."),
45 static const char implicit_ident_advice
[] =
46 N_("Your name and email address were configured automatically based\n"
47 "on your username and hostname. Please check that they are accurate.\n"
48 "You can suppress this message by setting them explicitly:\n"
50 " git config --global user.name \"Your Name\"\n"
51 " git config --global user.email you@example.com\n"
53 "After doing this, you may fix the identity used for this commit with:\n"
55 " git commit --amend --reset-author\n");
57 static const char empty_amend_advice
[] =
58 N_("You asked to amend the most recent commit, but doing so would make\n"
59 "it empty. You can repeat your command with --allow-empty, or you can\n"
60 "remove the commit entirely with \"git reset HEAD^\".\n");
62 static const char empty_cherry_pick_advice
[] =
63 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
64 "If you wish to commit it anyway, use:\n"
66 " git commit --allow-empty\n"
69 static const char empty_cherry_pick_advice_single
[] =
70 N_("Otherwise, please use 'git reset'\n");
72 static const char empty_cherry_pick_advice_multi
[] =
73 N_("If you wish to skip this commit, use:\n"
77 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
78 "the remaining commits.\n");
80 static const char *use_message_buffer
;
81 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
82 static struct lock_file index_lock
; /* real index */
83 static struct lock_file false_lock
; /* used only for partial commits */
90 static const char *logfile
, *force_author
;
91 static const char *template_file
;
93 * The _message variables are commit names from which to take
94 * the commit message and/or authorship.
96 static const char *author_message
, *author_message_buffer
;
97 static char *edit_message
, *use_message
;
98 static char *fixup_message
, *squash_message
;
99 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
100 static int edit_flag
= -1; /* unspecified */
101 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
102 static int no_post_rewrite
, allow_empty_message
;
103 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
104 static char *sign_commit
;
107 * The default commit message cleanup mode will remove the lines
108 * beginning with # (shell comments) and leading and trailing
109 * whitespaces (empty lines or containing only whitespaces)
110 * if editor is used, and only the whitespaces if the message
111 * is specified explicitly.
118 static const char *cleanup_arg
;
120 static enum commit_whence whence
;
121 static int sequencer_in_use
;
122 static int use_editor
= 1, include_status
= 1;
123 static int show_ignored_in_status
, have_option_m
;
124 static const char *only_include_assumed
;
125 static struct strbuf message
= STRBUF_INIT
;
127 static enum status_format
{
128 STATUS_FORMAT_NONE
= 0,
131 STATUS_FORMAT_PORCELAIN
,
133 STATUS_FORMAT_UNSPECIFIED
134 } status_format
= STATUS_FORMAT_UNSPECIFIED
;
136 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
138 struct strbuf
*buf
= opt
->value
;
141 strbuf_setlen(buf
, 0);
145 strbuf_addch(buf
, '\n');
146 strbuf_addstr(buf
, arg
);
147 strbuf_complete_line(buf
);
152 static void determine_whence(struct wt_status
*s
)
154 if (file_exists(git_path("MERGE_HEAD")))
156 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
157 whence
= FROM_CHERRY_PICK
;
158 if (file_exists(git_path("sequencer")))
159 sequencer_in_use
= 1;
162 whence
= FROM_COMMIT
;
167 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
169 wt_status_prepare(s
);
173 s
->hints
= advice_status_hints
; /* must come after git_config() */
176 static void rollback_index_files(void)
178 switch (commit_style
) {
180 break; /* nothing to do */
182 rollback_lock_file(&index_lock
);
185 rollback_lock_file(&index_lock
);
186 rollback_lock_file(&false_lock
);
191 static int commit_index_files(void)
195 switch (commit_style
) {
197 break; /* nothing to do */
199 err
= commit_lock_file(&index_lock
);
202 err
= commit_lock_file(&index_lock
);
203 rollback_lock_file(&false_lock
);
211 * Take a union of paths in the index and the named tree (typically, "HEAD"),
212 * and return the paths that match the given pattern in list.
214 static int list_paths(struct string_list
*list
, const char *with_tree
,
215 const char *prefix
, const struct pathspec
*pattern
)
223 m
= xcalloc(1, pattern
->nr
);
226 char *max_prefix
= common_prefix(pattern
);
227 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
231 for (i
= 0; i
< active_nr
; i
++) {
232 const struct cache_entry
*ce
= active_cache
[i
];
233 struct string_list_item
*item
;
235 if (ce
->ce_flags
& CE_UPDATE
)
237 if (!match_pathspec_depth(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
239 item
= string_list_insert(list
, ce
->name
);
240 if (ce_skip_worktree(ce
))
241 item
->util
= item
; /* better a valid pointer than a fake one */
244 return report_path_error(m
, pattern
, prefix
);
247 static void add_remove_files(struct string_list
*list
)
250 for (i
= 0; i
< list
->nr
; i
++) {
252 struct string_list_item
*p
= &(list
->items
[i
]);
254 /* p->util is skip-worktree */
258 if (!lstat(p
->string
, &st
)) {
259 if (add_to_cache(p
->string
, &st
, 0))
260 die(_("updating files failed"));
262 remove_file_from_cache(p
->string
);
266 static void create_base_index(const struct commit
*current_head
)
269 struct unpack_trees_options opts
;
277 memset(&opts
, 0, sizeof(opts
));
281 opts
.src_index
= &the_index
;
282 opts
.dst_index
= &the_index
;
284 opts
.fn
= oneway_merge
;
285 tree
= parse_tree_indirect(current_head
->object
.sha1
);
287 die(_("failed to unpack HEAD tree object"));
289 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
290 if (unpack_trees(1, &t
, &opts
))
291 exit(128); /* We've already reported the error, finish dying */
294 static void refresh_cache_or_die(int refresh_flags
)
297 * refresh_flags contains REFRESH_QUIET, so the only errors
298 * are for unmerged entries.
300 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
301 die_resolve_conflict("commit");
304 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
305 const struct commit
*current_head
, int is_status
)
308 struct string_list partial
;
309 struct pathspec pathspec
;
310 char *old_index_env
= NULL
;
311 int refresh_flags
= REFRESH_QUIET
;
314 refresh_flags
|= REFRESH_UNMERGED
;
315 parse_pathspec(&pathspec
, 0,
316 PATHSPEC_PREFER_FULL
,
319 if (read_cache_preload(&pathspec
) < 0)
320 die(_("index file corrupt"));
323 fd
= hold_locked_index(&index_lock
, 1);
325 refresh_cache_or_die(refresh_flags
);
327 if (write_cache(fd
, active_cache
, active_nr
) ||
328 close_lock_file(&index_lock
))
329 die(_("unable to create temporary index"));
331 old_index_env
= getenv(INDEX_ENVIRONMENT
);
332 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
334 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
335 die(_("interactive add failed"));
337 if (old_index_env
&& *old_index_env
)
338 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
340 unsetenv(INDEX_ENVIRONMENT
);
343 read_cache_from(index_lock
.filename
);
345 commit_style
= COMMIT_NORMAL
;
346 return index_lock
.filename
;
350 * Non partial, non as-is commit.
352 * (1) get the real index;
353 * (2) update the_index as necessary;
354 * (3) write the_index out to the real index (still locked);
355 * (4) return the name of the locked index file.
357 * The caller should run hooks on the locked real index, and
358 * (A) if all goes well, commit the real index;
359 * (B) on failure, rollback the real index.
361 if (all
|| (also
&& pathspec
.nr
)) {
362 fd
= hold_locked_index(&index_lock
, 1);
363 add_files_to_cache(also
? prefix
: NULL
, &pathspec
, 0);
364 refresh_cache_or_die(refresh_flags
);
365 update_main_cache_tree(WRITE_TREE_SILENT
);
366 if (write_cache(fd
, active_cache
, active_nr
) ||
367 close_lock_file(&index_lock
))
368 die(_("unable to write new_index file"));
369 commit_style
= COMMIT_NORMAL
;
370 return index_lock
.filename
;
376 * (1) return the name of the real index file.
378 * The caller should run hooks on the real index,
379 * and create commit from the_index.
380 * We still need to refresh the index here.
382 if (!only
&& !pathspec
.nr
) {
383 fd
= hold_locked_index(&index_lock
, 1);
384 refresh_cache_or_die(refresh_flags
);
385 if (active_cache_changed
) {
386 update_main_cache_tree(WRITE_TREE_SILENT
);
387 if (write_cache(fd
, active_cache
, active_nr
) ||
388 commit_locked_index(&index_lock
))
389 die(_("unable to write new_index file"));
391 rollback_lock_file(&index_lock
);
393 commit_style
= COMMIT_AS_IS
;
394 return get_index_file();
400 * (0) find the set of affected paths;
401 * (1) get lock on the real index file;
402 * (2) update the_index with the given paths;
403 * (3) write the_index out to the real index (still locked);
404 * (4) get lock on the false index file;
405 * (5) reset the_index from HEAD;
406 * (6) update the_index the same way as (2);
407 * (7) write the_index out to the false index file;
408 * (8) return the name of the false index file (still locked);
410 * The caller should run hooks on the locked false index, and
411 * create commit from it. Then
412 * (A) if all goes well, commit the real index;
413 * (B) on failure, rollback the real index;
414 * In either case, rollback the false index.
416 commit_style
= COMMIT_PARTIAL
;
418 if (whence
!= FROM_COMMIT
) {
419 if (whence
== FROM_MERGE
)
420 die(_("cannot do a partial commit during a merge."));
421 else if (whence
== FROM_CHERRY_PICK
)
422 die(_("cannot do a partial commit during a cherry-pick."));
425 memset(&partial
, 0, sizeof(partial
));
426 partial
.strdup_strings
= 1;
427 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, &pathspec
))
431 if (read_cache() < 0)
432 die(_("cannot read the index"));
434 fd
= hold_locked_index(&index_lock
, 1);
435 add_remove_files(&partial
);
436 refresh_cache(REFRESH_QUIET
);
437 if (write_cache(fd
, active_cache
, active_nr
) ||
438 close_lock_file(&index_lock
))
439 die(_("unable to write new_index file"));
441 fd
= hold_lock_file_for_update(&false_lock
,
442 git_path("next-index-%"PRIuMAX
,
443 (uintmax_t) getpid()),
446 create_base_index(current_head
);
447 add_remove_files(&partial
);
448 refresh_cache(REFRESH_QUIET
);
450 if (write_cache(fd
, active_cache
, active_nr
) ||
451 close_lock_file(&false_lock
))
452 die(_("unable to write temporary index file"));
455 read_cache_from(false_lock
.filename
);
457 return false_lock
.filename
;
460 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
463 unsigned char sha1
[20];
465 if (s
->relative_paths
)
470 s
->reference
= "HEAD^1";
472 s
->verbose
= verbose
;
473 s
->index_file
= index_file
;
476 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
478 wt_status_collect(s
);
480 switch (status_format
) {
481 case STATUS_FORMAT_SHORT
:
482 wt_shortstatus_print(s
);
484 case STATUS_FORMAT_PORCELAIN
:
485 wt_porcelain_print(s
);
487 case STATUS_FORMAT_UNSPECIFIED
:
488 die("BUG: finalize_deferred_config() should have been called");
490 case STATUS_FORMAT_NONE
:
491 case STATUS_FORMAT_LONG
:
496 return s
->commitable
;
499 static int is_a_merge(const struct commit
*current_head
)
501 return !!(current_head
->parents
&& current_head
->parents
->next
);
504 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
506 struct strbuf buf
= STRBUF_INIT
;
508 strbuf_addch(&buf
, hack
);
509 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
510 setenv(var
, buf
.buf
, 1);
511 strbuf_release(&buf
);
514 static int sane_ident_split(struct ident_split
*person
)
516 if (!person
->name_begin
|| !person
->name_end
||
517 person
->name_begin
== person
->name_end
)
518 return 0; /* no human readable name */
519 if (!person
->mail_begin
|| !person
->mail_end
||
520 person
->mail_begin
== person
->mail_end
)
521 return 0; /* no usable mail */
522 if (!person
->date_begin
|| !person
->date_end
||
523 !person
->tz_begin
|| !person
->tz_end
)
528 static void determine_author_info(struct strbuf
*author_ident
)
530 char *name
, *email
, *date
;
531 struct ident_split author
;
533 name
= getenv("GIT_AUTHOR_NAME");
534 email
= getenv("GIT_AUTHOR_EMAIL");
535 date
= getenv("GIT_AUTHOR_DATE");
537 if (author_message
) {
538 const char *a
, *lb
, *rb
, *eol
;
541 a
= strstr(author_message_buffer
, "\nauthor ");
543 die(_("invalid commit: %s"), author_message
);
545 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
546 rb
= strchrnul(lb
, '>');
547 eol
= strchrnul(rb
, '\n');
548 if (!*lb
|| !*rb
|| !*eol
)
549 die(_("invalid commit: %s"), author_message
);
551 if (lb
== a
+ strlen("\nauthor "))
552 /* \nauthor <foo@example.com> */
553 name
= xcalloc(1, 1);
555 name
= xmemdupz(a
+ strlen("\nauthor "),
557 (a
+ strlen("\nauthor "))));
558 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
559 len
= eol
- (rb
+ strlen("> "));
560 date
= xmalloc(len
+ 2);
562 memcpy(date
+ 1, rb
+ strlen("> "), len
);
563 date
[len
+ 1] = '\0';
567 const char *lb
= strstr(force_author
, " <");
568 const char *rb
= strchr(force_author
, '>');
571 die(_("malformed --author parameter"));
572 name
= xstrndup(force_author
, lb
- force_author
);
573 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
578 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
579 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
580 sane_ident_split(&author
)) {
581 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
582 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
583 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
587 static char *cut_ident_timestamp_part(char *string
)
589 char *ket
= strrchr(string
, '>');
590 if (!ket
|| ket
[1] != ' ')
591 die(_("Malformed ident string: '%s'"), string
);
596 static int prepare_to_commit(const char *index_file
, const char *prefix
,
597 struct commit
*current_head
,
599 struct strbuf
*author_ident
)
602 struct strbuf committer_ident
= STRBUF_INIT
;
603 int commitable
, saved_color_setting
;
604 struct strbuf sb
= STRBUF_INIT
;
606 const char *hook_arg1
= NULL
;
607 const char *hook_arg2
= NULL
;
609 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
610 int old_display_comment_prefix
;
612 /* This checks and barfs if author is badly specified */
613 determine_author_info(author_ident
);
615 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
618 if (squash_message
) {
620 * Insert the proper subject line before other commit
621 * message options add their content.
623 if (use_message
&& !strcmp(use_message
, squash_message
))
624 strbuf_addstr(&sb
, "squash! ");
626 struct pretty_print_context ctx
= {0};
628 c
= lookup_commit_reference_by_name(squash_message
);
630 die(_("could not lookup commit %s"), squash_message
);
631 ctx
.output_encoding
= get_commit_output_encoding();
632 format_commit_message(c
, "squash! %s\n\n", &sb
,
638 strbuf_addbuf(&sb
, &message
);
639 hook_arg1
= "message";
640 } else if (logfile
&& !strcmp(logfile
, "-")) {
642 fprintf(stderr
, _("(reading log message from standard input)\n"));
643 if (strbuf_read(&sb
, 0, 0) < 0)
644 die_errno(_("could not read log from standard input"));
645 hook_arg1
= "message";
646 } else if (logfile
) {
647 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
648 die_errno(_("could not read log file '%s'"),
650 hook_arg1
= "message";
651 } else if (use_message
) {
652 buffer
= strstr(use_message_buffer
, "\n\n");
653 if (!use_editor
&& (!buffer
|| buffer
[2] == '\0'))
654 die(_("commit has empty message"));
655 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
656 hook_arg1
= "commit";
657 hook_arg2
= use_message
;
658 } else if (fixup_message
) {
659 struct pretty_print_context ctx
= {0};
660 struct commit
*commit
;
661 commit
= lookup_commit_reference_by_name(fixup_message
);
663 die(_("could not lookup commit %s"), fixup_message
);
664 ctx
.output_encoding
= get_commit_output_encoding();
665 format_commit_message(commit
, "fixup! %s\n\n",
667 hook_arg1
= "message";
668 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
669 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
670 die_errno(_("could not read MERGE_MSG"));
672 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
673 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
674 die_errno(_("could not read SQUASH_MSG"));
675 hook_arg1
= "squash";
676 } else if (template_file
) {
677 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
678 die_errno(_("could not read '%s'"), template_file
);
679 hook_arg1
= "template";
680 clean_message_contents
= 0;
684 * The remaining cases don't modify the template message, but
685 * just set the argument(s) to the prepare-commit-msg hook.
687 else if (whence
== FROM_MERGE
)
689 else if (whence
== FROM_CHERRY_PICK
) {
690 hook_arg1
= "commit";
691 hook_arg2
= "CHERRY_PICK_HEAD";
694 if (squash_message
) {
696 * If squash_commit was used for the commit subject,
697 * then we're possibly hijacking other commit log options.
698 * Reset the hook args to tell the real story.
700 hook_arg1
= "message";
704 s
->fp
= fopen(git_path(commit_editmsg
), "w");
706 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
708 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
709 old_display_comment_prefix
= s
->display_comment_prefix
;
710 s
->display_comment_prefix
= 1;
713 * Most hints are counter-productive when the commit has
718 if (clean_message_contents
)
723 * See if we have a Conflicts: block at the end. If yes, count
724 * its size, so we can ignore it.
726 int ignore_footer
= 0;
727 int i
, eol
, previous
= 0;
730 for (i
= 0; i
< sb
.len
; i
++) {
731 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
736 if (starts_with(sb
.buf
+ previous
, "\nConflicts:\n")) {
737 ignore_footer
= sb
.len
- previous
;
745 append_signoff(&sb
, ignore_footer
, 0);
748 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
749 die_errno(_("could not write commit template"));
753 /* This checks if committer ident is explicitly given */
754 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
755 if (use_editor
&& include_status
) {
756 char *ai_tmp
, *ci_tmp
;
757 if (whence
!= FROM_COMMIT
)
758 status_printf_ln(s
, GIT_COLOR_NORMAL
,
761 "It looks like you may be committing a merge.\n"
762 "If this is not correct, please remove the file\n"
766 "It looks like you may be committing a cherry-pick.\n"
767 "If this is not correct, please remove the file\n"
770 git_path(whence
== FROM_MERGE
772 : "CHERRY_PICK_HEAD"));
774 fprintf(s
->fp
, "\n");
775 if (cleanup_mode
== CLEANUP_ALL
)
776 status_printf(s
, GIT_COLOR_NORMAL
,
777 _("Please enter the commit message for your changes."
778 " Lines starting\nwith '%c' will be ignored, and an empty"
779 " message aborts the commit.\n"), comment_line_char
);
780 else /* CLEANUP_SPACE, that is. */
781 status_printf(s
, GIT_COLOR_NORMAL
,
782 _("Please enter the commit message for your changes."
784 "with '%c' will be kept; you may remove them"
785 " yourself if you want to.\n"
786 "An empty message aborts the commit.\n"), comment_line_char
);
787 if (only_include_assumed
)
788 status_printf_ln(s
, GIT_COLOR_NORMAL
,
789 "%s", only_include_assumed
);
791 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
792 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
793 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
794 status_printf_ln(s
, GIT_COLOR_NORMAL
,
797 ident_shown
++ ? "" : "\n",
800 if (!committer_ident_sufficiently_given())
801 status_printf_ln(s
, GIT_COLOR_NORMAL
,
804 ident_shown
++ ? "" : "\n",
805 committer_ident
.buf
);
808 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
810 saved_color_setting
= s
->use_color
;
812 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
813 s
->use_color
= saved_color_setting
;
818 unsigned char sha1
[20];
819 const char *parent
= "HEAD";
821 if (!active_nr
&& read_cache() < 0)
822 die(_("Cannot read index"));
827 if (get_sha1(parent
, sha1
))
828 commitable
= !!active_nr
;
831 * Unless the user did explicitly request a submodule
832 * ignore mode by passing a command line option we do
833 * not ignore any changed submodule SHA-1s when
834 * comparing index and parent, no matter what is
835 * configured. Otherwise we won't commit any
836 * submodules which were manually staged, which would
837 * be really confusing.
839 int diff_flags
= DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG
;
840 if (ignore_submodule_arg
&&
841 !strcmp(ignore_submodule_arg
, "all"))
842 diff_flags
|= DIFF_OPT_IGNORE_SUBMODULES
;
843 commitable
= index_differs_from(parent
, diff_flags
);
846 strbuf_release(&committer_ident
);
851 * Reject an attempt to record a non-merge empty commit without
852 * explicit --allow-empty. In the cherry-pick case, it may be
853 * empty due to conflict resolution, which the user should okay.
855 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
856 !(amend
&& is_a_merge(current_head
))) {
857 s
->display_comment_prefix
= old_display_comment_prefix
;
858 run_status(stdout
, index_file
, prefix
, 0, s
);
860 fputs(_(empty_amend_advice
), stderr
);
861 else if (whence
== FROM_CHERRY_PICK
) {
862 fputs(_(empty_cherry_pick_advice
), stderr
);
863 if (!sequencer_in_use
)
864 fputs(_(empty_cherry_pick_advice_single
), stderr
);
866 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
872 * Re-read the index as pre-commit hook could have updated it,
873 * and write it out as a tree. We must do this before we invoke
874 * the editor and after we invoke run_status above.
877 read_cache_from(index_file
);
878 if (update_main_cache_tree(0)) {
879 error(_("Error building trees"));
883 if (run_hook(index_file
, "prepare-commit-msg",
884 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
888 char index
[PATH_MAX
];
889 const char *env
[2] = { NULL
};
891 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
892 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
894 _("Please supply the message using either -m or -F option.\n"));
900 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
907 static int rest_is_empty(struct strbuf
*sb
, int start
)
912 /* Check if the rest is just whitespace and Signed-of-by's. */
913 for (i
= start
; i
< sb
->len
; i
++) {
914 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
920 if (strlen(sign_off_header
) <= eol
- i
&&
921 starts_with(sb
->buf
+ i
, sign_off_header
)) {
926 if (!isspace(sb
->buf
[i
++]))
934 * Find out if the message in the strbuf contains only whitespace and
935 * Signed-off-by lines.
937 static int message_is_empty(struct strbuf
*sb
)
939 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
941 return rest_is_empty(sb
, 0);
945 * See if the user edited the message in the editor or left what
946 * was in the template intact
948 static int template_untouched(struct strbuf
*sb
)
950 struct strbuf tmpl
= STRBUF_INIT
;
953 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
956 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
959 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
960 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
963 strbuf_release(&tmpl
);
964 return rest_is_empty(sb
, start
- sb
->buf
);
967 static const char *find_author_by_nickname(const char *name
)
969 struct rev_info revs
;
970 struct commit
*commit
;
971 struct strbuf buf
= STRBUF_INIT
;
972 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
976 init_revisions(&revs
, NULL
);
977 strbuf_addf(&buf
, "--author=%s", name
);
982 setup_revisions(ac
, av
, &revs
, NULL
);
983 revs
.mailmap
= &mailmap
;
984 read_mailmap(revs
.mailmap
, NULL
);
986 prepare_revision_walk(&revs
);
987 commit
= get_revision(&revs
);
989 struct pretty_print_context ctx
= {0};
990 ctx
.date_mode
= DATE_NORMAL
;
991 strbuf_release(&buf
);
992 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
993 clear_mailmap(&mailmap
);
994 return strbuf_detach(&buf
, NULL
);
996 die(_("No existing author found with '%s'"), name
);
1000 static void handle_untracked_files_arg(struct wt_status
*s
)
1002 if (!untracked_files_arg
)
1003 ; /* default already initialized */
1004 else if (!strcmp(untracked_files_arg
, "no"))
1005 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1006 else if (!strcmp(untracked_files_arg
, "normal"))
1007 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1008 else if (!strcmp(untracked_files_arg
, "all"))
1009 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1011 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1014 static const char *read_commit_message(const char *name
)
1016 const char *out_enc
;
1017 struct commit
*commit
;
1019 commit
= lookup_commit_reference_by_name(name
);
1021 die(_("could not lookup commit %s"), name
);
1022 out_enc
= get_commit_output_encoding();
1023 return logmsg_reencode(commit
, NULL
, out_enc
);
1027 * Enumerate what needs to be propagated when --porcelain
1028 * is not in effect here.
1030 static struct status_deferred_config
{
1031 enum status_format status_format
;
1033 } status_deferred_config
= {
1034 STATUS_FORMAT_UNSPECIFIED
,
1035 -1 /* unspecified */
1038 static void finalize_deferred_config(struct wt_status
*s
)
1040 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1041 !s
->null_termination
);
1043 if (s
->null_termination
) {
1044 if (status_format
== STATUS_FORMAT_NONE
||
1045 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1046 status_format
= STATUS_FORMAT_PORCELAIN
;
1047 else if (status_format
== STATUS_FORMAT_LONG
)
1048 die(_("--long and -z are incompatible"));
1051 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1052 status_format
= status_deferred_config
.status_format
;
1053 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1054 status_format
= STATUS_FORMAT_NONE
;
1056 if (use_deferred_config
&& s
->show_branch
< 0)
1057 s
->show_branch
= status_deferred_config
.show_branch
;
1058 if (s
->show_branch
< 0)
1062 static int parse_and_validate_options(int argc
, const char *argv
[],
1063 const struct option
*options
,
1064 const char * const usage
[],
1066 struct commit
*current_head
,
1067 struct wt_status
*s
)
1071 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1072 finalize_deferred_config(s
);
1074 if (force_author
&& !strchr(force_author
, '>'))
1075 force_author
= find_author_by_nickname(force_author
);
1077 if (force_author
&& renew_authorship
)
1078 die(_("Using both --reset-author and --author does not make sense"));
1080 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1083 use_editor
= edit_flag
;
1085 setenv("GIT_EDITOR", ":", 1);
1087 /* Sanity check options */
1088 if (amend
&& !current_head
)
1089 die(_("You have nothing to amend."));
1090 if (amend
&& whence
!= FROM_COMMIT
) {
1091 if (whence
== FROM_MERGE
)
1092 die(_("You are in the middle of a merge -- cannot amend."));
1093 else if (whence
== FROM_CHERRY_PICK
)
1094 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1096 if (fixup_message
&& squash_message
)
1097 die(_("Options --squash and --fixup cannot be used together"));
1107 die(_("Only one of -c/-C/-F/--fixup can be used."));
1108 if (message
.len
&& f
> 0)
1109 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1110 if (f
|| message
.len
)
1111 template_file
= NULL
;
1113 use_message
= edit_message
;
1114 if (amend
&& !use_message
&& !fixup_message
)
1115 use_message
= "HEAD";
1116 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1117 die(_("--reset-author can be used only with -C, -c or --amend."));
1119 use_message_buffer
= read_commit_message(use_message
);
1120 if (!renew_authorship
) {
1121 author_message
= use_message
;
1122 author_message_buffer
= use_message_buffer
;
1125 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1126 author_message
= "CHERRY_PICK_HEAD";
1127 author_message_buffer
= read_commit_message(author_message
);
1130 if (patch_interactive
)
1133 if (also
+ only
+ all
+ interactive
> 1)
1134 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1135 if (argc
== 0 && (also
|| (only
&& !amend
)))
1136 die(_("No paths with --include/--only does not make sense."));
1137 if (argc
== 0 && only
&& amend
)
1138 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1139 if (argc
> 0 && !also
&& !only
)
1140 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1141 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1142 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1143 else if (!strcmp(cleanup_arg
, "verbatim"))
1144 cleanup_mode
= CLEANUP_NONE
;
1145 else if (!strcmp(cleanup_arg
, "whitespace"))
1146 cleanup_mode
= CLEANUP_SPACE
;
1147 else if (!strcmp(cleanup_arg
, "strip"))
1148 cleanup_mode
= CLEANUP_ALL
;
1150 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1152 handle_untracked_files_arg(s
);
1154 if (all
&& argc
> 0)
1155 die(_("Paths with -a does not make sense."));
1157 if (status_format
!= STATUS_FORMAT_NONE
)
1163 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1164 const struct commit
*current_head
, struct wt_status
*s
)
1167 const char *index_file
;
1169 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1170 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1171 rollback_index_files();
1173 return commitable
? 0 : 1;
1176 static int parse_status_slot(const char *var
, int offset
)
1178 if (!strcasecmp(var
+offset
, "header"))
1179 return WT_STATUS_HEADER
;
1180 if (!strcasecmp(var
+offset
, "branch"))
1181 return WT_STATUS_ONBRANCH
;
1182 if (!strcasecmp(var
+offset
, "updated")
1183 || !strcasecmp(var
+offset
, "added"))
1184 return WT_STATUS_UPDATED
;
1185 if (!strcasecmp(var
+offset
, "changed"))
1186 return WT_STATUS_CHANGED
;
1187 if (!strcasecmp(var
+offset
, "untracked"))
1188 return WT_STATUS_UNTRACKED
;
1189 if (!strcasecmp(var
+offset
, "nobranch"))
1190 return WT_STATUS_NOBRANCH
;
1191 if (!strcasecmp(var
+offset
, "unmerged"))
1192 return WT_STATUS_UNMERGED
;
1196 static int git_status_config(const char *k
, const char *v
, void *cb
)
1198 struct wt_status
*s
= cb
;
1200 if (starts_with(k
, "column."))
1201 return git_column_config(k
, v
, "status", &s
->colopts
);
1202 if (!strcmp(k
, "status.submodulesummary")) {
1204 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1205 if (is_bool
&& s
->submodule_summary
)
1206 s
->submodule_summary
= -1;
1209 if (!strcmp(k
, "status.short")) {
1210 if (git_config_bool(k
, v
))
1211 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1213 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1216 if (!strcmp(k
, "status.branch")) {
1217 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1220 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1221 s
->use_color
= git_config_colorbool(k
, v
);
1224 if (!strcmp(k
, "status.displaycommentprefix")) {
1225 s
->display_comment_prefix
= git_config_bool(k
, v
);
1228 if (starts_with(k
, "status.color.") || starts_with(k
, "color.status.")) {
1229 int slot
= parse_status_slot(k
, 13);
1233 return config_error_nonbool(k
);
1234 color_parse(v
, k
, s
->color_palette
[slot
]);
1237 if (!strcmp(k
, "status.relativepaths")) {
1238 s
->relative_paths
= git_config_bool(k
, v
);
1241 if (!strcmp(k
, "status.showuntrackedfiles")) {
1243 return config_error_nonbool(k
);
1244 else if (!strcmp(v
, "no"))
1245 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1246 else if (!strcmp(v
, "normal"))
1247 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1248 else if (!strcmp(v
, "all"))
1249 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1251 return error(_("Invalid untracked files mode '%s'"), v
);
1254 return git_diff_ui_config(k
, v
, NULL
);
1257 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1259 static struct wt_status s
;
1261 unsigned char sha1
[20];
1262 static struct option builtin_status_options
[] = {
1263 OPT__VERBOSE(&verbose
, N_("be verbose")),
1264 OPT_SET_INT('s', "short", &status_format
,
1265 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1266 OPT_BOOL('b', "branch", &s
.show_branch
,
1267 N_("show branch information")),
1268 OPT_SET_INT(0, "porcelain", &status_format
,
1269 N_("machine-readable output"),
1270 STATUS_FORMAT_PORCELAIN
),
1271 OPT_SET_INT(0, "long", &status_format
,
1272 N_("show status in long format (default)"),
1273 STATUS_FORMAT_LONG
),
1274 OPT_BOOL('z', "null", &s
.null_termination
,
1275 N_("terminate entries with NUL")),
1276 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1278 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1279 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1280 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1281 N_("show ignored files")),
1282 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1283 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1284 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1285 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1289 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1290 usage_with_options(builtin_status_usage
, builtin_status_options
);
1292 status_init_config(&s
, git_status_config
);
1293 argc
= parse_options(argc
, argv
, prefix
,
1294 builtin_status_options
,
1295 builtin_status_usage
, 0);
1296 finalize_colopts(&s
.colopts
, -1);
1297 finalize_deferred_config(&s
);
1299 handle_untracked_files_arg(&s
);
1300 if (show_ignored_in_status
)
1301 s
.show_ignored_files
= 1;
1302 parse_pathspec(&s
.pathspec
, 0,
1303 PATHSPEC_PREFER_FULL
,
1306 read_cache_preload(&s
.pathspec
);
1307 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1309 fd
= hold_locked_index(&index_lock
, 0);
1311 update_index_if_able(&the_index
, &index_lock
);
1313 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1314 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1315 wt_status_collect(&s
);
1317 if (s
.relative_paths
)
1320 switch (status_format
) {
1321 case STATUS_FORMAT_SHORT
:
1322 wt_shortstatus_print(&s
);
1324 case STATUS_FORMAT_PORCELAIN
:
1325 wt_porcelain_print(&s
);
1327 case STATUS_FORMAT_UNSPECIFIED
:
1328 die("BUG: finalize_deferred_config() should have been called");
1330 case STATUS_FORMAT_NONE
:
1331 case STATUS_FORMAT_LONG
:
1332 s
.verbose
= verbose
;
1333 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1334 wt_status_print(&s
);
1340 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1343 struct rev_info rev
;
1344 struct commit
*commit
;
1345 struct strbuf format
= STRBUF_INIT
;
1346 unsigned char junk_sha1
[20];
1348 struct pretty_print_context pctx
= {0};
1349 struct strbuf author_ident
= STRBUF_INIT
;
1350 struct strbuf committer_ident
= STRBUF_INIT
;
1352 commit
= lookup_commit(sha1
);
1354 die(_("couldn't look up newly created commit"));
1355 if (parse_commit(commit
))
1356 die(_("could not parse newly created commit"));
1358 strbuf_addstr(&format
, "format:%h] %s");
1360 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1361 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1362 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1363 strbuf_addstr(&format
, "\n Author: ");
1364 strbuf_addbuf_percentquote(&format
, &author_ident
);
1366 if (!committer_ident_sufficiently_given()) {
1367 strbuf_addstr(&format
, "\n Committer: ");
1368 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1369 if (advice_implicit_identity
) {
1370 strbuf_addch(&format
, '\n');
1371 strbuf_addstr(&format
, _(implicit_ident_advice
));
1374 strbuf_release(&author_ident
);
1375 strbuf_release(&committer_ident
);
1377 init_revisions(&rev
, prefix
);
1378 setup_revisions(0, NULL
, &rev
, NULL
);
1381 rev
.diffopt
.output_format
=
1382 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1384 rev
.verbose_header
= 1;
1385 rev
.show_root_diff
= 1;
1386 get_commit_format(format
.buf
, &rev
);
1387 rev
.always_show_header
= 0;
1388 rev
.diffopt
.detect_rename
= 1;
1389 rev
.diffopt
.break_opt
= 0;
1390 diff_setup_done(&rev
.diffopt
);
1392 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1394 starts_with(head
, "refs/heads/") ?
1396 !strcmp(head
, "HEAD") ?
1397 _("detached HEAD") :
1399 initial_commit
? _(" (root-commit)") : "");
1401 if (!log_tree_commit(&rev
, commit
)) {
1402 rev
.always_show_header
= 1;
1403 rev
.use_terminator
= 1;
1404 log_tree_commit(&rev
, commit
);
1407 strbuf_release(&format
);
1410 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1412 struct wt_status
*s
= cb
;
1415 if (!strcmp(k
, "commit.template"))
1416 return git_config_pathname(&template_file
, k
, v
);
1417 if (!strcmp(k
, "commit.status")) {
1418 include_status
= git_config_bool(k
, v
);
1421 if (!strcmp(k
, "commit.cleanup"))
1422 return git_config_string(&cleanup_arg
, k
, v
);
1424 status
= git_gpg_config(k
, v
, NULL
);
1427 return git_status_config(k
, v
, s
);
1430 static int run_rewrite_hook(const unsigned char *oldsha1
,
1431 const unsigned char *newsha1
)
1433 /* oldsha1 SP newsha1 LF NUL */
1434 static char buf
[2*40 + 3];
1435 struct child_process proc
;
1436 const char *argv
[3];
1440 argv
[0] = find_hook("post-rewrite");
1447 memset(&proc
, 0, sizeof(proc
));
1450 proc
.stdout_to_stderr
= 1;
1452 code
= start_command(&proc
);
1455 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1456 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1457 write_in_full(proc
.in
, buf
, n
);
1459 return finish_command(&proc
);
1462 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1464 static struct wt_status s
;
1465 static struct option builtin_commit_options
[] = {
1466 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1467 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1469 OPT_GROUP(N_("Commit message options")),
1470 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1471 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1472 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1473 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1474 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1475 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1476 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1477 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1478 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1479 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1480 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1481 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1482 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1483 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1484 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key id"),
1485 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1486 /* end commit message options */
1488 OPT_GROUP(N_("Commit contents options")),
1489 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1490 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1491 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1492 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1493 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1494 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1495 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1496 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1497 STATUS_FORMAT_SHORT
),
1498 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1499 OPT_SET_INT(0, "porcelain", &status_format
,
1500 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1501 OPT_SET_INT(0, "long", &status_format
,
1502 N_("show status in long format (default)"),
1503 STATUS_FORMAT_LONG
),
1504 OPT_BOOL('z', "null", &s
.null_termination
,
1505 N_("terminate entries with NUL")),
1506 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1507 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1508 { 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" },
1509 /* end commit contents options */
1511 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1512 N_("ok to record an empty change")),
1513 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1514 N_("ok to record a change with an empty message")),
1519 struct strbuf sb
= STRBUF_INIT
;
1520 struct strbuf author_ident
= STRBUF_INIT
;
1521 const char *index_file
, *reflog_msg
;
1523 unsigned char sha1
[20];
1524 struct ref_lock
*ref_lock
;
1525 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1526 struct stat statbuf
;
1527 int allow_fast_forward
= 1;
1528 struct commit
*current_head
= NULL
;
1529 struct commit_extra_header
*extra
= NULL
;
1531 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1532 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1534 status_init_config(&s
, git_commit_config
);
1535 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1538 if (get_sha1("HEAD", sha1
))
1539 current_head
= NULL
;
1541 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1542 if (parse_commit(current_head
))
1543 die(_("could not parse HEAD commit"));
1545 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1546 builtin_commit_usage
,
1547 prefix
, current_head
, &s
);
1549 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1550 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1552 /* Set up everything for writing the commit object. This includes
1553 running hooks, writing the trees, and interacting with the user. */
1554 if (!prepare_to_commit(index_file
, prefix
,
1555 current_head
, &s
, &author_ident
)) {
1556 rollback_index_files();
1560 /* Determine parents */
1561 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1562 if (!current_head
) {
1564 reflog_msg
= "commit (initial)";
1566 struct commit_list
*c
;
1569 reflog_msg
= "commit (amend)";
1570 for (c
= current_head
->parents
; c
; c
= c
->next
)
1571 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1572 } else if (whence
== FROM_MERGE
) {
1573 struct strbuf m
= STRBUF_INIT
;
1577 reflog_msg
= "commit (merge)";
1578 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1579 fp
= fopen(git_path("MERGE_HEAD"), "r");
1581 die_errno(_("could not open '%s' for reading"),
1582 git_path("MERGE_HEAD"));
1583 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1584 struct commit
*parent
;
1586 parent
= get_merge_parent(m
.buf
);
1588 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1589 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1593 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1594 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1595 die_errno(_("could not read MERGE_MODE"));
1596 if (!strcmp(sb
.buf
, "no-ff"))
1597 allow_fast_forward
= 0;
1599 if (allow_fast_forward
)
1600 parents
= reduce_heads(parents
);
1603 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1604 ? "commit (cherry-pick)"
1606 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1609 /* Finally, get the commit message */
1611 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1612 int saved_errno
= errno
;
1613 rollback_index_files();
1614 die(_("could not read commit message: %s"), strerror(saved_errno
));
1617 /* Truncate the message just before the diff, if any. */
1619 wt_status_truncate_message_at_cut_line(&sb
);
1621 if (cleanup_mode
!= CLEANUP_NONE
)
1622 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1623 if (template_untouched(&sb
) && !allow_empty_message
) {
1624 rollback_index_files();
1625 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1628 if (message_is_empty(&sb
) && !allow_empty_message
) {
1629 rollback_index_files();
1630 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1635 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1636 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1638 struct commit_extra_header
**tail
= &extra
;
1639 append_merge_tag_headers(parents
, &tail
);
1642 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1643 author_ident
.buf
, sign_commit
, extra
)) {
1644 rollback_index_files();
1645 die(_("failed to write commit object"));
1647 strbuf_release(&author_ident
);
1648 free_commit_extra_headers(extra
);
1650 ref_lock
= lock_any_ref_for_update("HEAD",
1653 : current_head
->object
.sha1
,
1656 nl
= strchr(sb
.buf
, '\n');
1658 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1660 strbuf_addch(&sb
, '\n');
1661 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1662 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1665 rollback_index_files();
1666 die(_("cannot lock HEAD ref"));
1668 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1669 rollback_index_files();
1670 die(_("cannot update HEAD ref"));
1673 unlink(git_path("CHERRY_PICK_HEAD"));
1674 unlink(git_path("REVERT_HEAD"));
1675 unlink(git_path("MERGE_HEAD"));
1676 unlink(git_path("MERGE_MSG"));
1677 unlink(git_path("MERGE_MODE"));
1678 unlink(git_path("SQUASH_MSG"));
1680 if (commit_index_files())
1681 die (_("Repository has been updated, but unable to write\n"
1682 "new_index file. Check that disk is not full or quota is\n"
1683 "not exceeded, and then \"git reset HEAD\" to recover."));
1686 run_hook(get_index_file(), "post-commit", NULL
);
1687 if (amend
&& !no_post_rewrite
) {
1688 struct notes_rewrite_cfg
*cfg
;
1689 cfg
= init_copy_notes_for_rewrite("amend");
1691 /* we are amending, so current_head is not NULL */
1692 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1693 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1695 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1698 print_summary(prefix
, sha1
, !current_head
);