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.
119 static const char *cleanup_arg
;
121 static enum commit_whence whence
;
122 static int sequencer_in_use
;
123 static int use_editor
= 1, include_status
= 1;
124 static int show_ignored_in_status
, have_option_m
;
125 static const char *only_include_assumed
;
126 static struct strbuf message
= STRBUF_INIT
;
128 static enum status_format
{
129 STATUS_FORMAT_NONE
= 0,
132 STATUS_FORMAT_PORCELAIN
,
134 STATUS_FORMAT_UNSPECIFIED
135 } status_format
= STATUS_FORMAT_UNSPECIFIED
;
137 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
139 struct strbuf
*buf
= opt
->value
;
142 strbuf_setlen(buf
, 0);
146 strbuf_addch(buf
, '\n');
147 strbuf_addstr(buf
, arg
);
148 strbuf_complete_line(buf
);
153 static void determine_whence(struct wt_status
*s
)
155 if (file_exists(git_path("MERGE_HEAD")))
157 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
158 whence
= FROM_CHERRY_PICK
;
159 if (file_exists(git_path("sequencer")))
160 sequencer_in_use
= 1;
163 whence
= FROM_COMMIT
;
168 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
170 wt_status_prepare(s
);
174 s
->hints
= advice_status_hints
; /* must come after git_config() */
177 static void rollback_index_files(void)
179 switch (commit_style
) {
181 break; /* nothing to do */
183 rollback_lock_file(&index_lock
);
186 rollback_lock_file(&index_lock
);
187 rollback_lock_file(&false_lock
);
192 static int commit_index_files(void)
196 switch (commit_style
) {
198 break; /* nothing to do */
200 err
= commit_lock_file(&index_lock
);
203 err
= commit_lock_file(&index_lock
);
204 rollback_lock_file(&false_lock
);
212 * Take a union of paths in the index and the named tree (typically, "HEAD"),
213 * and return the paths that match the given pattern in list.
215 static int list_paths(struct string_list
*list
, const char *with_tree
,
216 const char *prefix
, const struct pathspec
*pattern
)
224 m
= xcalloc(1, pattern
->nr
);
227 char *max_prefix
= common_prefix(pattern
);
228 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
232 for (i
= 0; i
< active_nr
; i
++) {
233 const struct cache_entry
*ce
= active_cache
[i
];
234 struct string_list_item
*item
;
236 if (ce
->ce_flags
& CE_UPDATE
)
238 if (!ce_path_match(ce
, pattern
, m
))
240 item
= string_list_insert(list
, ce
->name
);
241 if (ce_skip_worktree(ce
))
242 item
->util
= item
; /* better a valid pointer than a fake one */
245 return report_path_error(m
, pattern
, prefix
);
248 static void add_remove_files(struct string_list
*list
)
251 for (i
= 0; i
< list
->nr
; i
++) {
253 struct string_list_item
*p
= &(list
->items
[i
]);
255 /* p->util is skip-worktree */
259 if (!lstat(p
->string
, &st
)) {
260 if (add_to_cache(p
->string
, &st
, 0))
261 die(_("updating files failed"));
263 remove_file_from_cache(p
->string
);
267 static void create_base_index(const struct commit
*current_head
)
270 struct unpack_trees_options opts
;
278 memset(&opts
, 0, sizeof(opts
));
282 opts
.src_index
= &the_index
;
283 opts
.dst_index
= &the_index
;
285 opts
.fn
= oneway_merge
;
286 tree
= parse_tree_indirect(current_head
->object
.sha1
);
288 die(_("failed to unpack HEAD tree object"));
290 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
291 if (unpack_trees(1, &t
, &opts
))
292 exit(128); /* We've already reported the error, finish dying */
295 static void refresh_cache_or_die(int refresh_flags
)
298 * refresh_flags contains REFRESH_QUIET, so the only errors
299 * are for unmerged entries.
301 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
302 die_resolve_conflict("commit");
305 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
306 const struct commit
*current_head
, int is_status
)
309 struct string_list partial
;
310 struct pathspec pathspec
;
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 char *old_index_env
= NULL
;
324 fd
= hold_locked_index(&index_lock
, 1);
326 refresh_cache_or_die(refresh_flags
);
328 if (write_cache(fd
, active_cache
, active_nr
) ||
329 close_lock_file(&index_lock
))
330 die(_("unable to create temporary index"));
332 old_index_env
= getenv(INDEX_ENVIRONMENT
);
333 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
335 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
336 die(_("interactive add failed"));
338 if (old_index_env
&& *old_index_env
)
339 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
341 unsetenv(INDEX_ENVIRONMENT
);
344 read_cache_from(index_lock
.filename
);
346 commit_style
= COMMIT_NORMAL
;
347 return index_lock
.filename
;
351 * Non partial, non as-is commit.
353 * (1) get the real index;
354 * (2) update the_index as necessary;
355 * (3) write the_index out to the real index (still locked);
356 * (4) return the name of the locked index file.
358 * The caller should run hooks on the locked real index, and
359 * (A) if all goes well, commit the real index;
360 * (B) on failure, rollback the real index.
362 if (all
|| (also
&& pathspec
.nr
)) {
363 fd
= hold_locked_index(&index_lock
, 1);
364 add_files_to_cache(also
? prefix
: NULL
, &pathspec
, 0);
365 refresh_cache_or_die(refresh_flags
);
366 update_main_cache_tree(WRITE_TREE_SILENT
);
367 if (write_cache(fd
, active_cache
, active_nr
) ||
368 close_lock_file(&index_lock
))
369 die(_("unable to write new_index file"));
370 commit_style
= COMMIT_NORMAL
;
371 return index_lock
.filename
;
377 * (1) return the name of the real index file.
379 * The caller should run hooks on the real index,
380 * and create commit from the_index.
381 * We still need to refresh the index here.
383 if (!only
&& !pathspec
.nr
) {
384 fd
= hold_locked_index(&index_lock
, 1);
385 refresh_cache_or_die(refresh_flags
);
386 if (active_cache_changed
) {
387 update_main_cache_tree(WRITE_TREE_SILENT
);
388 if (write_cache(fd
, active_cache
, active_nr
) ||
389 commit_locked_index(&index_lock
))
390 die(_("unable to write new_index file"));
392 rollback_lock_file(&index_lock
);
394 commit_style
= COMMIT_AS_IS
;
395 return get_index_file();
401 * (0) find the set of affected paths;
402 * (1) get lock on the real index file;
403 * (2) update the_index with the given paths;
404 * (3) write the_index out to the real index (still locked);
405 * (4) get lock on the false index file;
406 * (5) reset the_index from HEAD;
407 * (6) update the_index the same way as (2);
408 * (7) write the_index out to the false index file;
409 * (8) return the name of the false index file (still locked);
411 * The caller should run hooks on the locked false index, and
412 * create commit from it. Then
413 * (A) if all goes well, commit the real index;
414 * (B) on failure, rollback the real index;
415 * In either case, rollback the false index.
417 commit_style
= COMMIT_PARTIAL
;
419 if (whence
!= FROM_COMMIT
) {
420 if (whence
== FROM_MERGE
)
421 die(_("cannot do a partial commit during a merge."));
422 else if (whence
== FROM_CHERRY_PICK
)
423 die(_("cannot do a partial commit during a cherry-pick."));
426 memset(&partial
, 0, sizeof(partial
));
427 partial
.strdup_strings
= 1;
428 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, &pathspec
))
432 if (read_cache() < 0)
433 die(_("cannot read the index"));
435 fd
= hold_locked_index(&index_lock
, 1);
436 add_remove_files(&partial
);
437 refresh_cache(REFRESH_QUIET
);
438 if (write_cache(fd
, active_cache
, active_nr
) ||
439 close_lock_file(&index_lock
))
440 die(_("unable to write new_index file"));
442 fd
= hold_lock_file_for_update(&false_lock
,
443 git_path("next-index-%"PRIuMAX
,
444 (uintmax_t) getpid()),
447 create_base_index(current_head
);
448 add_remove_files(&partial
);
449 refresh_cache(REFRESH_QUIET
);
451 if (write_cache(fd
, active_cache
, active_nr
) ||
452 close_lock_file(&false_lock
))
453 die(_("unable to write temporary index file"));
456 read_cache_from(false_lock
.filename
);
458 return false_lock
.filename
;
461 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
464 unsigned char sha1
[20];
466 if (s
->relative_paths
)
471 s
->reference
= "HEAD^1";
473 s
->verbose
= verbose
;
474 s
->index_file
= index_file
;
477 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
479 wt_status_collect(s
);
481 switch (status_format
) {
482 case STATUS_FORMAT_SHORT
:
483 wt_shortstatus_print(s
);
485 case STATUS_FORMAT_PORCELAIN
:
486 wt_porcelain_print(s
);
488 case STATUS_FORMAT_UNSPECIFIED
:
489 die("BUG: finalize_deferred_config() should have been called");
491 case STATUS_FORMAT_NONE
:
492 case STATUS_FORMAT_LONG
:
497 return s
->commitable
;
500 static int is_a_merge(const struct commit
*current_head
)
502 return !!(current_head
->parents
&& current_head
->parents
->next
);
505 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
507 struct strbuf buf
= STRBUF_INIT
;
509 strbuf_addch(&buf
, hack
);
510 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
511 setenv(var
, buf
.buf
, 1);
512 strbuf_release(&buf
);
515 static int sane_ident_split(struct ident_split
*person
)
517 if (!person
->name_begin
|| !person
->name_end
||
518 person
->name_begin
== person
->name_end
)
519 return 0; /* no human readable name */
520 if (!person
->mail_begin
|| !person
->mail_end
||
521 person
->mail_begin
== person
->mail_end
)
522 return 0; /* no usable mail */
523 if (!person
->date_begin
|| !person
->date_end
||
524 !person
->tz_begin
|| !person
->tz_end
)
529 static void determine_author_info(struct strbuf
*author_ident
)
531 char *name
, *email
, *date
;
532 struct ident_split author
;
534 name
= getenv("GIT_AUTHOR_NAME");
535 email
= getenv("GIT_AUTHOR_EMAIL");
536 date
= getenv("GIT_AUTHOR_DATE");
538 if (author_message
) {
539 const char *a
, *lb
, *rb
, *eol
;
542 a
= strstr(author_message_buffer
, "\nauthor ");
544 die(_("invalid commit: %s"), author_message
);
546 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
547 rb
= strchrnul(lb
, '>');
548 eol
= strchrnul(rb
, '\n');
549 if (!*lb
|| !*rb
|| !*eol
)
550 die(_("invalid commit: %s"), author_message
);
552 if (lb
== a
+ strlen("\nauthor "))
553 /* \nauthor <foo@example.com> */
554 name
= xcalloc(1, 1);
556 name
= xmemdupz(a
+ strlen("\nauthor "),
558 (a
+ strlen("\nauthor "))));
559 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
560 len
= eol
- (rb
+ strlen("> "));
561 date
= xmalloc(len
+ 2);
563 memcpy(date
+ 1, rb
+ strlen("> "), len
);
564 date
[len
+ 1] = '\0';
568 const char *lb
= strstr(force_author
, " <");
569 const char *rb
= strchr(force_author
, '>');
572 die(_("malformed --author parameter"));
573 name
= xstrndup(force_author
, lb
- force_author
);
574 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
579 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
580 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
581 sane_ident_split(&author
)) {
582 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
583 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
584 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
588 static char *cut_ident_timestamp_part(char *string
)
590 char *ket
= strrchr(string
, '>');
591 if (!ket
|| ket
[1] != ' ')
592 die(_("Malformed ident string: '%s'"), string
);
597 static void adjust_comment_line_char(const struct strbuf
*sb
)
599 char candidates
[] = "#;@!$%^&|:";
603 comment_line_char
= candidates
[0];
604 if (!memchr(sb
->buf
, comment_line_char
, sb
->len
))
608 candidate
= strchr(candidates
, *p
);
611 for (p
= sb
->buf
; *p
; p
++) {
612 if ((p
[0] == '\n' || p
[0] == '\r') && p
[1]) {
613 candidate
= strchr(candidates
, p
[1]);
619 for (p
= candidates
; *p
== ' '; p
++)
622 die(_("unable to select a comment character that is not used\n"
623 "in the current commit message"));
624 comment_line_char
= *p
;
627 static int prepare_to_commit(const char *index_file
, const char *prefix
,
628 struct commit
*current_head
,
630 struct strbuf
*author_ident
)
633 struct strbuf committer_ident
= STRBUF_INIT
;
635 struct strbuf sb
= STRBUF_INIT
;
636 const char *hook_arg1
= NULL
;
637 const char *hook_arg2
= NULL
;
638 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
639 int old_display_comment_prefix
;
641 /* This checks and barfs if author is badly specified */
642 determine_author_info(author_ident
);
644 if (!no_verify
&& run_commit_hook(use_editor
, index_file
, "pre-commit", NULL
))
647 if (squash_message
) {
649 * Insert the proper subject line before other commit
650 * message options add their content.
652 if (use_message
&& !strcmp(use_message
, squash_message
))
653 strbuf_addstr(&sb
, "squash! ");
655 struct pretty_print_context ctx
= {0};
657 c
= lookup_commit_reference_by_name(squash_message
);
659 die(_("could not lookup commit %s"), squash_message
);
660 ctx
.output_encoding
= get_commit_output_encoding();
661 format_commit_message(c
, "squash! %s\n\n", &sb
,
667 strbuf_addbuf(&sb
, &message
);
668 hook_arg1
= "message";
669 } else if (logfile
&& !strcmp(logfile
, "-")) {
671 fprintf(stderr
, _("(reading log message from standard input)\n"));
672 if (strbuf_read(&sb
, 0, 0) < 0)
673 die_errno(_("could not read log from standard input"));
674 hook_arg1
= "message";
675 } else if (logfile
) {
676 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
677 die_errno(_("could not read log file '%s'"),
679 hook_arg1
= "message";
680 } else if (use_message
) {
682 buffer
= strstr(use_message_buffer
, "\n\n");
683 if (!use_editor
&& (!buffer
|| buffer
[2] == '\0'))
684 die(_("commit has empty message"));
685 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
686 hook_arg1
= "commit";
687 hook_arg2
= use_message
;
688 } else if (fixup_message
) {
689 struct pretty_print_context ctx
= {0};
690 struct commit
*commit
;
691 commit
= lookup_commit_reference_by_name(fixup_message
);
693 die(_("could not lookup commit %s"), fixup_message
);
694 ctx
.output_encoding
= get_commit_output_encoding();
695 format_commit_message(commit
, "fixup! %s\n\n",
697 hook_arg1
= "message";
698 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
699 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
700 die_errno(_("could not read MERGE_MSG"));
702 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
703 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
704 die_errno(_("could not read SQUASH_MSG"));
705 hook_arg1
= "squash";
706 } else if (template_file
) {
707 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
708 die_errno(_("could not read '%s'"), template_file
);
709 hook_arg1
= "template";
710 clean_message_contents
= 0;
714 * The remaining cases don't modify the template message, but
715 * just set the argument(s) to the prepare-commit-msg hook.
717 else if (whence
== FROM_MERGE
)
719 else if (whence
== FROM_CHERRY_PICK
) {
720 hook_arg1
= "commit";
721 hook_arg2
= "CHERRY_PICK_HEAD";
724 if (squash_message
) {
726 * If squash_commit was used for the commit subject,
727 * then we're possibly hijacking other commit log options.
728 * Reset the hook args to tell the real story.
730 hook_arg1
= "message";
734 s
->fp
= fopen(git_path(commit_editmsg
), "w");
736 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
738 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
739 old_display_comment_prefix
= s
->display_comment_prefix
;
740 s
->display_comment_prefix
= 1;
743 * Most hints are counter-productive when the commit has
748 if (clean_message_contents
)
753 * See if we have a Conflicts: block at the end. If yes, count
754 * its size, so we can ignore it.
756 int ignore_footer
= 0;
757 int i
, eol
, previous
= 0;
760 for (i
= 0; i
< sb
.len
; i
++) {
761 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
766 if (starts_with(sb
.buf
+ previous
, "\nConflicts:\n")) {
767 ignore_footer
= sb
.len
- previous
;
775 append_signoff(&sb
, ignore_footer
, 0);
778 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
779 die_errno(_("could not write commit template"));
781 if (auto_comment_line_char
)
782 adjust_comment_line_char(&sb
);
785 /* This checks if committer ident is explicitly given */
786 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
787 if (use_editor
&& include_status
) {
789 int saved_color_setting
;
790 char *ai_tmp
, *ci_tmp
;
791 if (whence
!= FROM_COMMIT
) {
792 if (cleanup_mode
== CLEANUP_SCISSORS
)
793 wt_status_add_cut_line(s
->fp
);
794 status_printf_ln(s
, GIT_COLOR_NORMAL
,
797 "It looks like you may be committing a merge.\n"
798 "If this is not correct, please remove the file\n"
802 "It looks like you may be committing a cherry-pick.\n"
803 "If this is not correct, please remove the file\n"
806 git_path(whence
== FROM_MERGE
808 : "CHERRY_PICK_HEAD"));
811 fprintf(s
->fp
, "\n");
812 if (cleanup_mode
== CLEANUP_ALL
)
813 status_printf(s
, GIT_COLOR_NORMAL
,
814 _("Please enter the commit message for your changes."
815 " Lines starting\nwith '%c' will be ignored, and an empty"
816 " message aborts the commit.\n"), comment_line_char
);
817 else if (cleanup_mode
== CLEANUP_SCISSORS
&& whence
== FROM_COMMIT
)
818 wt_status_add_cut_line(s
->fp
);
819 else /* CLEANUP_SPACE, that is. */
820 status_printf(s
, GIT_COLOR_NORMAL
,
821 _("Please enter the commit message for your changes."
823 "with '%c' will be kept; you may remove them"
824 " yourself if you want to.\n"
825 "An empty message aborts the commit.\n"), comment_line_char
);
826 if (only_include_assumed
)
827 status_printf_ln(s
, GIT_COLOR_NORMAL
,
828 "%s", only_include_assumed
);
830 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
831 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
832 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
833 status_printf_ln(s
, GIT_COLOR_NORMAL
,
836 ident_shown
++ ? "" : "\n",
839 if (!committer_ident_sufficiently_given())
840 status_printf_ln(s
, GIT_COLOR_NORMAL
,
843 ident_shown
++ ? "" : "\n",
844 committer_ident
.buf
);
847 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
849 saved_color_setting
= s
->use_color
;
851 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
852 s
->use_color
= saved_color_setting
;
857 unsigned char sha1
[20];
858 const char *parent
= "HEAD";
860 if (!active_nr
&& read_cache() < 0)
861 die(_("Cannot read index"));
866 if (get_sha1(parent
, sha1
))
867 commitable
= !!active_nr
;
869 commitable
= index_differs_from(parent
, 0);
871 strbuf_release(&committer_ident
);
876 * Reject an attempt to record a non-merge empty commit without
877 * explicit --allow-empty. In the cherry-pick case, it may be
878 * empty due to conflict resolution, which the user should okay.
880 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
881 !(amend
&& is_a_merge(current_head
))) {
882 s
->display_comment_prefix
= old_display_comment_prefix
;
883 run_status(stdout
, index_file
, prefix
, 0, s
);
885 fputs(_(empty_amend_advice
), stderr
);
886 else if (whence
== FROM_CHERRY_PICK
) {
887 fputs(_(empty_cherry_pick_advice
), stderr
);
888 if (!sequencer_in_use
)
889 fputs(_(empty_cherry_pick_advice_single
), stderr
);
891 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
897 * Re-read the index as pre-commit hook could have updated it,
898 * and write it out as a tree. We must do this before we invoke
899 * the editor and after we invoke run_status above.
902 read_cache_from(index_file
);
903 if (update_main_cache_tree(0)) {
904 error(_("Error building trees"));
908 if (run_commit_hook(use_editor
, index_file
, "prepare-commit-msg",
909 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
913 char index
[PATH_MAX
];
914 const char *env
[2] = { NULL
};
916 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
917 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
919 _("Please supply the message using either -m or -F option.\n"));
925 run_commit_hook(use_editor
, index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
932 static int rest_is_empty(struct strbuf
*sb
, int start
)
937 /* Check if the rest is just whitespace and Signed-of-by's. */
938 for (i
= start
; i
< sb
->len
; i
++) {
939 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
945 if (strlen(sign_off_header
) <= eol
- i
&&
946 starts_with(sb
->buf
+ i
, sign_off_header
)) {
951 if (!isspace(sb
->buf
[i
++]))
959 * Find out if the message in the strbuf contains only whitespace and
960 * Signed-off-by lines.
962 static int message_is_empty(struct strbuf
*sb
)
964 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
966 return rest_is_empty(sb
, 0);
970 * See if the user edited the message in the editor or left what
971 * was in the template intact
973 static int template_untouched(struct strbuf
*sb
)
975 struct strbuf tmpl
= STRBUF_INIT
;
978 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
981 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
984 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
985 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
988 strbuf_release(&tmpl
);
989 return rest_is_empty(sb
, start
- sb
->buf
);
992 static const char *find_author_by_nickname(const char *name
)
994 struct rev_info revs
;
995 struct commit
*commit
;
996 struct strbuf buf
= STRBUF_INIT
;
997 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
1001 init_revisions(&revs
, NULL
);
1002 strbuf_addf(&buf
, "--author=%s", name
);
1007 setup_revisions(ac
, av
, &revs
, NULL
);
1008 revs
.mailmap
= &mailmap
;
1009 read_mailmap(revs
.mailmap
, NULL
);
1011 prepare_revision_walk(&revs
);
1012 commit
= get_revision(&revs
);
1014 struct pretty_print_context ctx
= {0};
1015 ctx
.date_mode
= DATE_NORMAL
;
1016 strbuf_release(&buf
);
1017 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
1018 clear_mailmap(&mailmap
);
1019 return strbuf_detach(&buf
, NULL
);
1021 die(_("No existing author found with '%s'"), name
);
1025 static void handle_untracked_files_arg(struct wt_status
*s
)
1027 if (!untracked_files_arg
)
1028 ; /* default already initialized */
1029 else if (!strcmp(untracked_files_arg
, "no"))
1030 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1031 else if (!strcmp(untracked_files_arg
, "normal"))
1032 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1033 else if (!strcmp(untracked_files_arg
, "all"))
1034 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1036 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1039 static const char *read_commit_message(const char *name
)
1041 const char *out_enc
;
1042 struct commit
*commit
;
1044 commit
= lookup_commit_reference_by_name(name
);
1046 die(_("could not lookup commit %s"), name
);
1047 out_enc
= get_commit_output_encoding();
1048 return logmsg_reencode(commit
, NULL
, out_enc
);
1052 * Enumerate what needs to be propagated when --porcelain
1053 * is not in effect here.
1055 static struct status_deferred_config
{
1056 enum status_format status_format
;
1058 } status_deferred_config
= {
1059 STATUS_FORMAT_UNSPECIFIED
,
1060 -1 /* unspecified */
1063 static void finalize_deferred_config(struct wt_status
*s
)
1065 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1066 !s
->null_termination
);
1068 if (s
->null_termination
) {
1069 if (status_format
== STATUS_FORMAT_NONE
||
1070 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1071 status_format
= STATUS_FORMAT_PORCELAIN
;
1072 else if (status_format
== STATUS_FORMAT_LONG
)
1073 die(_("--long and -z are incompatible"));
1076 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1077 status_format
= status_deferred_config
.status_format
;
1078 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1079 status_format
= STATUS_FORMAT_NONE
;
1081 if (use_deferred_config
&& s
->show_branch
< 0)
1082 s
->show_branch
= status_deferred_config
.show_branch
;
1083 if (s
->show_branch
< 0)
1087 static int parse_and_validate_options(int argc
, const char *argv
[],
1088 const struct option
*options
,
1089 const char * const usage
[],
1091 struct commit
*current_head
,
1092 struct wt_status
*s
)
1096 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1097 finalize_deferred_config(s
);
1099 if (force_author
&& !strchr(force_author
, '>'))
1100 force_author
= find_author_by_nickname(force_author
);
1102 if (force_author
&& renew_authorship
)
1103 die(_("Using both --reset-author and --author does not make sense"));
1105 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1108 use_editor
= edit_flag
;
1110 /* Sanity check options */
1111 if (amend
&& !current_head
)
1112 die(_("You have nothing to amend."));
1113 if (amend
&& whence
!= FROM_COMMIT
) {
1114 if (whence
== FROM_MERGE
)
1115 die(_("You are in the middle of a merge -- cannot amend."));
1116 else if (whence
== FROM_CHERRY_PICK
)
1117 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1119 if (fixup_message
&& squash_message
)
1120 die(_("Options --squash and --fixup cannot be used together"));
1130 die(_("Only one of -c/-C/-F/--fixup can be used."));
1131 if (message
.len
&& f
> 0)
1132 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1133 if (f
|| message
.len
)
1134 template_file
= NULL
;
1136 use_message
= edit_message
;
1137 if (amend
&& !use_message
&& !fixup_message
)
1138 use_message
= "HEAD";
1139 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1140 die(_("--reset-author can be used only with -C, -c or --amend."));
1142 use_message_buffer
= read_commit_message(use_message
);
1143 if (!renew_authorship
) {
1144 author_message
= use_message
;
1145 author_message_buffer
= use_message_buffer
;
1148 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1149 author_message
= "CHERRY_PICK_HEAD";
1150 author_message_buffer
= read_commit_message(author_message
);
1153 if (patch_interactive
)
1156 if (also
+ only
+ all
+ interactive
> 1)
1157 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1158 if (argc
== 0 && (also
|| (only
&& !amend
)))
1159 die(_("No paths with --include/--only does not make sense."));
1160 if (argc
== 0 && only
&& amend
)
1161 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1162 if (argc
> 0 && !also
&& !only
)
1163 only_include_assumed
= _("Explicit paths specified without -i or -o; assuming --only paths...");
1164 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1165 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1166 else if (!strcmp(cleanup_arg
, "verbatim"))
1167 cleanup_mode
= CLEANUP_NONE
;
1168 else if (!strcmp(cleanup_arg
, "whitespace"))
1169 cleanup_mode
= CLEANUP_SPACE
;
1170 else if (!strcmp(cleanup_arg
, "strip"))
1171 cleanup_mode
= CLEANUP_ALL
;
1172 else if (!strcmp(cleanup_arg
, "scissors"))
1173 cleanup_mode
= use_editor
? CLEANUP_SCISSORS
: CLEANUP_SPACE
;
1175 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1177 handle_untracked_files_arg(s
);
1179 if (all
&& argc
> 0)
1180 die(_("Paths with -a does not make sense."));
1182 if (status_format
!= STATUS_FORMAT_NONE
)
1188 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1189 const struct commit
*current_head
, struct wt_status
*s
)
1192 const char *index_file
;
1194 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1195 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1196 rollback_index_files();
1198 return commitable
? 0 : 1;
1201 static int parse_status_slot(const char *var
, int offset
)
1203 if (!strcasecmp(var
+offset
, "header"))
1204 return WT_STATUS_HEADER
;
1205 if (!strcasecmp(var
+offset
, "branch"))
1206 return WT_STATUS_ONBRANCH
;
1207 if (!strcasecmp(var
+offset
, "updated")
1208 || !strcasecmp(var
+offset
, "added"))
1209 return WT_STATUS_UPDATED
;
1210 if (!strcasecmp(var
+offset
, "changed"))
1211 return WT_STATUS_CHANGED
;
1212 if (!strcasecmp(var
+offset
, "untracked"))
1213 return WT_STATUS_UNTRACKED
;
1214 if (!strcasecmp(var
+offset
, "nobranch"))
1215 return WT_STATUS_NOBRANCH
;
1216 if (!strcasecmp(var
+offset
, "unmerged"))
1217 return WT_STATUS_UNMERGED
;
1221 static int git_status_config(const char *k
, const char *v
, void *cb
)
1223 struct wt_status
*s
= cb
;
1225 if (starts_with(k
, "column."))
1226 return git_column_config(k
, v
, "status", &s
->colopts
);
1227 if (!strcmp(k
, "status.submodulesummary")) {
1229 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1230 if (is_bool
&& s
->submodule_summary
)
1231 s
->submodule_summary
= -1;
1234 if (!strcmp(k
, "status.short")) {
1235 if (git_config_bool(k
, v
))
1236 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1238 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1241 if (!strcmp(k
, "status.branch")) {
1242 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1245 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1246 s
->use_color
= git_config_colorbool(k
, v
);
1249 if (!strcmp(k
, "status.displaycommentprefix")) {
1250 s
->display_comment_prefix
= git_config_bool(k
, v
);
1253 if (starts_with(k
, "status.color.") || starts_with(k
, "color.status.")) {
1254 int slot
= parse_status_slot(k
, 13);
1258 return config_error_nonbool(k
);
1259 color_parse(v
, k
, s
->color_palette
[slot
]);
1262 if (!strcmp(k
, "status.relativepaths")) {
1263 s
->relative_paths
= git_config_bool(k
, v
);
1266 if (!strcmp(k
, "status.showuntrackedfiles")) {
1268 return config_error_nonbool(k
);
1269 else if (!strcmp(v
, "no"))
1270 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1271 else if (!strcmp(v
, "normal"))
1272 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1273 else if (!strcmp(v
, "all"))
1274 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1276 return error(_("Invalid untracked files mode '%s'"), v
);
1279 return git_diff_ui_config(k
, v
, NULL
);
1282 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1284 static struct wt_status s
;
1286 unsigned char sha1
[20];
1287 static struct option builtin_status_options
[] = {
1288 OPT__VERBOSE(&verbose
, N_("be verbose")),
1289 OPT_SET_INT('s', "short", &status_format
,
1290 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1291 OPT_BOOL('b', "branch", &s
.show_branch
,
1292 N_("show branch information")),
1293 OPT_SET_INT(0, "porcelain", &status_format
,
1294 N_("machine-readable output"),
1295 STATUS_FORMAT_PORCELAIN
),
1296 OPT_SET_INT(0, "long", &status_format
,
1297 N_("show status in long format (default)"),
1298 STATUS_FORMAT_LONG
),
1299 OPT_BOOL('z', "null", &s
.null_termination
,
1300 N_("terminate entries with NUL")),
1301 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1303 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1304 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1305 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1306 N_("show ignored files")),
1307 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1308 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1309 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1310 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1314 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1315 usage_with_options(builtin_status_usage
, builtin_status_options
);
1317 status_init_config(&s
, git_status_config
);
1318 argc
= parse_options(argc
, argv
, prefix
,
1319 builtin_status_options
,
1320 builtin_status_usage
, 0);
1321 finalize_colopts(&s
.colopts
, -1);
1322 finalize_deferred_config(&s
);
1324 handle_untracked_files_arg(&s
);
1325 if (show_ignored_in_status
)
1326 s
.show_ignored_files
= 1;
1327 parse_pathspec(&s
.pathspec
, 0,
1328 PATHSPEC_PREFER_FULL
,
1331 read_cache_preload(&s
.pathspec
);
1332 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1334 fd
= hold_locked_index(&index_lock
, 0);
1336 update_index_if_able(&the_index
, &index_lock
);
1338 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1339 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1340 wt_status_collect(&s
);
1342 if (s
.relative_paths
)
1345 switch (status_format
) {
1346 case STATUS_FORMAT_SHORT
:
1347 wt_shortstatus_print(&s
);
1349 case STATUS_FORMAT_PORCELAIN
:
1350 wt_porcelain_print(&s
);
1352 case STATUS_FORMAT_UNSPECIFIED
:
1353 die("BUG: finalize_deferred_config() should have been called");
1355 case STATUS_FORMAT_NONE
:
1356 case STATUS_FORMAT_LONG
:
1357 s
.verbose
= verbose
;
1358 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1359 wt_status_print(&s
);
1365 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1368 struct rev_info rev
;
1369 struct commit
*commit
;
1370 struct strbuf format
= STRBUF_INIT
;
1371 unsigned char junk_sha1
[20];
1373 struct pretty_print_context pctx
= {0};
1374 struct strbuf author_ident
= STRBUF_INIT
;
1375 struct strbuf committer_ident
= STRBUF_INIT
;
1377 commit
= lookup_commit(sha1
);
1379 die(_("couldn't look up newly created commit"));
1380 if (parse_commit(commit
))
1381 die(_("could not parse newly created commit"));
1383 strbuf_addstr(&format
, "format:%h] %s");
1385 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1386 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1387 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1388 strbuf_addstr(&format
, "\n Author: ");
1389 strbuf_addbuf_percentquote(&format
, &author_ident
);
1391 if (!committer_ident_sufficiently_given()) {
1392 strbuf_addstr(&format
, "\n Committer: ");
1393 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1394 if (advice_implicit_identity
) {
1395 strbuf_addch(&format
, '\n');
1396 strbuf_addstr(&format
, _(implicit_ident_advice
));
1399 strbuf_release(&author_ident
);
1400 strbuf_release(&committer_ident
);
1402 init_revisions(&rev
, prefix
);
1403 setup_revisions(0, NULL
, &rev
, NULL
);
1406 rev
.diffopt
.output_format
=
1407 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1409 rev
.verbose_header
= 1;
1410 rev
.show_root_diff
= 1;
1411 get_commit_format(format
.buf
, &rev
);
1412 rev
.always_show_header
= 0;
1413 rev
.diffopt
.detect_rename
= 1;
1414 rev
.diffopt
.break_opt
= 0;
1415 diff_setup_done(&rev
.diffopt
);
1417 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1419 starts_with(head
, "refs/heads/") ?
1421 !strcmp(head
, "HEAD") ?
1422 _("detached HEAD") :
1424 initial_commit
? _(" (root-commit)") : "");
1426 if (!log_tree_commit(&rev
, commit
)) {
1427 rev
.always_show_header
= 1;
1428 rev
.use_terminator
= 1;
1429 log_tree_commit(&rev
, commit
);
1432 strbuf_release(&format
);
1435 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1437 struct wt_status
*s
= cb
;
1440 if (!strcmp(k
, "commit.template"))
1441 return git_config_pathname(&template_file
, k
, v
);
1442 if (!strcmp(k
, "commit.status")) {
1443 include_status
= git_config_bool(k
, v
);
1446 if (!strcmp(k
, "commit.cleanup"))
1447 return git_config_string(&cleanup_arg
, k
, v
);
1448 if (!strcmp(k
, "commit.gpgsign")) {
1449 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
1453 status
= git_gpg_config(k
, v
, NULL
);
1456 return git_status_config(k
, v
, s
);
1459 static int run_rewrite_hook(const unsigned char *oldsha1
,
1460 const unsigned char *newsha1
)
1462 /* oldsha1 SP newsha1 LF NUL */
1463 static char buf
[2*40 + 3];
1464 struct child_process proc
;
1465 const char *argv
[3];
1469 argv
[0] = find_hook("post-rewrite");
1476 memset(&proc
, 0, sizeof(proc
));
1479 proc
.stdout_to_stderr
= 1;
1481 code
= start_command(&proc
);
1484 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1485 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1486 write_in_full(proc
.in
, buf
, n
);
1488 return finish_command(&proc
);
1491 int run_commit_hook(int editor_is_used
, const char *index_file
, const char *name
, ...)
1493 const char *hook_env
[3] = { NULL
};
1494 char index
[PATH_MAX
];
1498 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
1499 hook_env
[0] = index
;
1502 * Let the hook know that no editor will be launched.
1504 if (!editor_is_used
)
1505 hook_env
[1] = "GIT_EDITOR=:";
1507 va_start(args
, name
);
1508 ret
= run_hook_ve(hook_env
, name
, args
);
1514 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1516 static struct wt_status s
;
1517 static struct option builtin_commit_options
[] = {
1518 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1519 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1521 OPT_GROUP(N_("Commit message options")),
1522 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1523 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1524 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1525 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1526 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1527 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1528 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1529 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1530 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1531 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1532 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1533 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1534 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1535 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1536 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key-id"),
1537 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1538 /* end commit message options */
1540 OPT_GROUP(N_("Commit contents options")),
1541 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1542 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1543 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1544 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1545 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1546 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1547 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1548 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1549 STATUS_FORMAT_SHORT
),
1550 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1551 OPT_SET_INT(0, "porcelain", &status_format
,
1552 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1553 OPT_SET_INT(0, "long", &status_format
,
1554 N_("show status in long format (default)"),
1555 STATUS_FORMAT_LONG
),
1556 OPT_BOOL('z', "null", &s
.null_termination
,
1557 N_("terminate entries with NUL")),
1558 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1559 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1560 { 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" },
1561 /* end commit contents options */
1563 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1564 N_("ok to record an empty change")),
1565 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1566 N_("ok to record a change with an empty message")),
1571 struct strbuf sb
= STRBUF_INIT
;
1572 struct strbuf author_ident
= STRBUF_INIT
;
1573 const char *index_file
, *reflog_msg
;
1575 unsigned char sha1
[20];
1576 struct ref_lock
*ref_lock
;
1577 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1578 struct stat statbuf
;
1579 struct commit
*current_head
= NULL
;
1580 struct commit_extra_header
*extra
= NULL
;
1582 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1583 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1585 status_init_config(&s
, git_commit_config
);
1586 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1589 if (get_sha1("HEAD", sha1
))
1590 current_head
= NULL
;
1592 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1593 if (parse_commit(current_head
))
1594 die(_("could not parse HEAD commit"));
1596 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1597 builtin_commit_usage
,
1598 prefix
, current_head
, &s
);
1600 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1601 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1603 /* Set up everything for writing the commit object. This includes
1604 running hooks, writing the trees, and interacting with the user. */
1605 if (!prepare_to_commit(index_file
, prefix
,
1606 current_head
, &s
, &author_ident
)) {
1607 rollback_index_files();
1611 /* Determine parents */
1612 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1613 if (!current_head
) {
1615 reflog_msg
= "commit (initial)";
1617 struct commit_list
*c
;
1620 reflog_msg
= "commit (amend)";
1621 for (c
= current_head
->parents
; c
; c
= c
->next
)
1622 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1623 } else if (whence
== FROM_MERGE
) {
1624 struct strbuf m
= STRBUF_INIT
;
1626 int allow_fast_forward
= 1;
1629 reflog_msg
= "commit (merge)";
1630 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1631 fp
= fopen(git_path("MERGE_HEAD"), "r");
1633 die_errno(_("could not open '%s' for reading"),
1634 git_path("MERGE_HEAD"));
1635 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1636 struct commit
*parent
;
1638 parent
= get_merge_parent(m
.buf
);
1640 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1641 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1645 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1646 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1647 die_errno(_("could not read MERGE_MODE"));
1648 if (!strcmp(sb
.buf
, "no-ff"))
1649 allow_fast_forward
= 0;
1651 if (allow_fast_forward
)
1652 parents
= reduce_heads(parents
);
1655 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1656 ? "commit (cherry-pick)"
1658 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1661 /* Finally, get the commit message */
1663 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1664 int saved_errno
= errno
;
1665 rollback_index_files();
1666 die(_("could not read commit message: %s"), strerror(saved_errno
));
1669 if (verbose
|| /* Truncate the message just before the diff, if any. */
1670 cleanup_mode
== CLEANUP_SCISSORS
)
1671 wt_status_truncate_message_at_cut_line(&sb
);
1673 if (cleanup_mode
!= CLEANUP_NONE
)
1674 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1675 if (template_untouched(&sb
) && !allow_empty_message
) {
1676 rollback_index_files();
1677 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1680 if (message_is_empty(&sb
) && !allow_empty_message
) {
1681 rollback_index_files();
1682 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1687 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1688 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1690 struct commit_extra_header
**tail
= &extra
;
1691 append_merge_tag_headers(parents
, &tail
);
1694 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1695 author_ident
.buf
, sign_commit
, extra
)) {
1696 rollback_index_files();
1697 die(_("failed to write commit object"));
1699 strbuf_release(&author_ident
);
1700 free_commit_extra_headers(extra
);
1702 ref_lock
= lock_any_ref_for_update("HEAD",
1705 : current_head
->object
.sha1
,
1708 nl
= strchr(sb
.buf
, '\n');
1710 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1712 strbuf_addch(&sb
, '\n');
1713 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1714 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1717 rollback_index_files();
1718 die(_("cannot lock HEAD ref"));
1720 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1721 rollback_index_files();
1722 die(_("cannot update HEAD ref"));
1725 unlink(git_path("CHERRY_PICK_HEAD"));
1726 unlink(git_path("REVERT_HEAD"));
1727 unlink(git_path("MERGE_HEAD"));
1728 unlink(git_path("MERGE_MSG"));
1729 unlink(git_path("MERGE_MODE"));
1730 unlink(git_path("SQUASH_MSG"));
1732 if (commit_index_files())
1733 die (_("Repository has been updated, but unable to write\n"
1734 "new_index file. Check that disk is not full or quota is\n"
1735 "not exceeded, and then \"git reset HEAD\" to recover."));
1738 run_commit_hook(use_editor
, get_index_file(), "post-commit", NULL
);
1739 if (amend
&& !no_post_rewrite
) {
1740 struct notes_rewrite_cfg
*cfg
;
1741 cfg
= init_copy_notes_for_rewrite("amend");
1743 /* we are amending, so current_head is not NULL */
1744 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1745 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1747 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1750 print_summary(prefix
, sha1
, !current_head
);