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"
36 static const char * const builtin_commit_usage
[] = {
37 N_("git commit [<options>] [--] <pathspec>..."),
41 static const char * const builtin_status_usage
[] = {
42 N_("git status [<options>] [--] <pathspec>..."),
46 static const char implicit_ident_advice_noconfig
[] =
47 N_("Your name and email address were configured automatically based\n"
48 "on your username and hostname. Please check that they are accurate.\n"
49 "You can suppress this message by setting them explicitly. Run the\n"
50 "following command and follow the instructions in your editor to edit\n"
51 "your configuration file:\n"
53 " git config --global --edit\n"
55 "After doing this, you may fix the identity used for this commit with:\n"
57 " git commit --amend --reset-author\n");
59 static const char implicit_ident_advice_config
[] =
60 N_("Your name and email address were configured automatically based\n"
61 "on your username and hostname. Please check that they are accurate.\n"
62 "You can suppress this message by setting them explicitly:\n"
64 " git config --global user.name \"Your Name\"\n"
65 " git config --global user.email you@example.com\n"
67 "After doing this, you may fix the identity used for this commit with:\n"
69 " git commit --amend --reset-author\n");
71 static const char empty_amend_advice
[] =
72 N_("You asked to amend the most recent commit, but doing so would make\n"
73 "it empty. You can repeat your command with --allow-empty, or you can\n"
74 "remove the commit entirely with \"git reset HEAD^\".\n");
76 static const char empty_cherry_pick_advice
[] =
77 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
78 "If you wish to commit it anyway, use:\n"
80 " git commit --allow-empty\n"
83 static const char empty_cherry_pick_advice_single
[] =
84 N_("Otherwise, please use 'git reset'\n");
86 static const char empty_cherry_pick_advice_multi
[] =
87 N_("If you wish to skip this commit, use:\n"
91 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
92 "the remaining commits.\n");
94 static GIT_PATH_FUNC(git_path_commit_editmsg
, "COMMIT_EDITMSG")
96 static const char *use_message_buffer
;
97 static struct lock_file index_lock
; /* real index */
98 static struct lock_file false_lock
; /* used only for partial commits */
105 static const char *logfile
, *force_author
;
106 static const char *template_file
;
108 * The _message variables are commit names from which to take
109 * the commit message and/or authorship.
111 static const char *author_message
, *author_message_buffer
;
112 static char *edit_message
, *use_message
;
113 static char *fixup_message
, *squash_message
;
114 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
115 static int edit_flag
= -1; /* unspecified */
116 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
117 static int config_commit_verbose
= -1; /* unspecified */
118 static int no_post_rewrite
, allow_empty_message
;
119 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
120 static char *sign_commit
;
123 * The default commit message cleanup mode will remove the lines
124 * beginning with # (shell comments) and leading and trailing
125 * whitespaces (empty lines or containing only whitespaces)
126 * if editor is used, and only the whitespaces if the message
127 * is specified explicitly.
129 static enum commit_msg_cleanup_mode cleanup_mode
;
130 static const char *cleanup_arg
;
132 static enum commit_whence whence
;
133 static int sequencer_in_use
;
134 static int use_editor
= 1, include_status
= 1;
135 static int show_ignored_in_status
, have_option_m
;
136 static struct strbuf message
= STRBUF_INIT
;
138 static enum wt_status_format status_format
= STATUS_FORMAT_UNSPECIFIED
;
140 static int opt_parse_porcelain(const struct option
*opt
, const char *arg
, int unset
)
142 enum wt_status_format
*value
= (enum wt_status_format
*)opt
->value
;
144 *value
= STATUS_FORMAT_NONE
;
146 *value
= STATUS_FORMAT_PORCELAIN
;
147 else if (!strcmp(arg
, "v1") || !strcmp(arg
, "1"))
148 *value
= STATUS_FORMAT_PORCELAIN
;
149 else if (!strcmp(arg
, "v2") || !strcmp(arg
, "2"))
150 *value
= STATUS_FORMAT_PORCELAIN_V2
;
152 die("unsupported porcelain version '%s'", arg
);
157 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
159 struct strbuf
*buf
= opt
->value
;
162 strbuf_setlen(buf
, 0);
166 strbuf_addch(buf
, '\n');
167 strbuf_addstr(buf
, arg
);
168 strbuf_complete_line(buf
);
173 static void determine_whence(struct wt_status
*s
)
175 if (file_exists(git_path_merge_head()))
177 else if (file_exists(git_path_cherry_pick_head())) {
178 whence
= FROM_CHERRY_PICK
;
179 if (file_exists(git_path_seq_dir()))
180 sequencer_in_use
= 1;
183 whence
= FROM_COMMIT
;
188 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
190 wt_status_prepare(s
);
193 init_diff_ui_defaults();
194 s
->hints
= advice_status_hints
; /* must come after git_config() */
197 static void rollback_index_files(void)
199 switch (commit_style
) {
201 break; /* nothing to do */
203 rollback_lock_file(&index_lock
);
206 rollback_lock_file(&index_lock
);
207 rollback_lock_file(&false_lock
);
212 static int commit_index_files(void)
216 switch (commit_style
) {
218 break; /* nothing to do */
220 err
= commit_lock_file(&index_lock
);
223 err
= commit_lock_file(&index_lock
);
224 rollback_lock_file(&false_lock
);
232 * Take a union of paths in the index and the named tree (typically, "HEAD"),
233 * and return the paths that match the given pattern in list.
235 static int list_paths(struct string_list
*list
, const char *with_tree
,
236 const char *prefix
, const struct pathspec
*pattern
)
244 m
= xcalloc(1, pattern
->nr
);
247 char *max_prefix
= common_prefix(pattern
);
248 overlay_tree_on_index(&the_index
, with_tree
,
249 max_prefix
? max_prefix
: prefix
);
253 for (i
= 0; i
< active_nr
; i
++) {
254 const struct cache_entry
*ce
= active_cache
[i
];
255 struct string_list_item
*item
;
257 if (ce
->ce_flags
& CE_UPDATE
)
259 if (!ce_path_match(ce
, pattern
, m
))
261 item
= string_list_insert(list
, ce
->name
);
262 if (ce_skip_worktree(ce
))
263 item
->util
= item
; /* better a valid pointer than a fake one */
266 ret
= report_path_error(m
, pattern
, prefix
);
271 static void add_remove_files(struct string_list
*list
)
274 for (i
= 0; i
< list
->nr
; i
++) {
276 struct string_list_item
*p
= &(list
->items
[i
]);
278 /* p->util is skip-worktree */
282 if (!lstat(p
->string
, &st
)) {
283 if (add_to_cache(p
->string
, &st
, 0))
284 die(_("updating files failed"));
286 remove_file_from_cache(p
->string
);
290 static void create_base_index(const struct commit
*current_head
)
293 struct unpack_trees_options opts
;
301 memset(&opts
, 0, sizeof(opts
));
305 opts
.src_index
= &the_index
;
306 opts
.dst_index
= &the_index
;
308 opts
.fn
= oneway_merge
;
309 tree
= parse_tree_indirect(¤t_head
->object
.oid
);
311 die(_("failed to unpack HEAD tree object"));
313 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
314 if (unpack_trees(1, &t
, &opts
))
315 exit(128); /* We've already reported the error, finish dying */
318 static void refresh_cache_or_die(int refresh_flags
)
321 * refresh_flags contains REFRESH_QUIET, so the only errors
322 * are for unmerged entries.
324 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
325 die_resolve_conflict("commit");
328 static const char *prepare_index(int argc
, const char **argv
, const char *prefix
,
329 const struct commit
*current_head
, int is_status
)
331 struct string_list partial
= STRING_LIST_INIT_DUP
;
332 struct pathspec pathspec
;
333 int refresh_flags
= REFRESH_QUIET
;
337 refresh_flags
|= REFRESH_UNMERGED
;
338 parse_pathspec(&pathspec
, 0,
339 PATHSPEC_PREFER_FULL
,
342 if (read_cache_preload(&pathspec
) < 0)
343 die(_("index file corrupt"));
346 char *old_index_env
= NULL
;
347 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
349 refresh_cache_or_die(refresh_flags
);
351 if (write_locked_index(&the_index
, &index_lock
, 0))
352 die(_("unable to create temporary index"));
354 old_index_env
= getenv(INDEX_ENVIRONMENT
);
355 setenv(INDEX_ENVIRONMENT
, get_lock_file_path(&index_lock
), 1);
357 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
358 die(_("interactive add failed"));
360 if (old_index_env
&& *old_index_env
)
361 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
363 unsetenv(INDEX_ENVIRONMENT
);
366 read_cache_from(get_lock_file_path(&index_lock
));
367 if (update_main_cache_tree(WRITE_TREE_SILENT
) == 0) {
368 if (reopen_lock_file(&index_lock
) < 0)
369 die(_("unable to write index file"));
370 if (write_locked_index(&the_index
, &index_lock
, 0))
371 die(_("unable to update temporary index"));
373 warning(_("Failed to update main cache tree"));
375 commit_style
= COMMIT_NORMAL
;
376 ret
= get_lock_file_path(&index_lock
);
381 * Non partial, non as-is commit.
383 * (1) get the real index;
384 * (2) update the_index as necessary;
385 * (3) write the_index out to the real index (still locked);
386 * (4) return the name of the locked index file.
388 * The caller should run hooks on the locked real index, and
389 * (A) if all goes well, commit the real index;
390 * (B) on failure, rollback the real index.
392 if (all
|| (also
&& pathspec
.nr
)) {
393 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
394 add_files_to_cache(also
? prefix
: NULL
, &pathspec
, 0);
395 refresh_cache_or_die(refresh_flags
);
396 update_main_cache_tree(WRITE_TREE_SILENT
);
397 if (write_locked_index(&the_index
, &index_lock
, 0))
398 die(_("unable to write new_index file"));
399 commit_style
= COMMIT_NORMAL
;
400 ret
= get_lock_file_path(&index_lock
);
407 * (1) return the name of the real index file.
409 * The caller should run hooks on the real index,
410 * and create commit from the_index.
411 * We still need to refresh the index here.
413 if (!only
&& !pathspec
.nr
) {
414 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
415 refresh_cache_or_die(refresh_flags
);
416 if (active_cache_changed
417 || !cache_tree_fully_valid(active_cache_tree
))
418 update_main_cache_tree(WRITE_TREE_SILENT
);
419 if (active_cache_changed
) {
420 if (write_locked_index(&the_index
, &index_lock
,
422 die(_("unable to write new_index file"));
424 rollback_lock_file(&index_lock
);
426 commit_style
= COMMIT_AS_IS
;
427 ret
= get_index_file();
434 * (0) find the set of affected paths;
435 * (1) get lock on the real index file;
436 * (2) update the_index with the given paths;
437 * (3) write the_index out to the real index (still locked);
438 * (4) get lock on the false index file;
439 * (5) reset the_index from HEAD;
440 * (6) update the_index the same way as (2);
441 * (7) write the_index out to the false index file;
442 * (8) return the name of the false index file (still locked);
444 * The caller should run hooks on the locked false index, and
445 * create commit from it. Then
446 * (A) if all goes well, commit the real index;
447 * (B) on failure, rollback the real index;
448 * In either case, rollback the false index.
450 commit_style
= COMMIT_PARTIAL
;
452 if (whence
!= FROM_COMMIT
) {
453 if (whence
== FROM_MERGE
)
454 die(_("cannot do a partial commit during a merge."));
455 else if (whence
== FROM_CHERRY_PICK
)
456 die(_("cannot do a partial commit during a cherry-pick."));
459 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, &pathspec
))
463 if (read_cache() < 0)
464 die(_("cannot read the index"));
466 hold_locked_index(&index_lock
, LOCK_DIE_ON_ERROR
);
467 add_remove_files(&partial
);
468 refresh_cache(REFRESH_QUIET
);
469 update_main_cache_tree(WRITE_TREE_SILENT
);
470 if (write_locked_index(&the_index
, &index_lock
, 0))
471 die(_("unable to write new_index file"));
473 hold_lock_file_for_update(&false_lock
,
474 git_path("next-index-%"PRIuMAX
,
475 (uintmax_t) getpid()),
478 create_base_index(current_head
);
479 add_remove_files(&partial
);
480 refresh_cache(REFRESH_QUIET
);
482 if (write_locked_index(&the_index
, &false_lock
, 0))
483 die(_("unable to write temporary index file"));
486 ret
= get_lock_file_path(&false_lock
);
487 read_cache_from(ret
);
489 string_list_clear(&partial
, 0);
490 clear_pathspec(&pathspec
);
494 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
497 struct object_id oid
;
499 if (s
->relative_paths
)
504 s
->reference
= "HEAD^1";
506 s
->verbose
= verbose
;
507 s
->index_file
= index_file
;
510 s
->is_initial
= get_oid(s
->reference
, &oid
) ? 1 : 0;
512 hashcpy(s
->sha1_commit
, oid
.hash
);
513 s
->status_format
= status_format
;
514 s
->ignore_submodule_arg
= ignore_submodule_arg
;
516 wt_status_collect(s
);
519 return s
->commitable
;
522 static int is_a_merge(const struct commit
*current_head
)
524 return !!(current_head
->parents
&& current_head
->parents
->next
);
527 static void assert_split_ident(struct ident_split
*id
, const struct strbuf
*buf
)
529 if (split_ident_line(id
, buf
->buf
, buf
->len
) || !id
->date_begin
)
530 die("BUG: unable to parse our own ident: %s", buf
->buf
);
533 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
535 struct strbuf buf
= STRBUF_INIT
;
537 strbuf_addch(&buf
, hack
);
538 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
539 setenv(var
, buf
.buf
, 1);
540 strbuf_release(&buf
);
543 static int parse_force_date(const char *in
, struct strbuf
*out
)
545 strbuf_addch(out
, '@');
547 if (parse_date(in
, out
) < 0) {
549 unsigned long t
= approxidate_careful(in
, &errors
);
552 strbuf_addf(out
, "%lu", t
);
558 static void set_ident_var(char **buf
, char *val
)
564 static void determine_author_info(struct strbuf
*author_ident
)
566 char *name
, *email
, *date
;
567 struct ident_split author
;
569 name
= xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
570 email
= xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
571 date
= xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
573 if (author_message
) {
574 struct ident_split ident
;
578 a
= find_commit_header(author_message_buffer
, "author", &len
);
580 die(_("commit '%s' lacks author header"), author_message
);
581 if (split_ident_line(&ident
, a
, len
) < 0)
582 die(_("commit '%s' has malformed author line"), author_message
);
584 set_ident_var(&name
, xmemdupz(ident
.name_begin
, ident
.name_end
- ident
.name_begin
));
585 set_ident_var(&email
, xmemdupz(ident
.mail_begin
, ident
.mail_end
- ident
.mail_begin
));
587 if (ident
.date_begin
) {
588 struct strbuf date_buf
= STRBUF_INIT
;
589 strbuf_addch(&date_buf
, '@');
590 strbuf_add(&date_buf
, ident
.date_begin
, ident
.date_end
- ident
.date_begin
);
591 strbuf_addch(&date_buf
, ' ');
592 strbuf_add(&date_buf
, ident
.tz_begin
, ident
.tz_end
- ident
.tz_begin
);
593 set_ident_var(&date
, strbuf_detach(&date_buf
, NULL
));
598 struct ident_split ident
;
600 if (split_ident_line(&ident
, force_author
, strlen(force_author
)) < 0)
601 die(_("malformed --author parameter"));
602 set_ident_var(&name
, xmemdupz(ident
.name_begin
, ident
.name_end
- ident
.name_begin
));
603 set_ident_var(&email
, xmemdupz(ident
.mail_begin
, ident
.mail_end
- ident
.mail_begin
));
607 struct strbuf date_buf
= STRBUF_INIT
;
608 if (parse_force_date(force_date
, &date_buf
))
609 die(_("invalid date format: %s"), force_date
);
610 set_ident_var(&date
, strbuf_detach(&date_buf
, NULL
));
613 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
614 assert_split_ident(&author
, author_ident
);
615 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
616 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
617 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
623 static int author_date_is_interesting(void)
625 return author_message
|| force_date
;
628 static void adjust_comment_line_char(const struct strbuf
*sb
)
630 char candidates
[] = "#;@!$%^&|:";
634 comment_line_char
= candidates
[0];
635 if (!memchr(sb
->buf
, comment_line_char
, sb
->len
))
639 candidate
= strchr(candidates
, *p
);
642 for (p
= sb
->buf
; *p
; p
++) {
643 if ((p
[0] == '\n' || p
[0] == '\r') && p
[1]) {
644 candidate
= strchr(candidates
, p
[1]);
650 for (p
= candidates
; *p
== ' '; p
++)
653 die(_("unable to select a comment character that is not used\n"
654 "in the current commit message"));
655 comment_line_char
= *p
;
658 static int prepare_to_commit(const char *index_file
, const char *prefix
,
659 struct commit
*current_head
,
661 struct strbuf
*author_ident
)
664 struct strbuf committer_ident
= STRBUF_INIT
;
666 struct strbuf sb
= STRBUF_INIT
;
667 const char *hook_arg1
= NULL
;
668 const char *hook_arg2
= NULL
;
669 int clean_message_contents
= (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
);
670 int old_display_comment_prefix
;
672 /* This checks and barfs if author is badly specified */
673 determine_author_info(author_ident
);
675 if (!no_verify
&& run_commit_hook(use_editor
, index_file
, "pre-commit", NULL
))
678 if (squash_message
) {
680 * Insert the proper subject line before other commit
681 * message options add their content.
683 if (use_message
&& !strcmp(use_message
, squash_message
))
684 strbuf_addstr(&sb
, "squash! ");
686 struct pretty_print_context ctx
= {0};
688 c
= lookup_commit_reference_by_name(squash_message
);
690 die(_("could not lookup commit %s"), squash_message
);
691 ctx
.output_encoding
= get_commit_output_encoding();
692 format_commit_message(c
, "squash! %s\n\n", &sb
,
698 strbuf_addbuf(&sb
, &message
);
699 hook_arg1
= "message";
700 } else if (logfile
&& !strcmp(logfile
, "-")) {
702 fprintf(stderr
, _("(reading log message from standard input)\n"));
703 if (strbuf_read(&sb
, 0, 0) < 0)
704 die_errno(_("could not read log from standard input"));
705 hook_arg1
= "message";
706 } else if (logfile
) {
707 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
708 die_errno(_("could not read log file '%s'"),
710 hook_arg1
= "message";
711 } else if (use_message
) {
713 buffer
= strstr(use_message_buffer
, "\n\n");
715 strbuf_addstr(&sb
, skip_blank_lines(buffer
+ 2));
716 hook_arg1
= "commit";
717 hook_arg2
= use_message
;
718 } else if (fixup_message
) {
719 struct pretty_print_context ctx
= {0};
720 struct commit
*commit
;
721 commit
= lookup_commit_reference_by_name(fixup_message
);
723 die(_("could not lookup commit %s"), fixup_message
);
724 ctx
.output_encoding
= get_commit_output_encoding();
725 format_commit_message(commit
, "fixup! %s\n\n",
727 hook_arg1
= "message";
728 } else if (!stat(git_path_merge_msg(), &statbuf
)) {
730 * prepend SQUASH_MSG here if it exists and a
731 * "merge --squash" was originally performed
733 if (!stat(git_path_squash_msg(), &statbuf
)) {
734 if (strbuf_read_file(&sb
, git_path_squash_msg(), 0) < 0)
735 die_errno(_("could not read SQUASH_MSG"));
736 hook_arg1
= "squash";
739 if (strbuf_read_file(&sb
, git_path_merge_msg(), 0) < 0)
740 die_errno(_("could not read MERGE_MSG"));
741 } else if (!stat(git_path_squash_msg(), &statbuf
)) {
742 if (strbuf_read_file(&sb
, git_path_squash_msg(), 0) < 0)
743 die_errno(_("could not read SQUASH_MSG"));
744 hook_arg1
= "squash";
745 } else if (template_file
) {
746 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
747 die_errno(_("could not read '%s'"), template_file
);
748 hook_arg1
= "template";
749 clean_message_contents
= 0;
753 * The remaining cases don't modify the template message, but
754 * just set the argument(s) to the prepare-commit-msg hook.
756 else if (whence
== FROM_MERGE
)
758 else if (whence
== FROM_CHERRY_PICK
) {
759 hook_arg1
= "commit";
760 hook_arg2
= "CHERRY_PICK_HEAD";
763 if (squash_message
) {
765 * If squash_commit was used for the commit subject,
766 * then we're possibly hijacking other commit log options.
767 * Reset the hook args to tell the real story.
769 hook_arg1
= "message";
773 s
->fp
= fopen_for_writing(git_path_commit_editmsg());
775 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
777 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
778 old_display_comment_prefix
= s
->display_comment_prefix
;
779 s
->display_comment_prefix
= 1;
782 * Most hints are counter-productive when the commit has
787 if (clean_message_contents
)
788 strbuf_stripspace(&sb
, 0);
791 append_signoff(&sb
, ignore_non_trailer(sb
.buf
, sb
.len
), 0);
793 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
794 die_errno(_("could not write commit template"));
796 if (auto_comment_line_char
)
797 adjust_comment_line_char(&sb
);
800 /* This checks if committer ident is explicitly given */
801 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
802 if (use_editor
&& include_status
) {
804 int saved_color_setting
;
805 struct ident_split ci
, ai
;
807 if (whence
!= FROM_COMMIT
) {
808 if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
809 wt_status_add_cut_line(s
->fp
);
810 status_printf_ln(s
, GIT_COLOR_NORMAL
,
813 "It looks like you may be committing a merge.\n"
814 "If this is not correct, please remove the file\n"
818 "It looks like you may be committing a cherry-pick.\n"
819 "If this is not correct, please remove the file\n"
822 whence
== FROM_MERGE
?
823 git_path_merge_head() :
824 git_path_cherry_pick_head());
827 fprintf(s
->fp
, "\n");
828 if (cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
)
829 status_printf(s
, GIT_COLOR_NORMAL
,
830 _("Please enter the commit message for your changes."
831 " Lines starting\nwith '%c' will be ignored, and an empty"
832 " message aborts the commit.\n"), comment_line_char
);
833 else if (cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
&&
834 whence
== FROM_COMMIT
)
835 wt_status_add_cut_line(s
->fp
);
836 else /* COMMIT_MSG_CLEANUP_SPACE, that is. */
837 status_printf(s
, GIT_COLOR_NORMAL
,
838 _("Please enter the commit message for your changes."
840 "with '%c' will be kept; you may remove them"
841 " yourself if you want to.\n"
842 "An empty message aborts the commit.\n"), comment_line_char
);
845 * These should never fail because they come from our own
846 * fmt_ident. They may fail the sane_ident test, but we know
847 * that the name and mail pointers will at least be valid,
848 * which is enough for our tests and printing here.
850 assert_split_ident(&ai
, author_ident
);
851 assert_split_ident(&ci
, &committer_ident
);
853 if (ident_cmp(&ai
, &ci
))
854 status_printf_ln(s
, GIT_COLOR_NORMAL
,
856 "Author: %.*s <%.*s>"),
857 ident_shown
++ ? "" : "\n",
858 (int)(ai
.name_end
- ai
.name_begin
), ai
.name_begin
,
859 (int)(ai
.mail_end
- ai
.mail_begin
), ai
.mail_begin
);
861 if (author_date_is_interesting())
862 status_printf_ln(s
, GIT_COLOR_NORMAL
,
865 ident_shown
++ ? "" : "\n",
866 show_ident_date(&ai
, DATE_MODE(NORMAL
)));
868 if (!committer_ident_sufficiently_given())
869 status_printf_ln(s
, GIT_COLOR_NORMAL
,
871 "Committer: %.*s <%.*s>"),
872 ident_shown
++ ? "" : "\n",
873 (int)(ci
.name_end
- ci
.name_begin
), ci
.name_begin
,
874 (int)(ci
.mail_end
- ci
.mail_begin
), ci
.mail_begin
);
876 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", ""); /* Add new line for clarity */
878 saved_color_setting
= s
->use_color
;
880 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
881 s
->use_color
= saved_color_setting
;
883 struct object_id oid
;
884 const char *parent
= "HEAD";
886 if (!active_nr
&& read_cache() < 0)
887 die(_("Cannot read index"));
892 if (get_oid(parent
, &oid
)) {
895 for (i
= 0; i
< active_nr
; i
++)
896 if (ce_intent_to_add(active_cache
[i
]))
898 commitable
= active_nr
- ita_nr
> 0;
901 * Unless the user did explicitly request a submodule
902 * ignore mode by passing a command line option we do
903 * not ignore any changed submodule SHA-1s when
904 * comparing index and parent, no matter what is
905 * configured. Otherwise we won't commit any
906 * submodules which were manually staged, which would
907 * be really confusing.
909 struct diff_flags flags
= DIFF_FLAGS_INIT
;
910 flags
.override_submodule_config
= 1;
911 if (ignore_submodule_arg
&&
912 !strcmp(ignore_submodule_arg
, "all"))
913 flags
.ignore_submodules
= 1;
914 commitable
= index_differs_from(parent
, &flags
, 1);
917 strbuf_release(&committer_ident
);
922 * Reject an attempt to record a non-merge empty commit without
923 * explicit --allow-empty. In the cherry-pick case, it may be
924 * empty due to conflict resolution, which the user should okay.
926 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
927 !(amend
&& is_a_merge(current_head
))) {
928 s
->display_comment_prefix
= old_display_comment_prefix
;
929 run_status(stdout
, index_file
, prefix
, 0, s
);
931 fputs(_(empty_amend_advice
), stderr
);
932 else if (whence
== FROM_CHERRY_PICK
) {
933 fputs(_(empty_cherry_pick_advice
), stderr
);
934 if (!sequencer_in_use
)
935 fputs(_(empty_cherry_pick_advice_single
), stderr
);
937 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
942 if (!no_verify
&& find_hook("pre-commit")) {
944 * Re-read the index as pre-commit hook could have updated it,
945 * and write it out as a tree. We must do this before we invoke
946 * the editor and after we invoke run_status above.
950 read_cache_from(index_file
);
952 if (update_main_cache_tree(0)) {
953 error(_("Error building trees"));
957 if (run_commit_hook(use_editor
, index_file
, "prepare-commit-msg",
958 git_path_commit_editmsg(), hook_arg1
, hook_arg2
, NULL
))
962 struct argv_array env
= ARGV_ARRAY_INIT
;
964 argv_array_pushf(&env
, "GIT_INDEX_FILE=%s", index_file
);
965 if (launch_editor(git_path_commit_editmsg(), NULL
, env
.argv
)) {
967 _("Please supply the message using either -m or -F option.\n"));
970 argv_array_clear(&env
);
974 run_commit_hook(use_editor
, index_file
, "commit-msg", git_path_commit_editmsg(), NULL
)) {
981 static const char *find_author_by_nickname(const char *name
)
983 struct rev_info revs
;
984 struct commit
*commit
;
985 struct strbuf buf
= STRBUF_INIT
;
986 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
990 init_revisions(&revs
, NULL
);
991 strbuf_addf(&buf
, "--author=%s", name
);
996 setup_revisions(ac
, av
, &revs
, NULL
);
997 revs
.mailmap
= &mailmap
;
998 read_mailmap(revs
.mailmap
, NULL
);
1000 if (prepare_revision_walk(&revs
))
1001 die(_("revision walk setup failed"));
1002 commit
= get_revision(&revs
);
1004 struct pretty_print_context ctx
= {0};
1005 ctx
.date_mode
.type
= DATE_NORMAL
;
1006 strbuf_release(&buf
);
1007 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
1008 clear_mailmap(&mailmap
);
1009 return strbuf_detach(&buf
, NULL
);
1011 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name
);
1015 static void handle_untracked_files_arg(struct wt_status
*s
)
1017 if (!untracked_files_arg
)
1018 ; /* default already initialized */
1019 else if (!strcmp(untracked_files_arg
, "no"))
1020 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1021 else if (!strcmp(untracked_files_arg
, "normal"))
1022 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1023 else if (!strcmp(untracked_files_arg
, "all"))
1024 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1026 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1029 static const char *read_commit_message(const char *name
)
1031 const char *out_enc
;
1032 struct commit
*commit
;
1034 commit
= lookup_commit_reference_by_name(name
);
1036 die(_("could not lookup commit %s"), name
);
1037 out_enc
= get_commit_output_encoding();
1038 return logmsg_reencode(commit
, NULL
, out_enc
);
1042 * Enumerate what needs to be propagated when --porcelain
1043 * is not in effect here.
1045 static struct status_deferred_config
{
1046 enum wt_status_format status_format
;
1048 } status_deferred_config
= {
1049 STATUS_FORMAT_UNSPECIFIED
,
1050 -1 /* unspecified */
1053 static void finalize_deferred_config(struct wt_status
*s
)
1055 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1056 status_format
!= STATUS_FORMAT_PORCELAIN_V2
&&
1057 !s
->null_termination
);
1059 if (s
->null_termination
) {
1060 if (status_format
== STATUS_FORMAT_NONE
||
1061 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1062 status_format
= STATUS_FORMAT_PORCELAIN
;
1063 else if (status_format
== STATUS_FORMAT_LONG
)
1064 die(_("--long and -z are incompatible"));
1067 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1068 status_format
= status_deferred_config
.status_format
;
1069 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1070 status_format
= STATUS_FORMAT_NONE
;
1072 if (use_deferred_config
&& s
->show_branch
< 0)
1073 s
->show_branch
= status_deferred_config
.show_branch
;
1074 if (s
->show_branch
< 0)
1078 static int parse_and_validate_options(int argc
, const char *argv
[],
1079 const struct option
*options
,
1080 const char * const usage
[],
1082 struct commit
*current_head
,
1083 struct wt_status
*s
)
1087 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1088 finalize_deferred_config(s
);
1090 if (force_author
&& !strchr(force_author
, '>'))
1091 force_author
= find_author_by_nickname(force_author
);
1093 if (force_author
&& renew_authorship
)
1094 die(_("Using both --reset-author and --author does not make sense"));
1096 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1099 use_editor
= edit_flag
;
1101 /* Sanity check options */
1102 if (amend
&& !current_head
)
1103 die(_("You have nothing to amend."));
1104 if (amend
&& whence
!= FROM_COMMIT
) {
1105 if (whence
== FROM_MERGE
)
1106 die(_("You are in the middle of a merge -- cannot amend."));
1107 else if (whence
== FROM_CHERRY_PICK
)
1108 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1110 if (fixup_message
&& squash_message
)
1111 die(_("Options --squash and --fixup cannot be used together"));
1121 die(_("Only one of -c/-C/-F/--fixup can be used."));
1122 if (have_option_m
&& f
> 0)
1123 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1124 if (f
|| have_option_m
)
1125 template_file
= NULL
;
1127 use_message
= edit_message
;
1128 if (amend
&& !use_message
&& !fixup_message
)
1129 use_message
= "HEAD";
1130 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1131 die(_("--reset-author can be used only with -C, -c or --amend."));
1133 use_message_buffer
= read_commit_message(use_message
);
1134 if (!renew_authorship
) {
1135 author_message
= use_message
;
1136 author_message_buffer
= use_message_buffer
;
1139 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1140 author_message
= "CHERRY_PICK_HEAD";
1141 author_message_buffer
= read_commit_message(author_message
);
1144 if (patch_interactive
)
1147 if (also
+ only
+ all
+ interactive
> 1)
1148 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1149 if (argc
== 0 && (also
|| (only
&& !amend
&& !allow_empty
)))
1150 die(_("No paths with --include/--only does not make sense."));
1151 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1152 cleanup_mode
= use_editor
? COMMIT_MSG_CLEANUP_ALL
:
1153 COMMIT_MSG_CLEANUP_SPACE
;
1154 else if (!strcmp(cleanup_arg
, "verbatim"))
1155 cleanup_mode
= COMMIT_MSG_CLEANUP_NONE
;
1156 else if (!strcmp(cleanup_arg
, "whitespace"))
1157 cleanup_mode
= COMMIT_MSG_CLEANUP_SPACE
;
1158 else if (!strcmp(cleanup_arg
, "strip"))
1159 cleanup_mode
= COMMIT_MSG_CLEANUP_ALL
;
1160 else if (!strcmp(cleanup_arg
, "scissors"))
1161 cleanup_mode
= use_editor
? COMMIT_MSG_CLEANUP_SCISSORS
:
1162 COMMIT_MSG_CLEANUP_SPACE
;
1164 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1166 handle_untracked_files_arg(s
);
1168 if (all
&& argc
> 0)
1169 die(_("Paths with -a does not make sense."));
1171 if (status_format
!= STATUS_FORMAT_NONE
)
1177 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1178 const struct commit
*current_head
, struct wt_status
*s
)
1181 const char *index_file
;
1183 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1184 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1185 rollback_index_files();
1187 return commitable
? 0 : 1;
1190 static int parse_status_slot(const char *slot
)
1192 if (!strcasecmp(slot
, "header"))
1193 return WT_STATUS_HEADER
;
1194 if (!strcasecmp(slot
, "branch"))
1195 return WT_STATUS_ONBRANCH
;
1196 if (!strcasecmp(slot
, "updated") || !strcasecmp(slot
, "added"))
1197 return WT_STATUS_UPDATED
;
1198 if (!strcasecmp(slot
, "changed"))
1199 return WT_STATUS_CHANGED
;
1200 if (!strcasecmp(slot
, "untracked"))
1201 return WT_STATUS_UNTRACKED
;
1202 if (!strcasecmp(slot
, "nobranch"))
1203 return WT_STATUS_NOBRANCH
;
1204 if (!strcasecmp(slot
, "unmerged"))
1205 return WT_STATUS_UNMERGED
;
1206 if (!strcasecmp(slot
, "localBranch"))
1207 return WT_STATUS_LOCAL_BRANCH
;
1208 if (!strcasecmp(slot
, "remoteBranch"))
1209 return WT_STATUS_REMOTE_BRANCH
;
1213 static int git_status_config(const char *k
, const char *v
, void *cb
)
1215 struct wt_status
*s
= cb
;
1216 const char *slot_name
;
1218 if (starts_with(k
, "column."))
1219 return git_column_config(k
, v
, "status", &s
->colopts
);
1220 if (!strcmp(k
, "status.submodulesummary")) {
1222 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1223 if (is_bool
&& s
->submodule_summary
)
1224 s
->submodule_summary
= -1;
1227 if (!strcmp(k
, "status.short")) {
1228 if (git_config_bool(k
, v
))
1229 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1231 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1234 if (!strcmp(k
, "status.branch")) {
1235 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1238 if (!strcmp(k
, "status.showstash")) {
1239 s
->show_stash
= git_config_bool(k
, v
);
1242 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1243 s
->use_color
= git_config_colorbool(k
, v
);
1246 if (!strcmp(k
, "status.displaycommentprefix")) {
1247 s
->display_comment_prefix
= git_config_bool(k
, v
);
1250 if (skip_prefix(k
, "status.color.", &slot_name
) ||
1251 skip_prefix(k
, "color.status.", &slot_name
)) {
1252 int slot
= parse_status_slot(slot_name
);
1256 return config_error_nonbool(k
);
1257 return color_parse(v
, s
->color_palette
[slot
]);
1259 if (!strcmp(k
, "status.relativepaths")) {
1260 s
->relative_paths
= git_config_bool(k
, v
);
1263 if (!strcmp(k
, "status.showuntrackedfiles")) {
1265 return config_error_nonbool(k
);
1266 else if (!strcmp(v
, "no"))
1267 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1268 else if (!strcmp(v
, "normal"))
1269 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1270 else if (!strcmp(v
, "all"))
1271 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1273 return error(_("Invalid untracked files mode '%s'"), v
);
1276 return git_diff_ui_config(k
, v
, NULL
);
1279 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1281 static struct wt_status s
;
1283 struct object_id oid
;
1284 static struct option builtin_status_options
[] = {
1285 OPT__VERBOSE(&verbose
, N_("be verbose")),
1286 OPT_SET_INT('s', "short", &status_format
,
1287 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1288 OPT_BOOL('b', "branch", &s
.show_branch
,
1289 N_("show branch information")),
1290 OPT_BOOL(0, "show-stash", &s
.show_stash
,
1291 N_("show stash information")),
1292 { OPTION_CALLBACK
, 0, "porcelain", &status_format
,
1293 N_("version"), N_("machine-readable output"),
1294 PARSE_OPT_OPTARG
, opt_parse_porcelain
},
1295 OPT_SET_INT(0, "long", &status_format
,
1296 N_("show status in long format (default)"),
1297 STATUS_FORMAT_LONG
),
1298 OPT_BOOL('z', "null", &s
.null_termination
,
1299 N_("terminate entries with NUL")),
1300 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1302 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1303 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1304 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1305 N_("show ignored files")),
1306 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1307 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1308 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1309 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1313 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1314 usage_with_options(builtin_status_usage
, builtin_status_options
);
1316 status_init_config(&s
, git_status_config
);
1317 argc
= parse_options(argc
, argv
, prefix
,
1318 builtin_status_options
,
1319 builtin_status_usage
, 0);
1320 finalize_colopts(&s
.colopts
, -1);
1321 finalize_deferred_config(&s
);
1323 handle_untracked_files_arg(&s
);
1324 if (show_ignored_in_status
)
1325 s
.show_ignored_files
= 1;
1326 parse_pathspec(&s
.pathspec
, 0,
1327 PATHSPEC_PREFER_FULL
,
1330 read_cache_preload(&s
.pathspec
);
1331 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1333 if (use_optional_locks())
1334 fd
= hold_locked_index(&index_lock
, 0);
1338 s
.is_initial
= get_oid(s
.reference
, &oid
) ? 1 : 0;
1340 hashcpy(s
.sha1_commit
, oid
.hash
);
1342 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1343 s
.status_format
= status_format
;
1344 s
.verbose
= verbose
;
1346 wt_status_collect(&s
);
1349 update_index_if_able(&the_index
, &index_lock
);
1351 if (s
.relative_paths
)
1354 wt_status_print(&s
);
1358 static const char *implicit_ident_advice(void)
1360 char *user_config
= expand_user_path("~/.gitconfig", 0);
1361 char *xdg_config
= xdg_config_home("config");
1362 int config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1368 return _(implicit_ident_advice_config
);
1370 return _(implicit_ident_advice_noconfig
);
1374 static void print_summary(const char *prefix
, const struct object_id
*oid
,
1377 struct rev_info rev
;
1378 struct commit
*commit
;
1379 struct strbuf format
= STRBUF_INIT
;
1381 struct pretty_print_context pctx
= {0};
1382 struct strbuf author_ident
= STRBUF_INIT
;
1383 struct strbuf committer_ident
= STRBUF_INIT
;
1385 commit
= lookup_commit(oid
);
1387 die(_("couldn't look up newly created commit"));
1388 if (parse_commit(commit
))
1389 die(_("could not parse newly created commit"));
1391 strbuf_addstr(&format
, "format:%h] %s");
1393 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1394 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1395 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1396 strbuf_addstr(&format
, "\n Author: ");
1397 strbuf_addbuf_percentquote(&format
, &author_ident
);
1399 if (author_date_is_interesting()) {
1400 struct strbuf date
= STRBUF_INIT
;
1401 format_commit_message(commit
, "%ad", &date
, &pctx
);
1402 strbuf_addstr(&format
, "\n Date: ");
1403 strbuf_addbuf_percentquote(&format
, &date
);
1404 strbuf_release(&date
);
1406 if (!committer_ident_sufficiently_given()) {
1407 strbuf_addstr(&format
, "\n Committer: ");
1408 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1409 if (advice_implicit_identity
) {
1410 strbuf_addch(&format
, '\n');
1411 strbuf_addstr(&format
, implicit_ident_advice());
1414 strbuf_release(&author_ident
);
1415 strbuf_release(&committer_ident
);
1417 init_revisions(&rev
, prefix
);
1418 setup_revisions(0, NULL
, &rev
, NULL
);
1421 rev
.diffopt
.output_format
=
1422 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1424 rev
.verbose_header
= 1;
1425 rev
.show_root_diff
= 1;
1426 get_commit_format(format
.buf
, &rev
);
1427 rev
.always_show_header
= 0;
1428 rev
.diffopt
.detect_rename
= 1;
1429 rev
.diffopt
.break_opt
= 0;
1430 diff_setup_done(&rev
.diffopt
);
1432 head
= resolve_ref_unsafe("HEAD", 0, NULL
, NULL
);
1434 die_errno(_("unable to resolve HEAD after creating commit"));
1435 if (!strcmp(head
, "HEAD"))
1436 head
= _("detached HEAD");
1438 skip_prefix(head
, "refs/heads/", &head
);
1439 printf("[%s%s ", head
, initial_commit
? _(" (root-commit)") : "");
1441 if (!log_tree_commit(&rev
, commit
)) {
1442 rev
.always_show_header
= 1;
1443 rev
.use_terminator
= 1;
1444 log_tree_commit(&rev
, commit
);
1447 strbuf_release(&format
);
1450 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1452 struct wt_status
*s
= cb
;
1455 if (!strcmp(k
, "commit.template"))
1456 return git_config_pathname(&template_file
, k
, v
);
1457 if (!strcmp(k
, "commit.status")) {
1458 include_status
= git_config_bool(k
, v
);
1461 if (!strcmp(k
, "commit.cleanup"))
1462 return git_config_string(&cleanup_arg
, k
, v
);
1463 if (!strcmp(k
, "commit.gpgsign")) {
1464 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
1467 if (!strcmp(k
, "commit.verbose")) {
1469 config_commit_verbose
= git_config_bool_or_int(k
, v
, &is_bool
);
1473 status
= git_gpg_config(k
, v
, NULL
);
1476 return git_status_config(k
, v
, s
);
1479 int run_commit_hook(int editor_is_used
, const char *index_file
, const char *name
, ...)
1481 struct argv_array hook_env
= ARGV_ARRAY_INIT
;
1485 argv_array_pushf(&hook_env
, "GIT_INDEX_FILE=%s", index_file
);
1488 * Let the hook know that no editor will be launched.
1490 if (!editor_is_used
)
1491 argv_array_push(&hook_env
, "GIT_EDITOR=:");
1493 va_start(args
, name
);
1494 ret
= run_hook_ve(hook_env
.argv
,name
, args
);
1496 argv_array_clear(&hook_env
);
1501 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1503 static struct wt_status s
;
1504 static struct option builtin_commit_options
[] = {
1505 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1506 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1508 OPT_GROUP(N_("Commit message options")),
1509 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1510 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1511 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1512 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1513 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1514 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1515 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1516 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1517 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1518 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1519 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1520 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1521 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1522 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1523 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key-id"),
1524 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1525 /* end commit message options */
1527 OPT_GROUP(N_("Commit contents options")),
1528 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1529 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1530 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1531 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1532 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1533 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit and commit-msg hooks")),
1534 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1535 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1536 STATUS_FORMAT_SHORT
),
1537 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1538 OPT_SET_INT(0, "porcelain", &status_format
,
1539 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1540 OPT_SET_INT(0, "long", &status_format
,
1541 N_("show status in long format (default)"),
1542 STATUS_FORMAT_LONG
),
1543 OPT_BOOL('z', "null", &s
.null_termination
,
1544 N_("terminate entries with NUL")),
1545 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1546 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1547 { 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" },
1548 /* end commit contents options */
1550 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1551 N_("ok to record an empty change")),
1552 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1553 N_("ok to record a change with an empty message")),
1558 struct strbuf sb
= STRBUF_INIT
;
1559 struct strbuf author_ident
= STRBUF_INIT
;
1560 const char *index_file
, *reflog_msg
;
1561 struct object_id oid
;
1562 struct commit_list
*parents
= NULL
;
1563 struct stat statbuf
;
1564 struct commit
*current_head
= NULL
;
1565 struct commit_extra_header
*extra
= NULL
;
1566 struct strbuf err
= STRBUF_INIT
;
1568 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1569 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1571 status_init_config(&s
, git_commit_config
);
1572 s
.commit_template
= 1;
1573 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1576 if (get_oid("HEAD", &oid
))
1577 current_head
= NULL
;
1579 current_head
= lookup_commit_or_die(&oid
, "HEAD");
1580 if (parse_commit(current_head
))
1581 die(_("could not parse HEAD commit"));
1583 verbose
= -1; /* unspecified */
1584 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1585 builtin_commit_usage
,
1586 prefix
, current_head
, &s
);
1588 verbose
= (config_commit_verbose
< 0) ? 0 : config_commit_verbose
;
1591 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1592 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1594 /* Set up everything for writing the commit object. This includes
1595 running hooks, writing the trees, and interacting with the user. */
1596 if (!prepare_to_commit(index_file
, prefix
,
1597 current_head
, &s
, &author_ident
)) {
1598 rollback_index_files();
1602 /* Determine parents */
1603 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1604 if (!current_head
) {
1606 reflog_msg
= "commit (initial)";
1609 reflog_msg
= "commit (amend)";
1610 parents
= copy_commit_list(current_head
->parents
);
1611 } else if (whence
== FROM_MERGE
) {
1612 struct strbuf m
= STRBUF_INIT
;
1614 int allow_fast_forward
= 1;
1615 struct commit_list
**pptr
= &parents
;
1618 reflog_msg
= "commit (merge)";
1619 pptr
= commit_list_append(current_head
, pptr
);
1620 fp
= xfopen(git_path_merge_head(), "r");
1621 while (strbuf_getline_lf(&m
, fp
) != EOF
) {
1622 struct commit
*parent
;
1624 parent
= get_merge_parent(m
.buf
);
1626 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1627 pptr
= commit_list_append(parent
, pptr
);
1631 if (!stat(git_path_merge_mode(), &statbuf
)) {
1632 if (strbuf_read_file(&sb
, git_path_merge_mode(), 0) < 0)
1633 die_errno(_("could not read MERGE_MODE"));
1634 if (!strcmp(sb
.buf
, "no-ff"))
1635 allow_fast_forward
= 0;
1637 if (allow_fast_forward
)
1638 parents
= reduce_heads(parents
);
1641 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1642 ? "commit (cherry-pick)"
1644 commit_list_insert(current_head
, &parents
);
1647 /* Finally, get the commit message */
1649 if (strbuf_read_file(&sb
, git_path_commit_editmsg(), 0) < 0) {
1650 int saved_errno
= errno
;
1651 rollback_index_files();
1652 die(_("could not read commit message: %s"), strerror(saved_errno
));
1655 if (verbose
|| /* Truncate the message just before the diff, if any. */
1656 cleanup_mode
== COMMIT_MSG_CLEANUP_SCISSORS
)
1657 strbuf_setlen(&sb
, wt_status_locate_end(sb
.buf
, sb
.len
));
1658 if (cleanup_mode
!= COMMIT_MSG_CLEANUP_NONE
)
1659 strbuf_stripspace(&sb
, cleanup_mode
== COMMIT_MSG_CLEANUP_ALL
);
1661 if (message_is_empty(&sb
, cleanup_mode
) && !allow_empty_message
) {
1662 rollback_index_files();
1663 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1666 if (template_untouched(&sb
, template_file
, cleanup_mode
) && !allow_empty_message
) {
1667 rollback_index_files();
1668 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1673 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1674 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1676 struct commit_extra_header
**tail
= &extra
;
1677 append_merge_tag_headers(parents
, &tail
);
1680 if (commit_tree_extended(sb
.buf
, sb
.len
, active_cache_tree
->oid
.hash
,
1681 parents
, oid
.hash
, author_ident
.buf
, sign_commit
, extra
)) {
1682 rollback_index_files();
1683 die(_("failed to write commit object"));
1685 strbuf_release(&author_ident
);
1686 free_commit_extra_headers(extra
);
1688 if (update_head_with_reflog(current_head
, &oid
, reflog_msg
, &sb
,
1690 rollback_index_files();
1694 unlink(git_path_cherry_pick_head());
1695 unlink(git_path_revert_head());
1696 unlink(git_path_merge_head());
1697 unlink(git_path_merge_msg());
1698 unlink(git_path_merge_mode());
1699 unlink(git_path_squash_msg());
1701 if (commit_index_files())
1702 die (_("Repository has been updated, but unable to write\n"
1703 "new_index file. Check that disk is not full and quota is\n"
1704 "not exceeded, and then \"git reset HEAD\" to recover."));
1707 run_commit_hook(use_editor
, get_index_file(), "post-commit", NULL
);
1708 if (amend
&& !no_post_rewrite
) {
1709 commit_post_rewrite(current_head
, &oid
);
1712 print_summary(prefix
, &oid
, !current_head
);