4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
11 #include "cache-tree.h"
19 #include "wt-status.h"
20 #include "run-command.h"
25 #include "parse-options.h"
26 #include "string-list.h"
28 #include "unpack-trees.h"
30 #include "submodule.h"
31 #include "gpg-interface.h"
33 #include "sequencer.h"
34 #include "notes-utils.h"
38 static const char * const builtin_commit_usage
[] = {
39 N_("git commit [<options>] [--] <pathspec>..."),
43 static const char * const builtin_status_usage
[] = {
44 N_("git status [<options>] [--] <pathspec>..."),
48 static const char implicit_ident_advice_noconfig
[] =
49 N_("Your name and email address were configured automatically based\n"
50 "on your username and hostname. Please check that they are accurate.\n"
51 "You can suppress this message by setting them explicitly. Run the\n"
52 "following command and follow the instructions in your editor to edit\n"
53 "your configuration file:\n"
55 " git config --global --edit\n"
57 "After doing this, you may fix the identity used for this commit with:\n"
59 " git commit --amend --reset-author\n");
61 static const char implicit_ident_advice_config
[] =
62 N_("Your name and email address were configured automatically based\n"
63 "on your username and hostname. Please check that they are accurate.\n"
64 "You can suppress this message by setting them explicitly:\n"
66 " git config --global user.name \"Your Name\"\n"
67 " git config --global user.email you@example.com\n"
69 "After doing this, you may fix the identity used for this commit with:\n"
71 " git commit --amend --reset-author\n");
73 static const char empty_amend_advice
[] =
74 N_("You asked to amend the most recent commit, but doing so would make\n"
75 "it empty. You can repeat your command with --allow-empty, or you can\n"
76 "remove the commit entirely with \"git reset HEAD^\".\n");
78 static const char empty_cherry_pick_advice
[] =
79 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
80 "If you wish to commit it anyway, use:\n"
82 " git commit --allow-empty\n"
85 static const char empty_cherry_pick_advice_single
[] =
86 N_("Otherwise, please use 'git reset'\n");
88 static const char empty_cherry_pick_advice_multi
[] =
89 N_("If you wish to skip this commit, use:\n"
93 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
94 "the remaining commits.\n");
96 static GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
98 static const char *use_message_buffer
;
99 static struct lock_file index_lock
; /* real index */
100 static struct lock_file false_lock
; /* used only for partial commits */
107 static const char *logfile
, *force_author
;
108 static const char *template_file
;
110 * The _message variables are commit names from which to take
111 * the commit message and/or authorship.
113 static const char *author_message
, *author_message_buffer
;
114 static char *edit_message
, *use_message
;
115 static char *fixup_message
, *squash_message
;
116 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
117 static int edit_flag
= -1; /* unspecified */
118 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
119 static int config_commit_verbose
= -1; /* unspecified */
120 static int no_post_rewrite
, allow_empty_message
;
121 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
122 static char *sign_commit
;
125 * The default commit message cleanup mode will remove the lines
126 * beginning with # (shell comments) and leading and trailing
127 * whitespaces (empty lines or containing only whitespaces)
128 * if editor is used, and only the whitespaces if the message
129 * is specified explicitly.
131 static enum commit_msg_cleanup_mode cleanup_mode
;
132 static const char *cleanup_arg
;
134 static enum commit_whence whence
;
135 static int sequencer_in_use
;
136 static int use_editor
= 1, include_status
= 1;
137 static int show_ignored_in_status
, have_option_m
;
138 static struct strbuf message
= STRBUF_INIT
;
140 static enum wt_status_format status_format
= STATUS_FORMAT_UNSPECIFIED
;
142 static int opt_parse_porcelain(const struct option
*opt
, const char *arg
, int unset
)
144 enum wt_status_format
*value
= (enum wt_status_format
*)opt
->value
;
146 *value
= STATUS_FORMAT_NONE
;
148 *value
= STATUS_FORMAT_PORCELAIN
;
149 else if (!strcmp(arg
, "v1") || !strcmp(arg
, "1"))
150 *value
= STATUS_FORMAT_PORCELAIN
;
151 else if (!strcmp(arg
, "v2") || !strcmp(arg
, "2"))
152 *value
= STATUS_FORMAT_PORCELAIN_V2
;
154 die("unsupported porcelain version '%s'", arg
);
159 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
161 struct strbuf
*buf
= opt
->value
;
164 strbuf_setlen(buf
, 0);
168 strbuf_addch(buf
, '\n');
169 strbuf_addstr(buf
, arg
);
170 strbuf_complete_line(buf
);
175 static void determine_whence(struct wt_status
*s
)
177 if (file_exists(git_path_merge_head()))
179 else if (file_exists(git_path_cherry_pick_head())) {
180 whence
= FROM_CHERRY_PICK
;
181 if (file_exists(git_path_seq_dir()))
182 sequencer_in_use
= 1;
185 whence
= FROM_COMMIT
;
190 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
192 wt_status_prepare(s
);
195 init_diff_ui_defaults();
196 s
->hints
= advice_status_hints
; /* must come after git_config() */
199 static void rollback_index_files(void)
201 switch (commit_style
) {
203 break; /* nothing to do */
205 rollback_lock_file(&index_lock
);
208 rollback_lock_file(&index_lock
);
209 rollback_lock_file(&false_lock
);
214 static int commit_index_files(void)
218 switch (commit_style
) {
220 break; /* nothing to do */
222 err
= commit_lock_file(&index_lock
);
225 err
= commit_lock_file(&index_lock
);
226 rollback_lock_file(&false_lock
);
234 * Take a union of paths in the index and the named tree (typically, "HEAD"),
235 * and return the paths that match the given pattern in list.
237 static int list_paths(struct string_list
*list
, const char *with_tree
,
238 const char *prefix
, const struct pathspec
*pattern
)
246 m
= xcalloc(1, pattern
->nr
);
249 char *max_prefix
= common_prefix(pattern
);
250 overlay_tree_on_index(&the_index
, with_tree
,
251 max_prefix
? max_prefix
: prefix
);
255 for (i
= 0; i
< active_nr
; i
++) {
256 const struct cache_entry
*ce
= active_cache
[i
];
257 struct string_list_item
*item
;
259 if (ce
->ce_flags
& CE_UPDATE
)
261 if (!ce_path_match(ce
, pattern
, m
))
263 item
= string_list_insert(list
, ce
->name
);
264 if (ce_skip_worktree(ce
))
265 item
->util
= item
; /* better a valid pointer than a fake one */
268 ret
= report_path_error(m
, pattern
, prefix
);
273 static void add_remove_files(struct string_list
*list
)
276 for (i
= 0; i
< list
->nr
; i
++) {
278 struct string_list_item
*p
= &(list
->items
[i
]);
280 /* p->util is skip-worktree */
284 if (!lstat(p
->string
, &st
)) {
285 if (add_to_cache(p
->string
, &st
, 0))
286 die(_("updating files failed"));
288 remove_file_from_cache(p
->string
);
292 static void create_base_index(const struct commit
*current_head
)
295 struct unpack_trees_options opts
;
303 memset(&opts
, 0, sizeof(opts
));
307 opts
.src_index
= &the_index
;
308 opts
.dst_index
= &the_index
;
310 opts
.fn
= oneway_merge
;
311 tree
= parse_tree_indirect(¤t_head
->object
.oid
);
313 die(_("failed to unpack HEAD tree object"));
315 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
316 if (unpack_trees(1, &t
, &opts
))
317 exit(128); /* We've already reported the error, finish dying */
320 static void refresh_cache_or_die(int refresh_flags
)
323 * refresh_flags contains REFRESH_QUIET, so the only errors
324 * are for unmerged entries.
326 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
327 die_resolve_conflict("commit");
330 static const char *prepare_index(int argc
, const char **argv
, const char *prefix
,
331 const struct commit
*current_head
, int is_status
)
333 struct string_list partial
= STRING_LIST_INIT_DUP
;
334 struct pathspec pathspec
;
335 int refresh_flags
= REFRESH_QUIET
;
339 refresh_flags
|= REFRESH_UNMERGED
;
340 parse_pathspec(&pathspec
, 0,
341 PATHSPEC_PREFER_FULL
,
344 if (read_cache_preload(&pathspec
) < 0)
345 die(_("index file corrupt"));
348 char *old_index_env
= NULL
;
349 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
351 refresh_cache_or_die(refresh_flags
);
353 if (write_locked_index(&the_index
, &index_lock
, 0))
354 die(_("unable to create temporary index"));
356 old_index_env
= getenv(INDEX_ENVIRONMENT
);
357 setenv(INDEX_ENVIRONMENT
, get_lock_file_path(&index_lock
), 1);
359 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
360 die(_("interactive add failed"));
362 if (old_index_env
&& *old_index_env
)
363 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
365 unsetenv(INDEX_ENVIRONMENT
);
368 read_cache_from(get_lock_file_path(&index_lock
));
369 if (update_main_cache_tree(WRITE_TREE_SILENT
) == 0) {
370 if (reopen_lock_file(&index_lock
) < 0)
371 die(_("unable to write index file"));
372 if (write_locked_index(&the_index
, &index_lock
, 0))
373 die(_("unable to update temporary index"));
375 warning(_("Failed to update main cache tree"));
377 commit_style
= COMMIT_NORMAL
;
378 ret
= get_lock_file_path(&index_lock
);
383 * Non partial, non as-is commit.
385 * (1) get the real index;
386 * (2) update the_index as necessary;
387 * (3) write the_index out to the real index (still locked);
388 * (4) return the name of the locked index file.
390 * The caller should run hooks on the locked real index, and
391 * (A) if all goes well, commit the real index;
392 * (B) on failure, rollback the real index.
394 if (all
|| (also
&& pathspec
.nr
)) {
395 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
396 add_files_to_cache(also
? prefix
: NULL
, &pathspec
, 0);
397 refresh_cache_or_die(refresh_flags
);
398 update_main_cache_tree(WRITE_TREE_SILENT
);
399 if (write_locked_index(&the_index
, &index_lock
, 0))
400 die(_("unable to write new_index file"));
401 commit_style
= COMMIT_NORMAL
;
402 ret
= get_lock_file_path(&index_lock
);
409 * (1) return the name of the real index file.
411 * The caller should run hooks on the real index,
412 * and create commit from the_index.
413 * We still need to refresh the index here.
415 if (!only
&& !pathspec
.nr
) {
416 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
417 refresh_cache_or_die(refresh_flags
);
418 if (active_cache_changed
419 || !cache_tree_fully_valid(active_cache_tree
))
420 update_main_cache_tree(WRITE_TREE_SILENT
);
421 if (active_cache_changed
) {
422 if (write_locked_index(&the_index
, &index_lock
,
424 die(_("unable to write new_index file"));
426 rollback_lock_file(&index_lock
);
428 commit_style
= COMMIT_AS_IS
;
429 ret
= get_index_file();
436 * (0) find the set of affected paths;
437 * (1) get lock on the real index file;
438 * (2) update the_index with the given paths;
439 * (3) write the_index out to the real index (still locked);
440 * (4) get lock on the false index file;
441 * (5) reset the_index from HEAD;
442 * (6) update the_index the same way as (2);
443 * (7) write the_index out to the false index file;
444 * (8) return the name of the false index file (still locked);
446 * The caller should run hooks on the locked false index, and
447 * create commit from it. Then
448 * (A) if all goes well, commit the real index;
449 * (B) on failure, rollback the real index;
450 * In either case, rollback the false index.
452 commit_style
= COMMIT_PARTIAL
;
454 if (whence
!= FROM_COMMIT
) {
455 if (whence
== FROM_MERGE
)
456 die(_("cannot do a partial commit during a merge."));
457 else if (whence
== FROM_CHERRY_PICK
)
458 die(_("cannot do a partial commit during a cherry-pick."));
461 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, &pathspec
))
465 if (read_cache() < 0)
466 die(_("cannot read the index"));
468 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
469 add_remove_files(&partial
);
470 refresh_cache(REFRESH_QUIET
);
471 update_main_cache_tree(WRITE_TREE_SILENT
);
472 if (write_locked_index(&the_index
, &index_lock
, 0))
473 die(_("unable to write new_index file"));
475 hold_lock_file_for_update(&false_lock
,
476 git_path("next-index-%"PRIuMAX
,
477 (uintmax_t) getpid()),
480 create_base_index(current_head
);
481 add_remove_files(&partial
);
482 refresh_cache(REFRESH_QUIET
);
484 if (write_locked_index(&the_index
, &false_lock
, 0))
485 die(_("unable to write temporary index file"));
488 ret
= get_lock_file_path(&false_lock
);
489 read_cache_from(ret
);
491 string_list_clear(&partial
, 0);
492 clear_pathspec(&pathspec
);
496 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
499 struct object_id oid
;
501 if (s
->relative_paths
)
506 s
->reference
= "HEAD^1";
508 s
->verbose
= verbose
;
509 s
->index_file
= index_file
;
512 s
->is_initial
= get_oid(s
->reference
, &oid
) ? 1 : 0;
514 hashcpy(s
->sha1_commit
, oid
.hash
);
515 s
->status_format
= status_format
;
516 s
->ignore_submodule_arg
= ignore_submodule_arg
;
518 wt_status_collect(s
);
521 return s
->commitable
;
524 static int is_a_merge(const struct commit
*current_head
)
526 return !!(current_head
->parents
&& current_head
->parents
->next
);
529 static void assert_split_ident(struct ident_split
*id
, const struct strbuf
*buf
)
531 if (split_ident_line(id
, buf
->buf
, buf
->len
) || !id
->date_begin
)
532 die("BUG: unable to parse our own ident: %s", buf
->buf
);
535 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
537 struct strbuf buf
= STRBUF_INIT
;
539 strbuf_addch(&buf
, hack
);
540 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
541 setenv(var
, buf
.buf
, 1);
542 strbuf_release(&buf
);
545 static int parse_force_date(const char *in
, struct strbuf
*out
)
547 strbuf_addch(out
, '@');
549 if (parse_date(in
, out
) < 0) {
551 unsigned long t
= approxidate_careful(in
, &errors
);
554 strbuf_addf(out
, "%lu", t
);
560 static void set_ident_var(char **buf
, char *val
)
566 static void determine_author_info(struct strbuf
*author_ident
)
568 char *name
, *email
, *date
;
569 struct ident_split author
;
571 name
= xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
572 email
= xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
573 date
= xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
575 if (author_message
) {
576 struct ident_split ident
;
580 a
= find_commit_header(author_message_buffer
, "author", &len
);
582 die(_("commit '%s' lacks author header"), author_message
);
583 if (split_ident_line(&ident
, a
, len
) < 0)
584 die(_("commit '%s' has malformed author line"), author_message
);
586 set_ident_var(&name
, xmemdupz(ident
.name_begin
, ident
.name_end
- ident
.name_begin
));
587 set_ident_var(&email
, xmemdupz(ident
.mail_begin
, ident
.mail_end
- ident
.mail_begin
));
589 if (ident
.date_begin
) {
590 struct strbuf date_buf
= STRBUF_INIT
;
591 strbuf_addch(&date_buf
, '@');
592 strbuf_add(&date_buf
, ident
.date_begin
, ident
.date_end
- ident
.date_begin
);
593 strbuf_addch(&date_buf
, ' ');
594 strbuf_add(&date_buf
, ident
.tz_begin
, ident
.tz_end
- ident
.tz_begin
);
595 set_ident_var(&date
, strbuf_detach(&date_buf
, NULL
));
600 struct ident_split ident
;
602 if (split_ident_line(&ident
, force_author
, strlen(force_author
)) < 0)
603 die(_("malformed --author parameter"));
604 set_ident_var(&name
, xmemdupz(ident
.name_begin
, ident
.name_end
- ident
.name_begin
));
605 set_ident_var(&email
, xmemdupz(ident
.mail_begin
, ident
.mail_end
- ident
.mail_begin
));
609 struct strbuf date_buf
= STRBUF_INIT
;
610 if (parse_force_date(force_date
, &date_buf
))
611 die(_("invalid date format: %s"), force_date
);
612 set_ident_var(&date
, strbuf_detach(&date_buf
, NULL
));
615 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
616 assert_split_ident(&author
, author_ident
);
617 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
618 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
619 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
625 static int author_date_is_interesting(void)
627 return author_message
|| force_date
;
630 static void adjust_comment_line_char(const struct strbuf
*sb
)
632 char candidates
[] = "#;@!$%^&|:";
636 comment_line_char
= candidates
[0];
637 if (!memchr(sb
->buf
, comment_line_char
, sb
->len
))
641 candidate
= strchr(candidates
, *p
);
644 for (p
= sb
->buf
; *p
; p
++) {
645 if ((p
[0] == '\n' || p
[0] == '\r') && p
[1]) {
646 candidate
= strchr(candidates
, p
[1]);
652 for (p
= candidates
; *p
== ' '; p
++)
655 die(_("unable to select a comment character that is not used\n"
656 "in the current commit message"));
657 comment_line_char
= *p
;
660 static int prepare_to_commit(const char *index_file
, const char *prefix
,
661 struct commit
*current_head
,
663 struct strbuf
*author_ident
)
666 struct strbuf committer_ident
= STRBUF_INIT
;
668 struct strbuf sb
= STRBUF_INIT
;
669 const char *hook_arg1
= NULL
;
670 const char *hook_arg2
= NULL
;
671 int clean_message_contents
= (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
);
672 int old_display_comment_prefix
;
674 /* This checks and barfs if author is badly specified */
675 determine_author_info(author_ident
);
677 if (!no_verify
&& run_commit_hook(use_editor
, index_file
, "pre-commit", NULL
))
680 if (squash_message
) {
682 * Insert the proper subject line before other commit
683 * message options add their content.
685 if (use_message
&& !strcmp(use_message
, squash_message
))
686 strbuf_addstr(&sb
, "squash! ");
688 struct pretty_print_context ctx
= {0};
690 c
= lookup_commit_reference_by_name(squash_message
);
692 die(_("could not lookup commit %s"), squash_message
);
693 ctx
.output_encoding
= get_commit_output_encoding();
694 format_commit_message(c
, "squash! %s\n\n", &sb
,
700 strbuf_addbuf(&sb
, &message
);
701 hook_arg1
= "message";
702 } else if (logfile
&& !strcmp(logfile
, "-")) {
704 fprintf(stderr
, _("(reading log message from standard input)\n"));
705 if (strbuf_read(&sb
, 0, 0) < 0)
706 die_errno(_("could not read log from standard input"));
707 hook_arg1
= "message";
708 } else if (logfile
) {
709 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
710 die_errno(_("could not read log file '%s'"),
712 hook_arg1
= "message";
713 } else if (use_message
) {
715 buffer
= strstr(use_message_buffer
, "\n\n");
717 strbuf_addstr(&sb
, skip_blank_lines(buffer
+ 2));
718 hook_arg1
= "commit";
719 hook_arg2
= use_message
;
720 } else if (fixup_message
) {
721 struct pretty_print_context ctx
= {0};
722 struct commit
*commit
;
723 commit
= lookup_commit_reference_by_name(fixup_message
);
725 die(_("could not lookup commit %s"), fixup_message
);
726 ctx
.output_encoding
= get_commit_output_encoding();
727 format_commit_message(commit
, "fixup! %s\n\n",
729 hook_arg1
= "message";
730 } else if (!stat(git_path_merge_msg(), &statbuf
)) {
732 * prepend SQUASH_MSG here if it exists and a
733 * "merge --squash" was originally performed
735 if (!stat(git_path_squash_msg(), &statbuf
)) {
736 if (strbuf_read_file(&sb
, git_path_squash_msg(), 0) < 0)
737 die_errno(_("could not read SQUASH_MSG"));
738 hook_arg1
= "squash";
741 if (strbuf_read_file(&sb
, git_path_merge_msg(), 0) < 0)
742 die_errno(_("could not read MERGE_MSG"));
743 } else if (!stat(git_path_squash_msg(), &statbuf
)) {
744 if (strbuf_read_file(&sb
, git_path_squash_msg(), 0) < 0)
745 die_errno(_("could not read SQUASH_MSG"));
746 hook_arg1
= "squash";
747 } else if (template_file
) {
748 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
749 die_errno(_("could not read '%s'"), template_file
);
750 hook_arg1
= "template";
751 clean_message_contents
= 0;
755 * The remaining cases don't modify the template message, but
756 * just set the argument(s) to the prepare-commit-msg hook.
758 else if (whence
== FROM_MERGE
)
760 else if (whence
== FROM_CHERRY_PICK
) {
761 hook_arg1
= "commit";
762 hook_arg2
= "CHERRY_PICK_HEAD";
765 if (squash_message
) {
767 * If squash_commit was used for the commit subject,
768 * then we're possibly hijacking other commit log options.
769 * Reset the hook args to tell the real story.
771 hook_arg1
= "message";
775 s
->fp
= fopen_for_writing(git_path_commit_editmsg());
777 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
779 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
780 old_display_comment_prefix
= s
->display_comment_prefix
;
781 s
->display_comment_prefix
= 1;
784 * Most hints are counter-productive when the commit has
789 if (clean_message_contents
)
790 strbuf_stripspace(&sb
, 0);
793 append_signoff(&sb
, ignore_non_trailer(sb
.buf
, sb
.len
), 0);
795 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
796 die_errno(_("could not write commit template"));
798 if (auto_comment_line_char
)
799 adjust_comment_line_char(&sb
);
802 /* This checks if committer ident is explicitly given */
803 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
804 if (use_editor
&& include_status
) {
806 int saved_color_setting
;
807 struct ident_split ci
, ai
;
809 if (whence
!= FROM_COMMIT
) {
810 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
811 wt_status_add_cut_line(s
->fp
);
812 status_printf_ln(s
, GIT_COLOR_NORMAL
,
815 "It looks like you may be committing a merge.\n"
816 "If this is not correct, please remove the file\n"
820 "It looks like you may be committing a cherry-pick.\n"
821 "If this is not correct, please remove the file\n"
824 whence
== FROM_MERGE
?
825 git_path_merge_head() :
826 git_path_cherry_pick_head());
829 fprintf(s
->fp
, "\n");
830 if (cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
)
831 status_printf(s
, GIT_COLOR_NORMAL
,
832 _("Please enter the commit message for your changes."
833 " Lines starting\nwith '%c' will be ignored, and an empty"
834 " message aborts the commit.\n"), comment_line_char
);
835 else if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
&&
836 whence
== FROM_COMMIT
)
837 wt_status_add_cut_line(s
->fp
);
838 else /* COMMIT_MSG_CLEANUP_SPACE, that is. */
839 status_printf(s
, GIT_COLOR_NORMAL
,
840 _("Please enter the commit message for your changes."
842 "with '%c' will be kept; you may remove them"
843 " yourself if you want to.\n"
844 "An empty message aborts the commit.\n"), comment_line_char
);
847 * These should never fail because they come from our own
848 * fmt_ident. They may fail the sane_ident test, but we know
849 * that the name and mail pointers will at least be valid,
850 * which is enough for our tests and printing here.
852 assert_split_ident(&ai
, author_ident
);
853 assert_split_ident(&ci
, &committer_ident
);
855 if (ident_cmp(&ai
, &ci
))
856 status_printf_ln(s
, GIT_COLOR_NORMAL
,
858 "Author: %.*s <%.*s>"),
859 ident_shown
++ ? "" : "\n",
860 (int)(ai
.name_end
- ai
.name_begin
), ai
.name_begin
,
861 (int)(ai
.mail_end
- ai
.mail_begin
), ai
.mail_begin
);
863 if (author_date_is_interesting())
864 status_printf_ln(s
, GIT_COLOR_NORMAL
,
867 ident_shown
++ ? "" : "\n",
868 show_ident_date(&ai
, DATE_MODE(NORMAL
)));
870 if (!committer_ident_sufficiently_given())
871 status_printf_ln(s
, GIT_COLOR_NORMAL
,
873 "Committer: %.*s <%.*s>"),
874 ident_shown
++ ? "" : "\n",
875 (int)(ci
.name_end
- ci
.name_begin
), ci
.name_begin
,
876 (int)(ci
.mail_end
- ci
.mail_begin
), ci
.mail_begin
);
878 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", ""); /* Add new line for clarity */
880 saved_color_setting
= s
->use_color
;
882 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
883 s
->use_color
= saved_color_setting
;
885 struct object_id oid
;
886 const char *parent
= "HEAD";
888 if (!active_nr
&& read_cache() < 0)
889 die(_("Cannot read index"));
894 if (get_oid(parent
, &oid
)) {
897 for (i
= 0; i
< active_nr
; i
++)
898 if (ce_intent_to_add(active_cache
[i
]))
900 commitable
= active_nr
- ita_nr
> 0;
903 * Unless the user did explicitly request a submodule
904 * ignore mode by passing a command line option we do
905 * not ignore any changed submodule SHA-1s when
906 * comparing index and parent, no matter what is
907 * configured. Otherwise we won't commit any
908 * submodules which were manually staged, which would
909 * be really confusing.
911 struct diff_flags flags
= DIFF_FLAGS_INIT
;
912 flags
.override_submodule_config
= 1;
913 if (ignore_submodule_arg
&&
914 !strcmp(ignore_submodule_arg
, "all"))
915 flags
.ignore_submodules
= 1;
916 commitable
= index_differs_from(parent
, &flags
, 1);
919 strbuf_release(&committer_ident
);
924 * Reject an attempt to record a non-merge empty commit without
925 * explicit --allow-empty. In the cherry-pick case, it may be
926 * empty due to conflict resolution, which the user should okay.
928 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
929 !(amend
&& is_a_merge(current_head
))) {
930 s
->display_comment_prefix
= old_display_comment_prefix
;
931 run_status(stdout
, index_file
, prefix
, 0, s
);
933 fputs(_(empty_amend_advice
), stderr
);
934 else if (whence
== FROM_CHERRY_PICK
) {
935 fputs(_(empty_cherry_pick_advice
), stderr
);
936 if (!sequencer_in_use
)
937 fputs(_(empty_cherry_pick_advice_single
), stderr
);
939 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
944 if (!no_verify
&& find_hook("pre-commit")) {
946 * Re-read the index as pre-commit hook could have updated it,
947 * and write it out as a tree. We must do this before we invoke
948 * the editor and after we invoke run_status above.
952 read_cache_from(index_file
);
954 if (update_main_cache_tree(0)) {
955 error(_("Error building trees"));
959 if (run_commit_hook(use_editor
, index_file
, "prepare-commit-msg",
960 git_path_commit_editmsg(), hook_arg1
, hook_arg2
, NULL
))
964 struct argv_array env
= ARGV_ARRAY_INIT
;
966 argv_array_pushf(&env
, "GIT_INDEX_FILE=%s", index_file
);
967 if (launch_editor(git_path_commit_editmsg(), NULL
, env
.argv
)) {
969 _("Please supply the message using either -m or -F option.\n"));
972 argv_array_clear(&env
);
976 run_commit_hook(use_editor
, index_file
, "commit-msg", git_path_commit_editmsg(), NULL
)) {
983 static const char *find_author_by_nickname(const char *name
)
985 struct rev_info revs
;
986 struct commit
*commit
;
987 struct strbuf buf
= STRBUF_INIT
;
988 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
992 init_revisions(&revs
, NULL
);
993 strbuf_addf(&buf
, "--author=%s", name
);
998 setup_revisions(ac
, av
, &revs
, NULL
);
999 revs
.mailmap
= &mailmap
;
1000 read_mailmap(revs
.mailmap
, NULL
);
1002 if (prepare_revision_walk(&revs
))
1003 die(_("revision walk setup failed"));
1004 commit
= get_revision(&revs
);
1006 struct pretty_print_context ctx
= {0};
1007 ctx
.date_mode
.type
= DATE_NORMAL
;
1008 strbuf_release(&buf
);
1009 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
1010 clear_mailmap(&mailmap
);
1011 return strbuf_detach(&buf
, NULL
);
1013 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name
);
1017 static void handle_untracked_files_arg(struct wt_status
*s
)
1019 if (!untracked_files_arg
)
1020 ; /* default already initialized */
1021 else if (!strcmp(untracked_files_arg
, "no"))
1022 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1023 else if (!strcmp(untracked_files_arg
, "normal"))
1024 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1025 else if (!strcmp(untracked_files_arg
, "all"))
1026 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1028 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1031 static const char *read_commit_message(const char *name
)
1033 const char *out_enc
;
1034 struct commit
*commit
;
1036 commit
= lookup_commit_reference_by_name(name
);
1038 die(_("could not lookup commit %s"), name
);
1039 out_enc
= get_commit_output_encoding();
1040 return logmsg_reencode(commit
, NULL
, out_enc
);
1044 * Enumerate what needs to be propagated when --porcelain
1045 * is not in effect here.
1047 static struct status_deferred_config
{
1048 enum wt_status_format status_format
;
1050 } status_deferred_config
= {
1051 STATUS_FORMAT_UNSPECIFIED
,
1052 -1 /* unspecified */
1055 static void finalize_deferred_config(struct wt_status
*s
)
1057 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1058 status_format
!= STATUS_FORMAT_PORCELAIN_V2
&&
1059 !s
->null_termination
);
1061 if (s
->null_termination
) {
1062 if (status_format
== STATUS_FORMAT_NONE
||
1063 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1064 status_format
= STATUS_FORMAT_PORCELAIN
;
1065 else if (status_format
== STATUS_FORMAT_LONG
)
1066 die(_("--long and -z are incompatible"));
1069 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1070 status_format
= status_deferred_config
.status_format
;
1071 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1072 status_format
= STATUS_FORMAT_NONE
;
1074 if (use_deferred_config
&& s
->show_branch
< 0)
1075 s
->show_branch
= status_deferred_config
.show_branch
;
1076 if (s
->show_branch
< 0)
1080 static int parse_and_validate_options(int argc
, const char *argv
[],
1081 const struct option
*options
,
1082 const char * const usage
[],
1084 struct commit
*current_head
,
1085 struct wt_status
*s
)
1089 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1090 finalize_deferred_config(s
);
1092 if (force_author
&& !strchr(force_author
, '>'))
1093 force_author
= find_author_by_nickname(force_author
);
1095 if (force_author
&& renew_authorship
)
1096 die(_("Using both --reset-author and --author does not make sense"));
1098 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1101 use_editor
= edit_flag
;
1103 /* Sanity check options */
1104 if (amend
&& !current_head
)
1105 die(_("You have nothing to amend."));
1106 if (amend
&& whence
!= FROM_COMMIT
) {
1107 if (whence
== FROM_MERGE
)
1108 die(_("You are in the middle of a merge -- cannot amend."));
1109 else if (whence
== FROM_CHERRY_PICK
)
1110 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1112 if (fixup_message
&& squash_message
)
1113 die(_("Options --squash and --fixup cannot be used together"));
1123 die(_("Only one of -c/-C/-F/--fixup can be used."));
1124 if (have_option_m
&& f
> 0)
1125 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1126 if (f
|| have_option_m
)
1127 template_file
= NULL
;
1129 use_message
= edit_message
;
1130 if (amend
&& !use_message
&& !fixup_message
)
1131 use_message
= "HEAD";
1132 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1133 die(_("--reset-author can be used only with -C, -c or --amend."));
1135 use_message_buffer
= read_commit_message(use_message
);
1136 if (!renew_authorship
) {
1137 author_message
= use_message
;
1138 author_message_buffer
= use_message_buffer
;
1141 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1142 author_message
= "CHERRY_PICK_HEAD";
1143 author_message_buffer
= read_commit_message(author_message
);
1146 if (patch_interactive
)
1149 if (also
+ only
+ all
+ interactive
> 1)
1150 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1151 if (argc
== 0 && (also
|| (only
&& !amend
&& !allow_empty
)))
1152 die(_("No paths with --include/--only does not make sense."));
1153 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1154 cleanup_mode
= use_editor
? COMMIT_MSG_CLEANUP_ALL
:
1155 COMMIT_MSG_CLEANUP_SPACE
;
1156 else if (!strcmp(cleanup_arg
, "verbatim"))
1157 cleanup_mode
= COMMIT_MSG_CLEANUP_NONE
;
1158 else if (!strcmp(cleanup_arg
, "whitespace"))
1159 cleanup_mode
= COMMIT_MSG_CLEANUP_SPACE
;
1160 else if (!strcmp(cleanup_arg
, "strip"))
1161 cleanup_mode
= COMMIT_MSG_CLEANUP_ALL
;
1162 else if (!strcmp(cleanup_arg
, "scissors"))
1163 cleanup_mode
= use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
1164 COMMIT_MSG_CLEANUP_SPACE
;
1166 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1168 handle_untracked_files_arg(s
);
1170 if (all
&& argc
> 0)
1171 die(_("Paths with -a does not make sense."));
1173 if (status_format
!= STATUS_FORMAT_NONE
)
1179 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1180 const struct commit
*current_head
, struct wt_status
*s
)
1183 const char *index_file
;
1185 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1186 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1187 rollback_index_files();
1189 return commitable
? 0 : 1;
1192 static int parse_status_slot(const char *slot
)
1194 if (!strcasecmp(slot
, "header"))
1195 return WT_STATUS_HEADER
;
1196 if (!strcasecmp(slot
, "branch"))
1197 return WT_STATUS_ONBRANCH
;
1198 if (!strcasecmp(slot
, "updated") || !strcasecmp(slot
, "added"))
1199 return WT_STATUS_UPDATED
;
1200 if (!strcasecmp(slot
, "changed"))
1201 return WT_STATUS_CHANGED
;
1202 if (!strcasecmp(slot
, "untracked"))
1203 return WT_STATUS_UNTRACKED
;
1204 if (!strcasecmp(slot
, "nobranch"))
1205 return WT_STATUS_NOBRANCH
;
1206 if (!strcasecmp(slot
, "unmerged"))
1207 return WT_STATUS_UNMERGED
;
1208 if (!strcasecmp(slot
, "localBranch"))
1209 return WT_STATUS_LOCAL_BRANCH
;
1210 if (!strcasecmp(slot
, "remoteBranch"))
1211 return WT_STATUS_REMOTE_BRANCH
;
1215 static int git_status_config(const char *k
, const char *v
, void *cb
)
1217 struct wt_status
*s
= cb
;
1218 const char *slot_name
;
1220 if (starts_with(k
, "column."))
1221 return git_column_config(k
, v
, "status", &s
->colopts
);
1222 if (!strcmp(k
, "status.submodulesummary")) {
1224 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1225 if (is_bool
&& s
->submodule_summary
)
1226 s
->submodule_summary
= -1;
1229 if (!strcmp(k
, "status.short")) {
1230 if (git_config_bool(k
, v
))
1231 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1233 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1236 if (!strcmp(k
, "status.branch")) {
1237 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1240 if (!strcmp(k
, "status.showstash")) {
1241 s
->show_stash
= git_config_bool(k
, v
);
1244 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1245 s
->use_color
= git_config_colorbool(k
, v
);
1248 if (!strcmp(k
, "status.displaycommentprefix")) {
1249 s
->display_comment_prefix
= git_config_bool(k
, v
);
1252 if (skip_prefix(k
, "status.color.", &slot_name
) ||
1253 skip_prefix(k
, "color.status.", &slot_name
)) {
1254 int slot
= parse_status_slot(slot_name
);
1258 return config_error_nonbool(k
);
1259 return color_parse(v
, s
->color_palette
[slot
]);
1261 if (!strcmp(k
, "status.relativepaths")) {
1262 s
->relative_paths
= git_config_bool(k
, v
);
1265 if (!strcmp(k
, "status.showuntrackedfiles")) {
1267 return config_error_nonbool(k
);
1268 else if (!strcmp(v
, "no"))
1269 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1270 else if (!strcmp(v
, "normal"))
1271 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1272 else if (!strcmp(v
, "all"))
1273 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1275 return error(_("Invalid untracked files mode '%s'"), v
);
1278 return git_diff_ui_config(k
, v
, NULL
);
1281 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1283 static struct wt_status s
;
1285 struct object_id oid
;
1286 static struct option builtin_status_options
[] = {
1287 OPT__VERBOSE(&verbose
, N_("be verbose")),
1288 OPT_SET_INT('s', "short", &status_format
,
1289 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1290 OPT_BOOL('b', "branch", &s
.show_branch
,
1291 N_("show branch information")),
1292 OPT_BOOL(0, "show-stash", &s
.show_stash
,
1293 N_("show stash information")),
1294 { OPTION_CALLBACK
, 0, "porcelain", &status_format
,
1295 N_("version"), N_("machine-readable output"),
1296 PARSE_OPT_OPTARG
, opt_parse_porcelain
},
1297 OPT_SET_INT(0, "long", &status_format
,
1298 N_("show status in long format (default)"),
1299 STATUS_FORMAT_LONG
),
1300 OPT_BOOL('z', "null", &s
.null_termination
,
1301 N_("terminate entries with NUL")),
1302 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1304 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1305 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1306 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1307 N_("show ignored files")),
1308 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1309 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1310 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1311 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1315 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1316 usage_with_options(builtin_status_usage
, builtin_status_options
);
1318 status_init_config(&s
, git_status_config
);
1319 argc
= parse_options(argc
, argv
, prefix
,
1320 builtin_status_options
,
1321 builtin_status_usage
, 0);
1322 finalize_colopts(&s
.colopts
, -1);
1323 finalize_deferred_config(&s
);
1325 handle_untracked_files_arg(&s
);
1326 if (show_ignored_in_status
)
1327 s
.show_ignored_files
= 1;
1328 parse_pathspec(&s
.pathspec
, 0,
1329 PATHSPEC_PREFER_FULL
,
1332 read_cache_preload(&s
.pathspec
);
1333 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1335 if (use_optional_locks())
1336 fd
= hold_locked_index(&index_lock
, 0);
1340 s
.is_initial
= get_oid(s
.reference
, &oid
) ? 1 : 0;
1342 hashcpy(s
.sha1_commit
, oid
.hash
);
1344 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1345 s
.status_format
= status_format
;
1346 s
.verbose
= verbose
;
1348 wt_status_collect(&s
);
1351 update_index_if_able(&the_index
, &index_lock
);
1353 if (s
.relative_paths
)
1356 wt_status_print(&s
);
1360 static const char *implicit_ident_advice(void)
1362 char *user_config
= expand_user_path("~/.gitconfig", 0);
1363 char *xdg_config
= xdg_config_home("config");
1364 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1370 return _(implicit_ident_advice_config
);
1372 return _(implicit_ident_advice_noconfig
);
1376 static void print_summary(const char *prefix
, const struct object_id
*oid
,
1379 struct rev_info rev
;
1380 struct commit
*commit
;
1381 struct strbuf format
= STRBUF_INIT
;
1383 struct pretty_print_context pctx
= {0};
1384 struct strbuf author_ident
= STRBUF_INIT
;
1385 struct strbuf committer_ident
= STRBUF_INIT
;
1387 commit
= lookup_commit(oid
);
1389 die(_("couldn't look up newly created commit"));
1390 if (parse_commit(commit
))
1391 die(_("could not parse newly created commit"));
1393 strbuf_addstr(&format
, "format:%h] %s");
1395 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1396 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1397 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1398 strbuf_addstr(&format
, "\n Author: ");
1399 strbuf_addbuf_percentquote(&format
, &author_ident
);
1401 if (author_date_is_interesting()) {
1402 struct strbuf date
= STRBUF_INIT
;
1403 format_commit_message(commit
, "%ad", &date
, &pctx
);
1404 strbuf_addstr(&format
, "\n Date: ");
1405 strbuf_addbuf_percentquote(&format
, &date
);
1406 strbuf_release(&date
);
1408 if (!committer_ident_sufficiently_given()) {
1409 strbuf_addstr(&format
, "\n Committer: ");
1410 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1411 if (advice_implicit_identity
) {
1412 strbuf_addch(&format
, '\n');
1413 strbuf_addstr(&format
, implicit_ident_advice());
1416 strbuf_release(&author_ident
);
1417 strbuf_release(&committer_ident
);
1419 init_revisions(&rev
, prefix
);
1420 setup_revisions(0, NULL
, &rev
, NULL
);
1423 rev
.diffopt
.output_format
=
1424 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1426 rev
.verbose_header
= 1;
1427 rev
.show_root_diff
= 1;
1428 get_commit_format(format
.buf
, &rev
);
1429 rev
.always_show_header
= 0;
1430 rev
.diffopt
.detect_rename
= 1;
1431 rev
.diffopt
.break_opt
= 0;
1432 diff_setup_done(&rev
.diffopt
);
1434 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1436 die_errno(_("unable to resolve HEAD after creating commit"));
1437 if (!strcmp(head
, "HEAD"))
1438 head
= _("detached HEAD");
1440 skip_prefix(head
, "refs/heads/", &head
);
1441 printf("[%s%s ", head
, initial_commit
? _(" (root-commit)") : "");
1443 if (!log_tree_commit(&rev
, commit
)) {
1444 rev
.always_show_header
= 1;
1445 rev
.use_terminator
= 1;
1446 log_tree_commit(&rev
, commit
);
1449 strbuf_release(&format
);
1452 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1454 struct wt_status
*s
= cb
;
1457 if (!strcmp(k
, "commit.template"))
1458 return git_config_pathname(&template_file
, k
, v
);
1459 if (!strcmp(k
, "commit.status")) {
1460 include_status
= git_config_bool(k
, v
);
1463 if (!strcmp(k
, "commit.cleanup"))
1464 return git_config_string(&cleanup_arg
, k
, v
);
1465 if (!strcmp(k
, "commit.gpgsign")) {
1466 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
1469 if (!strcmp(k
, "commit.verbose")) {
1471 config_commit_verbose
= git_config_bool_or_int(k
, v
, &is_bool
);
1475 status
= git_gpg_config(k
, v
, NULL
);
1478 return git_status_config(k
, v
, s
);
1481 static int run_rewrite_hook(const struct object_id
*oldoid
,
1482 const struct object_id
*newoid
)
1484 struct child_process proc
= CHILD_PROCESS_INIT
;
1485 const char *argv
[3];
1487 struct strbuf sb
= STRBUF_INIT
;
1489 argv
[0] = find_hook("post-rewrite");
1498 proc
.stdout_to_stderr
= 1;
1500 code
= start_command(&proc
);
1503 strbuf_addf(&sb
, "%s %s\n", oid_to_hex(oldoid
), oid_to_hex(newoid
));
1504 sigchain_push(SIGPIPE
, SIG_IGN
);
1505 write_in_full(proc
.in
, sb
.buf
, sb
.len
);
1507 strbuf_release(&sb
);
1508 sigchain_pop(SIGPIPE
);
1509 return finish_command(&proc
);
1512 int run_commit_hook(int editor_is_used
, const char *index_file
, const char *name
, ...)
1514 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1518 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", index_file
);
1521 * Let the hook know that no editor will be launched.
1523 if (!editor_is_used
)
1524 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1526 va_start(args
, name
);
1527 ret
= run_hook_ve(hook_env
.argv
,name
, args
);
1529 argv_array_clear(&hook_env
);
1534 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1536 static struct wt_status s
;
1537 static struct option builtin_commit_options
[] = {
1538 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1539 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1541 OPT_GROUP(N_("Commit message options")),
1542 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1543 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1544 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1545 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1546 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1547 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1548 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1549 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1550 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1551 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1552 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1553 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1554 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1555 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1556 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key-id"),
1557 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1558 /* end commit message options */
1560 OPT_GROUP(N_("Commit contents options")),
1561 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1562 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1563 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1564 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1565 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1566 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit and commit-msg hooks")),
1567 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1568 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1569 STATUS_FORMAT_SHORT
),
1570 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1571 OPT_SET_INT(0, "porcelain", &status_format
,
1572 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1573 OPT_SET_INT(0, "long", &status_format
,
1574 N_("show status in long format (default)"),
1575 STATUS_FORMAT_LONG
),
1576 OPT_BOOL('z', "null", &s
.null_termination
,
1577 N_("terminate entries with NUL")),
1578 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1579 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1580 { 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" },
1581 /* end commit contents options */
1583 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1584 N_("ok to record an empty change")),
1585 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1586 N_("ok to record a change with an empty message")),
1591 struct strbuf sb
= STRBUF_INIT
;
1592 struct strbuf author_ident
= STRBUF_INIT
;
1593 const char *index_file
, *reflog_msg
;
1594 struct object_id oid
;
1595 struct commit_list
*parents
= NULL
;
1596 struct stat statbuf
;
1597 struct commit
*current_head
= NULL
;
1598 struct commit_extra_header
*extra
= NULL
;
1599 struct strbuf err
= STRBUF_INIT
;
1601 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1602 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1604 status_init_config(&s
, git_commit_config
);
1605 s
.commit_template
= 1;
1606 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1609 if (get_oid("HEAD", &oid
))
1610 current_head
= NULL
;
1612 current_head
= lookup_commit_or_die(&oid
, "HEAD");
1613 if (parse_commit(current_head
))
1614 die(_("could not parse HEAD commit"));
1616 verbose
= -1; /* unspecified */
1617 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1618 builtin_commit_usage
,
1619 prefix
, current_head
, &s
);
1621 verbose
= (config_commit_verbose
< 0) ? 0 : config_commit_verbose
;
1624 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1625 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1627 /* Set up everything for writing the commit object. This includes
1628 running hooks, writing the trees, and interacting with the user. */
1629 if (!prepare_to_commit(index_file
, prefix
,
1630 current_head
, &s
, &author_ident
)) {
1631 rollback_index_files();
1635 /* Determine parents */
1636 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1637 if (!current_head
) {
1639 reflog_msg
= "commit (initial)";
1642 reflog_msg
= "commit (amend)";
1643 parents
= copy_commit_list(current_head
->parents
);
1644 } else if (whence
== FROM_MERGE
) {
1645 struct strbuf m
= STRBUF_INIT
;
1647 int allow_fast_forward
= 1;
1648 struct commit_list
**pptr
= &parents
;
1651 reflog_msg
= "commit (merge)";
1652 pptr
= commit_list_append(current_head
, pptr
);
1653 fp
= xfopen(git_path_merge_head(), "r");
1654 while (strbuf_getline_lf(&m
, fp
) != EOF
) {
1655 struct commit
*parent
;
1657 parent
= get_merge_parent(m
.buf
);
1659 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1660 pptr
= commit_list_append(parent
, pptr
);
1664 if (!stat(git_path_merge_mode(), &statbuf
)) {
1665 if (strbuf_read_file(&sb
, git_path_merge_mode(), 0) < 0)
1666 die_errno(_("could not read MERGE_MODE"));
1667 if (!strcmp(sb
.buf
, "no-ff"))
1668 allow_fast_forward
= 0;
1670 if (allow_fast_forward
)
1671 parents
= reduce_heads(parents
);
1674 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1675 ? "commit (cherry-pick)"
1677 commit_list_insert(current_head
, &parents
);
1680 /* Finally, get the commit message */
1682 if (strbuf_read_file(&sb
, git_path_commit_editmsg(), 0) < 0) {
1683 int saved_errno
= errno
;
1684 rollback_index_files();
1685 die(_("could not read commit message: %s"), strerror(saved_errno
));
1688 if (verbose
|| /* Truncate the message just before the diff, if any. */
1689 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1690 strbuf_setlen(&sb
, wt_status_locate_end(sb
.buf
, sb
.len
));
1691 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1692 strbuf_stripspace(&sb
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1694 if (message_is_empty(&sb
, cleanup_mode
) && !allow_empty_message
) {
1695 rollback_index_files();
1696 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1699 if (template_untouched(&sb
, template_file
, cleanup_mode
) && !allow_empty_message
) {
1700 rollback_index_files();
1701 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1706 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1707 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1709 struct commit_extra_header
**tail
= &extra
;
1710 append_merge_tag_headers(parents
, &tail
);
1713 if (commit_tree_extended(sb
.buf
, sb
.len
, active_cache_tree
->oid
.hash
,
1714 parents
, oid
.hash
, author_ident
.buf
, sign_commit
, extra
)) {
1715 rollback_index_files();
1716 die(_("failed to write commit object"));
1718 strbuf_release(&author_ident
);
1719 free_commit_extra_headers(extra
);
1721 if (update_head_with_reflog(current_head
, &oid
, reflog_msg
, &sb
,
1723 rollback_index_files();
1727 unlink(git_path_cherry_pick_head());
1728 unlink(git_path_revert_head());
1729 unlink(git_path_merge_head());
1730 unlink(git_path_merge_msg());
1731 unlink(git_path_merge_mode());
1732 unlink(git_path_squash_msg());
1734 if (commit_index_files())
1735 die (_("Repository has been updated, but unable to write\n"
1736 "new_index file. Check that disk is not full and quota is\n"
1737 "not exceeded, and then \"git reset HEAD\" to recover."));
1740 run_commit_hook(use_editor
, get_index_file(), "post-commit", NULL
);
1741 if (amend
&& !no_post_rewrite
) {
1742 struct notes_rewrite_cfg
*cfg
;
1743 cfg
= init_copy_notes_for_rewrite("amend");
1745 /* we are amending, so current_head is not NULL */
1746 copy_note_for_rewrite(cfg
, ¤t_head
->object
.oid
, &oid
);
1747 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1749 run_rewrite_hook(¤t_head
->object
.oid
, &oid
);
1752 print_summary(prefix
, &oid
, !current_head
);