4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
9 #include "cache-tree.h"
17 #include "wt-status.h"
18 #include "run-command.h"
23 #include "parse-options.h"
24 #include "string-list.h"
26 #include "unpack-trees.h"
28 #include "submodule.h"
29 #include "gpg-interface.h"
31 #include "sequencer.h"
32 #include "notes-utils.h"
35 static const char * const builtin_commit_usage
[] = {
36 N_("git commit [options] [--] <pathspec>..."),
40 static const char * const builtin_status_usage
[] = {
41 N_("git status [options] [--] <pathspec>..."),
45 static const char implicit_ident_advice_noconfig
[] =
46 N_("Your name and email address were configured automatically based\n"
47 "on your username and hostname. Please check that they are accurate.\n"
48 "You can suppress this message by setting them explicitly. Run the\n"
49 "following command and follow the instructions in your editor to edit\n"
50 "your configuration file:\n"
52 " git config --global --edit\n"
54 "After doing this, you may fix the identity used for this commit with:\n"
56 " git commit --amend --reset-author\n");
58 static const char implicit_ident_advice_config
[] =
59 N_("Your name and email address were configured automatically based\n"
60 "on your username and hostname. Please check that they are accurate.\n"
61 "You can suppress this message by setting them explicitly:\n"
63 " git config --global user.name \"Your Name\"\n"
64 " git config --global user.email you@example.com\n"
66 "After doing this, you may fix the identity used for this commit with:\n"
68 " git commit --amend --reset-author\n");
70 static const char empty_amend_advice
[] =
71 N_("You asked to amend the most recent commit, but doing so would make\n"
72 "it empty. You can repeat your command with --allow-empty, or you can\n"
73 "remove the commit entirely with \"git reset HEAD^\".\n");
75 static const char empty_cherry_pick_advice
[] =
76 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
77 "If you wish to commit it anyway, use:\n"
79 " git commit --allow-empty\n"
82 static const char empty_cherry_pick_advice_single
[] =
83 N_("Otherwise, please use 'git reset'\n");
85 static const char empty_cherry_pick_advice_multi
[] =
86 N_("If you wish to skip this commit, use:\n"
90 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
91 "the remaining commits.\n");
93 static const char *use_message_buffer
;
94 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
95 static struct lock_file index_lock
; /* real index */
96 static struct lock_file false_lock
; /* used only for partial commits */
103 static const char *logfile
, *force_author
;
104 static const char *template_file
;
106 * The _message variables are commit names from which to take
107 * the commit message and/or authorship.
109 static const char *author_message
, *author_message_buffer
;
110 static char *edit_message
, *use_message
;
111 static char *fixup_message
, *squash_message
;
112 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
113 static int edit_flag
= -1; /* unspecified */
114 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
115 static int no_post_rewrite
, allow_empty_message
;
116 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
117 static char *sign_commit
;
120 * The default commit message cleanup mode will remove the lines
121 * beginning with # (shell comments) and leading and trailing
122 * whitespaces (empty lines or containing only whitespaces)
123 * if editor is used, and only the whitespaces if the message
124 * is specified explicitly.
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 const char *only_include_assumed
;
139 static struct strbuf message
= STRBUF_INIT
;
141 static enum status_format
{
142 STATUS_FORMAT_NONE
= 0,
145 STATUS_FORMAT_PORCELAIN
,
147 STATUS_FORMAT_UNSPECIFIED
148 } status_format
= STATUS_FORMAT_UNSPECIFIED
;
150 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
152 struct strbuf
*buf
= opt
->value
;
155 strbuf_setlen(buf
, 0);
159 strbuf_addch(buf
, '\n');
160 strbuf_addstr(buf
, arg
);
161 strbuf_complete_line(buf
);
166 static void determine_whence(struct wt_status
*s
)
168 if (file_exists(git_path("MERGE_HEAD")))
170 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
171 whence
= FROM_CHERRY_PICK
;
172 if (file_exists(git_path(SEQ_DIR
)))
173 sequencer_in_use
= 1;
176 whence
= FROM_COMMIT
;
181 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
183 wt_status_prepare(s
);
187 s
->hints
= advice_status_hints
; /* must come after git_config() */
190 static void rollback_index_files(void)
192 switch (commit_style
) {
194 break; /* nothing to do */
196 rollback_lock_file(&index_lock
);
199 rollback_lock_file(&index_lock
);
200 rollback_lock_file(&false_lock
);
205 static int commit_index_files(void)
209 switch (commit_style
) {
211 break; /* nothing to do */
213 err
= commit_lock_file(&index_lock
);
216 err
= commit_lock_file(&index_lock
);
217 rollback_lock_file(&false_lock
);
225 * Take a union of paths in the index and the named tree (typically, "HEAD"),
226 * and return the paths that match the given pattern in list.
228 static int list_paths(struct string_list
*list
, const char *with_tree
,
229 const char *prefix
, const struct pathspec
*pattern
)
237 m
= xcalloc(1, pattern
->nr
);
240 char *max_prefix
= common_prefix(pattern
);
241 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
245 for (i
= 0; i
< active_nr
; i
++) {
246 const struct cache_entry
*ce
= active_cache
[i
];
247 struct string_list_item
*item
;
249 if (ce
->ce_flags
& CE_UPDATE
)
251 if (!ce_path_match(ce
, pattern
, m
))
253 item
= string_list_insert(list
, ce
->name
);
254 if (ce_skip_worktree(ce
))
255 item
->util
= item
; /* better a valid pointer than a fake one */
258 return report_path_error(m
, pattern
, prefix
);
261 static void add_remove_files(struct string_list
*list
)
264 for (i
= 0; i
< list
->nr
; i
++) {
266 struct string_list_item
*p
= &(list
->items
[i
]);
268 /* p->util is skip-worktree */
272 if (!lstat(p
->string
, &st
)) {
273 if (add_to_cache(p
->string
, &st
, 0))
274 die(_("updating files failed"));
276 remove_file_from_cache(p
->string
);
280 static void create_base_index(const struct commit
*current_head
)
283 struct unpack_trees_options opts
;
291 memset(&opts
, 0, sizeof(opts
));
295 opts
.src_index
= &the_index
;
296 opts
.dst_index
= &the_index
;
298 opts
.fn
= oneway_merge
;
299 tree
= parse_tree_indirect(current_head
->object
.sha1
);
301 die(_("failed to unpack HEAD tree object"));
303 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
304 if (unpack_trees(1, &t
, &opts
))
305 exit(128); /* We've already reported the error, finish dying */
308 static void refresh_cache_or_die(int refresh_flags
)
311 * refresh_flags contains REFRESH_QUIET, so the only errors
312 * are for unmerged entries.
314 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
315 die_resolve_conflict("commit");
318 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
319 const struct commit
*current_head
, int is_status
)
321 struct string_list partial
;
322 struct pathspec pathspec
;
323 int refresh_flags
= REFRESH_QUIET
;
326 refresh_flags
|= REFRESH_UNMERGED
;
327 parse_pathspec(&pathspec
, 0,
328 PATHSPEC_PREFER_FULL
,
331 if (read_cache_preload(&pathspec
) < 0)
332 die(_("index file corrupt"));
335 char *old_index_env
= NULL
;
336 hold_locked_index(&index_lock
, 1);
338 refresh_cache_or_die(refresh_flags
);
340 if (write_locked_index(&the_index
, &index_lock
, CLOSE_LOCK
))
341 die(_("unable to create temporary index"));
343 old_index_env
= getenv(INDEX_ENVIRONMENT
);
344 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
346 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
347 die(_("interactive add failed"));
349 if (old_index_env
&& *old_index_env
)
350 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
352 unsetenv(INDEX_ENVIRONMENT
);
355 read_cache_from(index_lock
.filename
);
356 if (update_main_cache_tree(WRITE_TREE_SILENT
) == 0) {
357 if (reopen_lock_file(&index_lock
) < 0)
358 die(_("unable to write index file"));
359 if (write_locked_index(&the_index
, &index_lock
, CLOSE_LOCK
))
360 die(_("unable to update temporary index"));
362 warning(_("Failed to update main cache tree"));
364 commit_style
= COMMIT_NORMAL
;
365 return index_lock
.filename
;
369 * Non partial, non as-is commit.
371 * (1) get the real index;
372 * (2) update the_index as necessary;
373 * (3) write the_index out to the real index (still locked);
374 * (4) return the name of the locked index file.
376 * The caller should run hooks on the locked real index, and
377 * (A) if all goes well, commit the real index;
378 * (B) on failure, rollback the real index.
380 if (all
|| (also
&& pathspec
.nr
)) {
381 hold_locked_index(&index_lock
, 1);
382 add_files_to_cache(also
? prefix
: NULL
, &pathspec
, 0);
383 refresh_cache_or_die(refresh_flags
);
384 update_main_cache_tree(WRITE_TREE_SILENT
);
385 if (write_locked_index(&the_index
, &index_lock
, CLOSE_LOCK
))
386 die(_("unable to write new_index file"));
387 commit_style
= COMMIT_NORMAL
;
388 return index_lock
.filename
;
394 * (1) return the name of the real index file.
396 * The caller should run hooks on the real index,
397 * and create commit from the_index.
398 * We still need to refresh the index here.
400 if (!only
&& !pathspec
.nr
) {
401 hold_locked_index(&index_lock
, 1);
402 refresh_cache_or_die(refresh_flags
);
403 if (active_cache_changed
404 || !cache_tree_fully_valid(active_cache_tree
)) {
405 update_main_cache_tree(WRITE_TREE_SILENT
);
406 active_cache_changed
= 1;
408 if (active_cache_changed
) {
409 if (write_locked_index(&the_index
, &index_lock
,
411 die(_("unable to write new_index file"));
413 rollback_lock_file(&index_lock
);
415 commit_style
= COMMIT_AS_IS
;
416 return get_index_file();
422 * (0) find the set of affected paths;
423 * (1) get lock on the real index file;
424 * (2) update the_index with the given paths;
425 * (3) write the_index out to the real index (still locked);
426 * (4) get lock on the false index file;
427 * (5) reset the_index from HEAD;
428 * (6) update the_index the same way as (2);
429 * (7) write the_index out to the false index file;
430 * (8) return the name of the false index file (still locked);
432 * The caller should run hooks on the locked false index, and
433 * create commit from it. Then
434 * (A) if all goes well, commit the real index;
435 * (B) on failure, rollback the real index;
436 * In either case, rollback the false index.
438 commit_style
= COMMIT_PARTIAL
;
440 if (whence
!= FROM_COMMIT
) {
441 if (whence
== FROM_MERGE
)
442 die(_("cannot do a partial commit during a merge."));
443 else if (whence
== FROM_CHERRY_PICK
)
444 die(_("cannot do a partial commit during a cherry-pick."));
447 string_list_init(&partial
, 1);
448 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, &pathspec
))
452 if (read_cache() < 0)
453 die(_("cannot read the index"));
455 hold_locked_index(&index_lock
, 1);
456 add_remove_files(&partial
);
457 refresh_cache(REFRESH_QUIET
);
458 update_main_cache_tree(WRITE_TREE_SILENT
);
459 if (write_locked_index(&the_index
, &index_lock
, CLOSE_LOCK
))
460 die(_("unable to write new_index file"));
462 hold_lock_file_for_update(&false_lock
,
463 git_path("next-index-%"PRIuMAX
,
464 (uintmax_t) getpid()),
467 create_base_index(current_head
);
468 add_remove_files(&partial
);
469 refresh_cache(REFRESH_QUIET
);
471 if (write_locked_index(&the_index
, &false_lock
, CLOSE_LOCK
))
472 die(_("unable to write temporary index file"));
475 read_cache_from(false_lock
.filename
);
477 return false_lock
.filename
;
480 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
483 unsigned char sha1
[20];
485 if (s
->relative_paths
)
490 s
->reference
= "HEAD^1";
492 s
->verbose
= verbose
;
493 s
->index_file
= index_file
;
496 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
498 wt_status_collect(s
);
500 switch (status_format
) {
501 case STATUS_FORMAT_SHORT
:
502 wt_shortstatus_print(s
);
504 case STATUS_FORMAT_PORCELAIN
:
505 wt_porcelain_print(s
);
507 case STATUS_FORMAT_UNSPECIFIED
:
508 die("BUG: finalize_deferred_config() should have been called");
510 case STATUS_FORMAT_NONE
:
511 case STATUS_FORMAT_LONG
:
516 return s
->commitable
;
519 static int is_a_merge(const struct commit
*current_head
)
521 return !!(current_head
->parents
&& current_head
->parents
->next
);
524 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
526 struct strbuf buf
= STRBUF_INIT
;
528 strbuf_addch(&buf
, hack
);
529 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
530 setenv(var
, buf
.buf
, 1);
531 strbuf_release(&buf
);
534 static int sane_ident_split(struct ident_split
*person
)
536 if (!person
->name_begin
|| !person
->name_end
||
537 person
->name_begin
== person
->name_end
)
538 return 0; /* no human readable name */
539 if (!person
->mail_begin
|| !person
->mail_end
||
540 person
->mail_begin
== person
->mail_end
)
541 return 0; /* no usable mail */
542 if (!person
->date_begin
|| !person
->date_end
||
543 !person
->tz_begin
|| !person
->tz_end
)
548 static int parse_force_date(const char *in
, char *out
, int len
)
555 if (parse_date(in
, out
, len
) < 0) {
557 unsigned long t
= approxidate_careful(in
, &errors
);
560 snprintf(out
, len
, "%lu", t
);
566 static void determine_author_info(struct strbuf
*author_ident
)
568 char *name
, *email
, *date
;
569 struct ident_split author
;
572 name
= getenv("GIT_AUTHOR_NAME");
573 email
= getenv("GIT_AUTHOR_EMAIL");
574 date
= getenv("GIT_AUTHOR_DATE");
576 if (author_message
) {
577 const char *a
, *lb
, *rb
, *eol
;
580 a
= strstr(author_message_buffer
, "\nauthor ");
582 die(_("invalid commit: %s"), author_message
);
584 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
585 rb
= strchrnul(lb
, '>');
586 eol
= strchrnul(rb
, '\n');
587 if (!*lb
|| !*rb
|| !*eol
)
588 die(_("invalid commit: %s"), author_message
);
590 if (lb
== a
+ strlen("\nauthor "))
591 /* \nauthor <foo@example.com> */
592 name
= xcalloc(1, 1);
594 name
= xmemdupz(a
+ strlen("\nauthor "),
596 (a
+ strlen("\nauthor "))));
597 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
598 len
= eol
- (rb
+ strlen("> "));
599 date
= xmalloc(len
+ 2);
601 memcpy(date
+ 1, rb
+ strlen("> "), len
);
602 date
[len
+ 1] = '\0';
606 const char *lb
= strstr(force_author
, " <");
607 const char *rb
= strchr(force_author
, '>');
610 die(_("malformed --author parameter"));
611 name
= xstrndup(force_author
, lb
- force_author
);
612 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
616 if (parse_force_date(force_date
, date_buf
, sizeof(date_buf
)))
617 die(_("invalid date format: %s"), force_date
);
621 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
622 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
623 sane_ident_split(&author
)) {
624 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
625 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
626 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
630 static void split_ident_or_die(struct ident_split
*id
, const struct strbuf
*buf
)
632 if (split_ident_line(id
, buf
->buf
, buf
->len
) ||
633 !sane_ident_split(id
))
634 die(_("Malformed ident string: '%s'"), buf
->buf
);
637 static int author_date_is_interesting(void)
639 return author_message
|| force_date
;
642 static void adjust_comment_line_char(const struct strbuf
*sb
)
644 char candidates
[] = "#;@!$%^&|:";
648 comment_line_char
= candidates
[0];
649 if (!memchr(sb
->buf
, comment_line_char
, sb
->len
))
653 candidate
= strchr(candidates
, *p
);
656 for (p
= sb
->buf
; *p
; p
++) {
657 if ((p
[0] == '\n' || p
[0] == '\r') && p
[1]) {
658 candidate
= strchr(candidates
, p
[1]);
664 for (p
= candidates
; *p
== ' '; p
++)
667 die(_("unable to select a comment character that is not used\n"
668 "in the current commit message"));
669 comment_line_char
= *p
;
672 static int prepare_to_commit(const char *index_file
, const char *prefix
,
673 struct commit
*current_head
,
675 struct strbuf
*author_ident
)
678 struct strbuf committer_ident
= STRBUF_INIT
;
680 struct strbuf sb
= STRBUF_INIT
;
681 const char *hook_arg1
= NULL
;
682 const char *hook_arg2
= NULL
;
683 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
684 int old_display_comment_prefix
;
686 /* This checks and barfs if author is badly specified */
687 determine_author_info(author_ident
);
689 if (!no_verify
&& run_commit_hook(use_editor
, index_file
, "pre-commit", NULL
))
692 if (squash_message
) {
694 * Insert the proper subject line before other commit
695 * message options add their content.
697 if (use_message
&& !strcmp(use_message
, squash_message
))
698 strbuf_addstr(&sb
, "squash! ");
700 struct pretty_print_context ctx
= {0};
702 c
= lookup_commit_reference_by_name(squash_message
);
704 die(_("could not lookup commit %s"), squash_message
);
705 ctx
.output_encoding
= get_commit_output_encoding();
706 format_commit_message(c
, "squash! %s\n\n", &sb
,
712 strbuf_addbuf(&sb
, &message
);
713 hook_arg1
= "message";
714 } else if (logfile
&& !strcmp(logfile
, "-")) {
716 fprintf(stderr
, _("(reading log message from standard input)\n"));
717 if (strbuf_read(&sb
, 0, 0) < 0)
718 die_errno(_("could not read log from standard input"));
719 hook_arg1
= "message";
720 } else if (logfile
) {
721 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
722 die_errno(_("could not read log file '%s'"),
724 hook_arg1
= "message";
725 } else if (use_message
) {
727 buffer
= strstr(use_message_buffer
, "\n\n");
729 strbuf_addstr(&sb
, buffer
+ 2);
730 hook_arg1
= "commit";
731 hook_arg2
= use_message
;
732 } else if (fixup_message
) {
733 struct pretty_print_context ctx
= {0};
734 struct commit
*commit
;
735 commit
= lookup_commit_reference_by_name(fixup_message
);
737 die(_("could not lookup commit %s"), fixup_message
);
738 ctx
.output_encoding
= get_commit_output_encoding();
739 format_commit_message(commit
, "fixup! %s\n\n",
741 hook_arg1
= "message";
742 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
743 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
744 die_errno(_("could not read MERGE_MSG"));
746 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
747 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
748 die_errno(_("could not read SQUASH_MSG"));
749 hook_arg1
= "squash";
750 } else if (template_file
) {
751 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
752 die_errno(_("could not read '%s'"), template_file
);
753 hook_arg1
= "template";
754 clean_message_contents
= 0;
758 * The remaining cases don't modify the template message, but
759 * just set the argument(s) to the prepare-commit-msg hook.
761 else if (whence
== FROM_MERGE
)
763 else if (whence
== FROM_CHERRY_PICK
) {
764 hook_arg1
= "commit";
765 hook_arg2
= "CHERRY_PICK_HEAD";
768 if (squash_message
) {
770 * If squash_commit was used for the commit subject,
771 * then we're possibly hijacking other commit log options.
772 * Reset the hook args to tell the real story.
774 hook_arg1
= "message";
778 s
->fp
= fopen(git_path(commit_editmsg
), "w");
780 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
782 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
783 old_display_comment_prefix
= s
->display_comment_prefix
;
784 s
->display_comment_prefix
= 1;
787 * Most hints are counter-productive when the commit has
792 if (clean_message_contents
)
797 * See if we have a Conflicts: block at the end. If yes, count
798 * its size, so we can ignore it.
800 int ignore_footer
= 0;
801 int i
, eol
, previous
= 0;
804 for (i
= 0; i
< sb
.len
; i
++) {
805 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
810 if (starts_with(sb
.buf
+ previous
, "\nConflicts:\n")) {
811 ignore_footer
= sb
.len
- previous
;
819 append_signoff(&sb
, ignore_footer
, 0);
822 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
823 die_errno(_("could not write commit template"));
825 if (auto_comment_line_char
)
826 adjust_comment_line_char(&sb
);
829 /* This checks if committer ident is explicitly given */
830 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
831 if (use_editor
&& include_status
) {
833 int saved_color_setting
;
834 struct ident_split ci
, ai
;
836 if (whence
!= FROM_COMMIT
) {
837 if (cleanup_mode
== CLEANUP_SCISSORS
)
838 wt_status_add_cut_line(s
->fp
);
839 status_printf_ln(s
, GIT_COLOR_NORMAL
,
842 "It looks like you may be committing a merge.\n"
843 "If this is not correct, please remove the file\n"
847 "It looks like you may be committing a cherry-pick.\n"
848 "If this is not correct, please remove the file\n"
851 git_path(whence
== FROM_MERGE
853 : "CHERRY_PICK_HEAD"));
856 fprintf(s
->fp
, "\n");
857 if (cleanup_mode
== CLEANUP_ALL
)
858 status_printf(s
, GIT_COLOR_NORMAL
,
859 _("Please enter the commit message for your changes."
860 " Lines starting\nwith '%c' will be ignored, and an empty"
861 " message aborts the commit.\n"), comment_line_char
);
862 else if (cleanup_mode
== CLEANUP_SCISSORS
&& whence
== FROM_COMMIT
)
863 wt_status_add_cut_line(s
->fp
);
864 else /* CLEANUP_SPACE, that is. */
865 status_printf(s
, GIT_COLOR_NORMAL
,
866 _("Please enter the commit message for your changes."
868 "with '%c' will be kept; you may remove them"
869 " yourself if you want to.\n"
870 "An empty message aborts the commit.\n"), comment_line_char
);
871 if (only_include_assumed
)
872 status_printf_ln(s
, GIT_COLOR_NORMAL
,
873 "%s", only_include_assumed
);
875 split_ident_or_die(&ai
, author_ident
);
876 split_ident_or_die(&ci
, &committer_ident
);
878 if (ident_cmp(&ai
, &ci
))
879 status_printf_ln(s
, GIT_COLOR_NORMAL
,
881 "Author: %.*s <%.*s>"),
882 ident_shown
++ ? "" : "\n",
883 (int)(ai
.name_end
- ai
.name_begin
), ai
.name_begin
,
884 (int)(ai
.mail_end
- ai
.mail_begin
), ai
.mail_begin
);
886 if (author_date_is_interesting())
887 status_printf_ln(s
, GIT_COLOR_NORMAL
,
890 ident_shown
++ ? "" : "\n",
891 show_ident_date(&ai
, DATE_NORMAL
));
893 if (!committer_ident_sufficiently_given())
894 status_printf_ln(s
, GIT_COLOR_NORMAL
,
896 "Committer: %.*s <%.*s>"),
897 ident_shown
++ ? "" : "\n",
898 (int)(ci
.name_end
- ci
.name_begin
), ci
.name_begin
,
899 (int)(ci
.mail_end
- ci
.mail_begin
), ci
.mail_begin
);
902 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", "");
904 saved_color_setting
= s
->use_color
;
906 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
907 s
->use_color
= saved_color_setting
;
909 unsigned char sha1
[20];
910 const char *parent
= "HEAD";
912 if (!active_nr
&& read_cache() < 0)
913 die(_("Cannot read index"));
918 if (get_sha1(parent
, sha1
))
919 commitable
= !!active_nr
;
922 * Unless the user did explicitly request a submodule
923 * ignore mode by passing a command line option we do
924 * not ignore any changed submodule SHA-1s when
925 * comparing index and parent, no matter what is
926 * configured. Otherwise we won't commit any
927 * submodules which were manually staged, which would
928 * be really confusing.
930 int diff_flags
= DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG
;
931 if (ignore_submodule_arg
&&
932 !strcmp(ignore_submodule_arg
, "all"))
933 diff_flags
|= DIFF_OPT_IGNORE_SUBMODULES
;
934 commitable
= index_differs_from(parent
, diff_flags
);
937 strbuf_release(&committer_ident
);
942 * Reject an attempt to record a non-merge empty commit without
943 * explicit --allow-empty. In the cherry-pick case, it may be
944 * empty due to conflict resolution, which the user should okay.
946 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
947 !(amend
&& is_a_merge(current_head
))) {
948 s
->display_comment_prefix
= old_display_comment_prefix
;
949 run_status(stdout
, index_file
, prefix
, 0, s
);
951 fputs(_(empty_amend_advice
), stderr
);
952 else if (whence
== FROM_CHERRY_PICK
) {
953 fputs(_(empty_cherry_pick_advice
), stderr
);
954 if (!sequencer_in_use
)
955 fputs(_(empty_cherry_pick_advice_single
), stderr
);
957 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
963 * Re-read the index as pre-commit hook could have updated it,
964 * and write it out as a tree. We must do this before we invoke
965 * the editor and after we invoke run_status above.
968 read_cache_from(index_file
);
969 if (update_main_cache_tree(0)) {
970 error(_("Error building trees"));
974 if (run_commit_hook(use_editor
, index_file
, "prepare-commit-msg",
975 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
979 char index
[PATH_MAX
];
980 const char *env
[2] = { NULL
};
982 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
983 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
985 _("Please supply the message using either -m or -F option.\n"));
991 run_commit_hook(use_editor
, index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
998 static int rest_is_empty(struct strbuf
*sb
, int start
)
1003 /* Check if the rest is just whitespace and Signed-of-by's. */
1004 for (i
= start
; i
< sb
->len
; i
++) {
1005 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1011 if (strlen(sign_off_header
) <= eol
- i
&&
1012 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1017 if (!isspace(sb
->buf
[i
++]))
1025 * Find out if the message in the strbuf contains only whitespace and
1026 * Signed-off-by lines.
1028 static int message_is_empty(struct strbuf
*sb
)
1030 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
1032 return rest_is_empty(sb
, 0);
1036 * See if the user edited the message in the editor or left what
1037 * was in the template intact
1039 static int template_untouched(struct strbuf
*sb
)
1041 struct strbuf tmpl
= STRBUF_INIT
;
1044 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
1047 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1050 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
1051 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1053 strbuf_release(&tmpl
);
1054 return rest_is_empty(sb
, start
- sb
->buf
);
1057 static const char *find_author_by_nickname(const char *name
)
1059 struct rev_info revs
;
1060 struct commit
*commit
;
1061 struct strbuf buf
= STRBUF_INIT
;
1062 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
1066 init_revisions(&revs
, NULL
);
1067 strbuf_addf(&buf
, "--author=%s", name
);
1072 setup_revisions(ac
, av
, &revs
, NULL
);
1073 revs
.mailmap
= &mailmap
;
1074 read_mailmap(revs
.mailmap
, NULL
);
1076 if (prepare_revision_walk(&revs
))
1077 die(_("revision walk setup failed"));
1078 commit
= get_revision(&revs
);
1080 struct pretty_print_context ctx
= {0};
1081 ctx
.date_mode
= DATE_NORMAL
;
1082 strbuf_release(&buf
);
1083 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
1084 clear_mailmap(&mailmap
);
1085 return strbuf_detach(&buf
, NULL
);
1087 die(_("No existing author found with '%s'"), name
);
1091 static void handle_untracked_files_arg(struct wt_status
*s
)
1093 if (!untracked_files_arg
)
1094 ; /* default already initialized */
1095 else if (!strcmp(untracked_files_arg
, "no"))
1096 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1097 else if (!strcmp(untracked_files_arg
, "normal"))
1098 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1099 else if (!strcmp(untracked_files_arg
, "all"))
1100 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1102 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1105 static const char *read_commit_message(const char *name
)
1107 const char *out_enc
;
1108 struct commit
*commit
;
1110 commit
= lookup_commit_reference_by_name(name
);
1112 die(_("could not lookup commit %s"), name
);
1113 out_enc
= get_commit_output_encoding();
1114 return logmsg_reencode(commit
, NULL
, out_enc
);
1118 * Enumerate what needs to be propagated when --porcelain
1119 * is not in effect here.
1121 static struct status_deferred_config
{
1122 enum status_format status_format
;
1124 } status_deferred_config
= {
1125 STATUS_FORMAT_UNSPECIFIED
,
1126 -1 /* unspecified */
1129 static void finalize_deferred_config(struct wt_status
*s
)
1131 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1132 !s
->null_termination
);
1134 if (s
->null_termination
) {
1135 if (status_format
== STATUS_FORMAT_NONE
||
1136 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1137 status_format
= STATUS_FORMAT_PORCELAIN
;
1138 else if (status_format
== STATUS_FORMAT_LONG
)
1139 die(_("--long and -z are incompatible"));
1142 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1143 status_format
= status_deferred_config
.status_format
;
1144 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1145 status_format
= STATUS_FORMAT_NONE
;
1147 if (use_deferred_config
&& s
->show_branch
< 0)
1148 s
->show_branch
= status_deferred_config
.show_branch
;
1149 if (s
->show_branch
< 0)
1153 static int parse_and_validate_options(int argc
, const char *argv
[],
1154 const struct option
*options
,
1155 const char * const usage
[],
1157 struct commit
*current_head
,
1158 struct wt_status
*s
)
1162 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1163 finalize_deferred_config(s
);
1165 if (force_author
&& !strchr(force_author
, '>'))
1166 force_author
= find_author_by_nickname(force_author
);
1168 if (force_author
&& renew_authorship
)
1169 die(_("Using both --reset-author and --author does not make sense"));
1171 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1174 use_editor
= edit_flag
;
1176 /* Sanity check options */
1177 if (amend
&& !current_head
)
1178 die(_("You have nothing to amend."));
1179 if (amend
&& whence
!= FROM_COMMIT
) {
1180 if (whence
== FROM_MERGE
)
1181 die(_("You are in the middle of a merge -- cannot amend."));
1182 else if (whence
== FROM_CHERRY_PICK
)
1183 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1185 if (fixup_message
&& squash_message
)
1186 die(_("Options --squash and --fixup cannot be used together"));
1196 die(_("Only one of -c/-C/-F/--fixup can be used."));
1197 if (message
.len
&& f
> 0)
1198 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1199 if (f
|| message
.len
)
1200 template_file
= NULL
;
1202 use_message
= edit_message
;
1203 if (amend
&& !use_message
&& !fixup_message
)
1204 use_message
= "HEAD";
1205 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1206 die(_("--reset-author can be used only with -C, -c or --amend."));
1208 use_message_buffer
= read_commit_message(use_message
);
1209 if (!renew_authorship
) {
1210 author_message
= use_message
;
1211 author_message_buffer
= use_message_buffer
;
1214 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1215 author_message
= "CHERRY_PICK_HEAD";
1216 author_message_buffer
= read_commit_message(author_message
);
1219 if (patch_interactive
)
1222 if (also
+ only
+ all
+ interactive
> 1)
1223 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1224 if (argc
== 0 && (also
|| (only
&& !amend
)))
1225 die(_("No paths with --include/--only does not make sense."));
1226 if (argc
== 0 && only
&& amend
)
1227 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1228 if (argc
> 0 && !also
&& !only
)
1229 only_include_assumed
= _("Explicit paths specified without -i or -o; assuming --only paths...");
1230 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1231 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1232 else if (!strcmp(cleanup_arg
, "verbatim"))
1233 cleanup_mode
= CLEANUP_NONE
;
1234 else if (!strcmp(cleanup_arg
, "whitespace"))
1235 cleanup_mode
= CLEANUP_SPACE
;
1236 else if (!strcmp(cleanup_arg
, "strip"))
1237 cleanup_mode
= CLEANUP_ALL
;
1238 else if (!strcmp(cleanup_arg
, "scissors"))
1239 cleanup_mode
= use_editor
? CLEANUP_SCISSORS
: CLEANUP_SPACE
;
1241 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1243 handle_untracked_files_arg(s
);
1245 if (all
&& argc
> 0)
1246 die(_("Paths with -a does not make sense."));
1248 if (status_format
!= STATUS_FORMAT_NONE
)
1254 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1255 const struct commit
*current_head
, struct wt_status
*s
)
1258 const char *index_file
;
1260 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1261 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1262 rollback_index_files();
1264 return commitable
? 0 : 1;
1267 static int parse_status_slot(const char *var
, int offset
)
1269 if (!strcasecmp(var
+offset
, "header"))
1270 return WT_STATUS_HEADER
;
1271 if (!strcasecmp(var
+offset
, "branch"))
1272 return WT_STATUS_ONBRANCH
;
1273 if (!strcasecmp(var
+offset
, "updated")
1274 || !strcasecmp(var
+offset
, "added"))
1275 return WT_STATUS_UPDATED
;
1276 if (!strcasecmp(var
+offset
, "changed"))
1277 return WT_STATUS_CHANGED
;
1278 if (!strcasecmp(var
+offset
, "untracked"))
1279 return WT_STATUS_UNTRACKED
;
1280 if (!strcasecmp(var
+offset
, "nobranch"))
1281 return WT_STATUS_NOBRANCH
;
1282 if (!strcasecmp(var
+offset
, "unmerged"))
1283 return WT_STATUS_UNMERGED
;
1287 static int git_status_config(const char *k
, const char *v
, void *cb
)
1289 struct wt_status
*s
= cb
;
1291 if (starts_with(k
, "column."))
1292 return git_column_config(k
, v
, "status", &s
->colopts
);
1293 if (!strcmp(k
, "status.submodulesummary")) {
1295 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1296 if (is_bool
&& s
->submodule_summary
)
1297 s
->submodule_summary
= -1;
1300 if (!strcmp(k
, "status.short")) {
1301 if (git_config_bool(k
, v
))
1302 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1304 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1307 if (!strcmp(k
, "status.branch")) {
1308 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1311 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1312 s
->use_color
= git_config_colorbool(k
, v
);
1315 if (!strcmp(k
, "status.displaycommentprefix")) {
1316 s
->display_comment_prefix
= git_config_bool(k
, v
);
1319 if (starts_with(k
, "status.color.") || starts_with(k
, "color.status.")) {
1320 int slot
= parse_status_slot(k
, 13);
1324 return config_error_nonbool(k
);
1325 color_parse(v
, k
, s
->color_palette
[slot
]);
1328 if (!strcmp(k
, "status.relativepaths")) {
1329 s
->relative_paths
= git_config_bool(k
, v
);
1332 if (!strcmp(k
, "status.showuntrackedfiles")) {
1334 return config_error_nonbool(k
);
1335 else if (!strcmp(v
, "no"))
1336 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1337 else if (!strcmp(v
, "normal"))
1338 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1339 else if (!strcmp(v
, "all"))
1340 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1342 return error(_("Invalid untracked files mode '%s'"), v
);
1345 return git_diff_ui_config(k
, v
, NULL
);
1348 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1350 static struct wt_status s
;
1352 unsigned char sha1
[20];
1353 static struct option builtin_status_options
[] = {
1354 OPT__VERBOSE(&verbose
, N_("be verbose")),
1355 OPT_SET_INT('s', "short", &status_format
,
1356 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1357 OPT_BOOL('b', "branch", &s
.show_branch
,
1358 N_("show branch information")),
1359 OPT_SET_INT(0, "porcelain", &status_format
,
1360 N_("machine-readable output"),
1361 STATUS_FORMAT_PORCELAIN
),
1362 OPT_SET_INT(0, "long", &status_format
,
1363 N_("show status in long format (default)"),
1364 STATUS_FORMAT_LONG
),
1365 OPT_BOOL('z', "null", &s
.null_termination
,
1366 N_("terminate entries with NUL")),
1367 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1369 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1370 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1371 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1372 N_("show ignored files")),
1373 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1374 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1375 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1376 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1380 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1381 usage_with_options(builtin_status_usage
, builtin_status_options
);
1383 status_init_config(&s
, git_status_config
);
1384 argc
= parse_options(argc
, argv
, prefix
,
1385 builtin_status_options
,
1386 builtin_status_usage
, 0);
1387 finalize_colopts(&s
.colopts
, -1);
1388 finalize_deferred_config(&s
);
1390 handle_untracked_files_arg(&s
);
1391 if (show_ignored_in_status
)
1392 s
.show_ignored_files
= 1;
1393 parse_pathspec(&s
.pathspec
, 0,
1394 PATHSPEC_PREFER_FULL
,
1397 read_cache_preload(&s
.pathspec
);
1398 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1400 fd
= hold_locked_index(&index_lock
, 0);
1402 update_index_if_able(&the_index
, &index_lock
);
1404 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1405 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1406 wt_status_collect(&s
);
1408 if (s
.relative_paths
)
1411 switch (status_format
) {
1412 case STATUS_FORMAT_SHORT
:
1413 wt_shortstatus_print(&s
);
1415 case STATUS_FORMAT_PORCELAIN
:
1416 wt_porcelain_print(&s
);
1418 case STATUS_FORMAT_UNSPECIFIED
:
1419 die("BUG: finalize_deferred_config() should have been called");
1421 case STATUS_FORMAT_NONE
:
1422 case STATUS_FORMAT_LONG
:
1423 s
.verbose
= verbose
;
1424 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1425 wt_status_print(&s
);
1431 static const char *implicit_ident_advice(void)
1433 char *user_config
= NULL
;
1434 char *xdg_config
= NULL
;
1437 home_config_paths(&user_config
, &xdg_config
, "config");
1438 config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1443 return _(implicit_ident_advice_config
);
1445 return _(implicit_ident_advice_noconfig
);
1449 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1452 struct rev_info rev
;
1453 struct commit
*commit
;
1454 struct strbuf format
= STRBUF_INIT
;
1455 unsigned char junk_sha1
[20];
1457 struct pretty_print_context pctx
= {0};
1458 struct strbuf author_ident
= STRBUF_INIT
;
1459 struct strbuf committer_ident
= STRBUF_INIT
;
1461 commit
= lookup_commit(sha1
);
1463 die(_("couldn't look up newly created commit"));
1464 if (parse_commit(commit
))
1465 die(_("could not parse newly created commit"));
1467 strbuf_addstr(&format
, "format:%h] %s");
1469 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1470 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1471 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1472 strbuf_addstr(&format
, "\n Author: ");
1473 strbuf_addbuf_percentquote(&format
, &author_ident
);
1475 if (author_date_is_interesting()) {
1476 struct strbuf date
= STRBUF_INIT
;
1477 format_commit_message(commit
, "%ad", &date
, &pctx
);
1478 strbuf_addstr(&format
, "\n Date: ");
1479 strbuf_addbuf_percentquote(&format
, &date
);
1480 strbuf_release(&date
);
1482 if (!committer_ident_sufficiently_given()) {
1483 strbuf_addstr(&format
, "\n Committer: ");
1484 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1485 if (advice_implicit_identity
) {
1486 strbuf_addch(&format
, '\n');
1487 strbuf_addstr(&format
, implicit_ident_advice());
1490 strbuf_release(&author_ident
);
1491 strbuf_release(&committer_ident
);
1493 init_revisions(&rev
, prefix
);
1494 setup_revisions(0, NULL
, &rev
, NULL
);
1497 rev
.diffopt
.output_format
=
1498 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1500 rev
.verbose_header
= 1;
1501 rev
.show_root_diff
= 1;
1502 get_commit_format(format
.buf
, &rev
);
1503 rev
.always_show_header
= 0;
1504 rev
.diffopt
.detect_rename
= 1;
1505 rev
.diffopt
.break_opt
= 0;
1506 diff_setup_done(&rev
.diffopt
);
1508 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1510 starts_with(head
, "refs/heads/") ?
1512 !strcmp(head
, "HEAD") ?
1513 _("detached HEAD") :
1515 initial_commit
? _(" (root-commit)") : "");
1517 if (!log_tree_commit(&rev
, commit
)) {
1518 rev
.always_show_header
= 1;
1519 rev
.use_terminator
= 1;
1520 log_tree_commit(&rev
, commit
);
1523 strbuf_release(&format
);
1526 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1528 struct wt_status
*s
= cb
;
1531 if (!strcmp(k
, "commit.template"))
1532 return git_config_pathname(&template_file
, k
, v
);
1533 if (!strcmp(k
, "commit.status")) {
1534 include_status
= git_config_bool(k
, v
);
1537 if (!strcmp(k
, "commit.cleanup"))
1538 return git_config_string(&cleanup_arg
, k
, v
);
1539 if (!strcmp(k
, "commit.gpgsign")) {
1540 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
1544 status
= git_gpg_config(k
, v
, NULL
);
1547 return git_status_config(k
, v
, s
);
1550 static int run_rewrite_hook(const unsigned char *oldsha1
,
1551 const unsigned char *newsha1
)
1553 /* oldsha1 SP newsha1 LF NUL */
1554 static char buf
[2*40 + 3];
1555 struct child_process proc
;
1556 const char *argv
[3];
1560 argv
[0] = find_hook("post-rewrite");
1567 memset(&proc
, 0, sizeof(proc
));
1570 proc
.stdout_to_stderr
= 1;
1572 code
= start_command(&proc
);
1575 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1576 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1577 write_in_full(proc
.in
, buf
, n
);
1579 return finish_command(&proc
);
1582 int run_commit_hook(int editor_is_used
, const char *index_file
, const char *name
, ...)
1584 const char *hook_env
[3] = { NULL
};
1585 char index
[PATH_MAX
];
1589 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
1590 hook_env
[0] = index
;
1593 * Let the hook know that no editor will be launched.
1595 if (!editor_is_used
)
1596 hook_env
[1] = "GIT_EDITOR=:";
1598 va_start(args
, name
);
1599 ret
= run_hook_ve(hook_env
, name
, args
);
1605 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1607 static struct wt_status s
;
1608 static struct option builtin_commit_options
[] = {
1609 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1610 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1612 OPT_GROUP(N_("Commit message options")),
1613 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1614 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1615 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1616 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1617 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1618 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1619 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1620 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1621 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1622 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1623 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1624 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1625 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1626 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1627 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key-id"),
1628 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1629 /* end commit message options */
1631 OPT_GROUP(N_("Commit contents options")),
1632 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1633 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1634 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1635 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1636 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1637 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1638 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1639 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1640 STATUS_FORMAT_SHORT
),
1641 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1642 OPT_SET_INT(0, "porcelain", &status_format
,
1643 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1644 OPT_SET_INT(0, "long", &status_format
,
1645 N_("show status in long format (default)"),
1646 STATUS_FORMAT_LONG
),
1647 OPT_BOOL('z', "null", &s
.null_termination
,
1648 N_("terminate entries with NUL")),
1649 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1650 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1651 { 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" },
1652 /* end commit contents options */
1654 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1655 N_("ok to record an empty change")),
1656 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1657 N_("ok to record a change with an empty message")),
1662 struct strbuf sb
= STRBUF_INIT
;
1663 struct strbuf author_ident
= STRBUF_INIT
;
1664 const char *index_file
, *reflog_msg
;
1666 unsigned char sha1
[20];
1667 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1668 struct stat statbuf
;
1669 struct commit
*current_head
= NULL
;
1670 struct commit_extra_header
*extra
= NULL
;
1671 struct ref_transaction
*transaction
;
1672 struct strbuf err
= STRBUF_INIT
;
1674 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1675 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1677 status_init_config(&s
, git_commit_config
);
1678 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1681 if (get_sha1("HEAD", sha1
))
1682 current_head
= NULL
;
1684 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1685 if (parse_commit(current_head
))
1686 die(_("could not parse HEAD commit"));
1688 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1689 builtin_commit_usage
,
1690 prefix
, current_head
, &s
);
1692 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1693 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1695 /* Set up everything for writing the commit object. This includes
1696 running hooks, writing the trees, and interacting with the user. */
1697 if (!prepare_to_commit(index_file
, prefix
,
1698 current_head
, &s
, &author_ident
)) {
1699 rollback_index_files();
1703 /* Determine parents */
1704 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1705 if (!current_head
) {
1707 reflog_msg
= "commit (initial)";
1709 struct commit_list
*c
;
1712 reflog_msg
= "commit (amend)";
1713 for (c
= current_head
->parents
; c
; c
= c
->next
)
1714 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1715 } else if (whence
== FROM_MERGE
) {
1716 struct strbuf m
= STRBUF_INIT
;
1718 int allow_fast_forward
= 1;
1721 reflog_msg
= "commit (merge)";
1722 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1723 fp
= fopen(git_path("MERGE_HEAD"), "r");
1725 die_errno(_("could not open '%s' for reading"),
1726 git_path("MERGE_HEAD"));
1727 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1728 struct commit
*parent
;
1730 parent
= get_merge_parent(m
.buf
);
1732 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1733 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1737 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1738 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1739 die_errno(_("could not read MERGE_MODE"));
1740 if (!strcmp(sb
.buf
, "no-ff"))
1741 allow_fast_forward
= 0;
1743 if (allow_fast_forward
)
1744 parents
= reduce_heads(parents
);
1747 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1748 ? "commit (cherry-pick)"
1750 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1753 /* Finally, get the commit message */
1755 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1756 int saved_errno
= errno
;
1757 rollback_index_files();
1758 die(_("could not read commit message: %s"), strerror(saved_errno
));
1761 if (verbose
|| /* Truncate the message just before the diff, if any. */
1762 cleanup_mode
== CLEANUP_SCISSORS
)
1763 wt_status_truncate_message_at_cut_line(&sb
);
1765 if (cleanup_mode
!= CLEANUP_NONE
)
1766 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1767 if (template_untouched(&sb
) && !allow_empty_message
) {
1768 rollback_index_files();
1769 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1772 if (message_is_empty(&sb
) && !allow_empty_message
) {
1773 rollback_index_files();
1774 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1779 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1780 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1782 struct commit_extra_header
**tail
= &extra
;
1783 append_merge_tag_headers(parents
, &tail
);
1786 if (commit_tree_extended(sb
.buf
, sb
.len
, active_cache_tree
->sha1
,
1787 parents
, sha1
, author_ident
.buf
, sign_commit
, extra
)) {
1788 rollback_index_files();
1789 die(_("failed to write commit object"));
1791 strbuf_release(&author_ident
);
1792 free_commit_extra_headers(extra
);
1794 nl
= strchr(sb
.buf
, '\n');
1796 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1798 strbuf_addch(&sb
, '\n');
1799 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1800 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1802 transaction
= transaction_begin(&err
);
1804 transaction_update_sha1(transaction
, "HEAD", sha1
,
1806 current_head
->object
.sha1
: NULL
,
1807 0, !!current_head
, sb
.buf
, &err
) ||
1808 transaction_commit(transaction
, &err
)) {
1809 rollback_index_files();
1812 transaction_free(transaction
);
1814 unlink(git_path("CHERRY_PICK_HEAD"));
1815 unlink(git_path("REVERT_HEAD"));
1816 unlink(git_path("MERGE_HEAD"));
1817 unlink(git_path("MERGE_MSG"));
1818 unlink(git_path("MERGE_MODE"));
1819 unlink(git_path("SQUASH_MSG"));
1821 if (commit_index_files())
1822 die (_("Repository has been updated, but unable to write\n"
1823 "new_index file. Check that disk is not full or quota is\n"
1824 "not exceeded, and then \"git reset HEAD\" to recover."));
1827 run_commit_hook(use_editor
, get_index_file(), "post-commit", NULL
);
1828 if (amend
&& !no_post_rewrite
) {
1829 struct notes_rewrite_cfg
*cfg
;
1830 cfg
= init_copy_notes_for_rewrite("amend");
1832 /* we are amending, so current_head is not NULL */
1833 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1834 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1836 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1839 print_summary(prefix
, sha1
, !current_head
);