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("sequencer")))
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
;
673 * Inspect sb and determine the true "end" of the log message, in
674 * order to find where to put a new Signed-off-by: line. Ignored are
675 * trailing comment lines and blank lines, and also the traditional
676 * "Conflicts:" block that is not commented out, so that we can use
677 * "git commit -s --amend" on an existing commit that forgot to remove
680 * Returns the number of bytes from the tail to ignore, to be fed as
681 * the second parameter to append_signoff().
683 static int ignore_non_trailer(struct strbuf
*sb
)
687 int in_old_conflicts_block
= 0;
689 while (bol
< sb
->len
) {
692 if (!(next_line
= memchr(sb
->buf
+ bol
, '\n', sb
->len
- bol
)))
693 next_line
= sb
->buf
+ sb
->len
;
697 if (sb
->buf
[bol
] == comment_line_char
|| sb
->buf
[bol
] == '\n') {
698 /* is this the first of the run of comments? */
701 /* otherwise, it is just continuing */
702 } else if (starts_with(sb
->buf
+ bol
, "Conflicts:\n")) {
703 in_old_conflicts_block
= 1;
706 } else if (in_old_conflicts_block
&& sb
->buf
[bol
] == '\t') {
707 ; /* a pathname in the conflicts block */
709 /* the previous was not trailing comment */
711 in_old_conflicts_block
= 0;
713 bol
= next_line
- sb
->buf
;
715 return boc
? sb
->len
- boc
: 0;
718 static int prepare_to_commit(const char *index_file
, const char *prefix
,
719 struct commit
*current_head
,
721 struct strbuf
*author_ident
)
724 struct strbuf committer_ident
= STRBUF_INIT
;
726 struct strbuf sb
= STRBUF_INIT
;
727 const char *hook_arg1
= NULL
;
728 const char *hook_arg2
= NULL
;
729 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
730 int old_display_comment_prefix
;
732 /* This checks and barfs if author is badly specified */
733 determine_author_info(author_ident
);
735 if (!no_verify
&& run_commit_hook(use_editor
, index_file
, "pre-commit", NULL
))
738 if (squash_message
) {
740 * Insert the proper subject line before other commit
741 * message options add their content.
743 if (use_message
&& !strcmp(use_message
, squash_message
))
744 strbuf_addstr(&sb
, "squash! ");
746 struct pretty_print_context ctx
= {0};
748 c
= lookup_commit_reference_by_name(squash_message
);
750 die(_("could not lookup commit %s"), squash_message
);
751 ctx
.output_encoding
= get_commit_output_encoding();
752 format_commit_message(c
, "squash! %s\n\n", &sb
,
758 strbuf_addbuf(&sb
, &message
);
759 hook_arg1
= "message";
760 } else if (logfile
&& !strcmp(logfile
, "-")) {
762 fprintf(stderr
, _("(reading log message from standard input)\n"));
763 if (strbuf_read(&sb
, 0, 0) < 0)
764 die_errno(_("could not read log from standard input"));
765 hook_arg1
= "message";
766 } else if (logfile
) {
767 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
768 die_errno(_("could not read log file '%s'"),
770 hook_arg1
= "message";
771 } else if (use_message
) {
773 buffer
= strstr(use_message_buffer
, "\n\n");
775 strbuf_addstr(&sb
, buffer
+ 2);
776 hook_arg1
= "commit";
777 hook_arg2
= use_message
;
778 } else if (fixup_message
) {
779 struct pretty_print_context ctx
= {0};
780 struct commit
*commit
;
781 commit
= lookup_commit_reference_by_name(fixup_message
);
783 die(_("could not lookup commit %s"), fixup_message
);
784 ctx
.output_encoding
= get_commit_output_encoding();
785 format_commit_message(commit
, "fixup! %s\n\n",
787 hook_arg1
= "message";
788 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
789 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
790 die_errno(_("could not read MERGE_MSG"));
792 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
793 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
794 die_errno(_("could not read SQUASH_MSG"));
795 hook_arg1
= "squash";
796 } else if (template_file
) {
797 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
798 die_errno(_("could not read '%s'"), template_file
);
799 hook_arg1
= "template";
800 clean_message_contents
= 0;
804 * The remaining cases don't modify the template message, but
805 * just set the argument(s) to the prepare-commit-msg hook.
807 else if (whence
== FROM_MERGE
)
809 else if (whence
== FROM_CHERRY_PICK
) {
810 hook_arg1
= "commit";
811 hook_arg2
= "CHERRY_PICK_HEAD";
814 if (squash_message
) {
816 * If squash_commit was used for the commit subject,
817 * then we're possibly hijacking other commit log options.
818 * Reset the hook args to tell the real story.
820 hook_arg1
= "message";
824 s
->fp
= fopen(git_path(commit_editmsg
), "w");
826 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
828 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
829 old_display_comment_prefix
= s
->display_comment_prefix
;
830 s
->display_comment_prefix
= 1;
833 * Most hints are counter-productive when the commit has
838 if (clean_message_contents
)
842 append_signoff(&sb
, ignore_non_trailer(&sb
), 0);
844 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
845 die_errno(_("could not write commit template"));
847 if (auto_comment_line_char
)
848 adjust_comment_line_char(&sb
);
851 /* This checks if committer ident is explicitly given */
852 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
853 if (use_editor
&& include_status
) {
855 int saved_color_setting
;
856 struct ident_split ci
, ai
;
858 if (whence
!= FROM_COMMIT
) {
859 if (cleanup_mode
== CLEANUP_SCISSORS
)
860 wt_status_add_cut_line(s
->fp
);
861 status_printf_ln(s
, GIT_COLOR_NORMAL
,
864 "It looks like you may be committing a merge.\n"
865 "If this is not correct, please remove the file\n"
869 "It looks like you may be committing a cherry-pick.\n"
870 "If this is not correct, please remove the file\n"
873 git_path(whence
== FROM_MERGE
875 : "CHERRY_PICK_HEAD"));
878 fprintf(s
->fp
, "\n");
879 if (cleanup_mode
== CLEANUP_ALL
)
880 status_printf(s
, GIT_COLOR_NORMAL
,
881 _("Please enter the commit message for your changes."
882 " Lines starting\nwith '%c' will be ignored, and an empty"
883 " message aborts the commit.\n"), comment_line_char
);
884 else if (cleanup_mode
== CLEANUP_SCISSORS
&& whence
== FROM_COMMIT
)
885 wt_status_add_cut_line(s
->fp
);
886 else /* CLEANUP_SPACE, that is. */
887 status_printf(s
, GIT_COLOR_NORMAL
,
888 _("Please enter the commit message for your changes."
890 "with '%c' will be kept; you may remove them"
891 " yourself if you want to.\n"
892 "An empty message aborts the commit.\n"), comment_line_char
);
893 if (only_include_assumed
)
894 status_printf_ln(s
, GIT_COLOR_NORMAL
,
895 "%s", only_include_assumed
);
897 split_ident_or_die(&ai
, author_ident
);
898 split_ident_or_die(&ci
, &committer_ident
);
900 if (ident_cmp(&ai
, &ci
))
901 status_printf_ln(s
, GIT_COLOR_NORMAL
,
903 "Author: %.*s <%.*s>"),
904 ident_shown
++ ? "" : "\n",
905 (int)(ai
.name_end
- ai
.name_begin
), ai
.name_begin
,
906 (int)(ai
.mail_end
- ai
.mail_begin
), ai
.mail_begin
);
908 if (author_date_is_interesting())
909 status_printf_ln(s
, GIT_COLOR_NORMAL
,
912 ident_shown
++ ? "" : "\n",
913 show_ident_date(&ai
, DATE_NORMAL
));
915 if (!committer_ident_sufficiently_given())
916 status_printf_ln(s
, GIT_COLOR_NORMAL
,
918 "Committer: %.*s <%.*s>"),
919 ident_shown
++ ? "" : "\n",
920 (int)(ci
.name_end
- ci
.name_begin
), ci
.name_begin
,
921 (int)(ci
.mail_end
- ci
.mail_begin
), ci
.mail_begin
);
924 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", "");
926 saved_color_setting
= s
->use_color
;
928 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
929 s
->use_color
= saved_color_setting
;
931 unsigned char sha1
[20];
932 const char *parent
= "HEAD";
934 if (!active_nr
&& read_cache() < 0)
935 die(_("Cannot read index"));
940 if (get_sha1(parent
, sha1
))
941 commitable
= !!active_nr
;
944 * Unless the user did explicitly request a submodule
945 * ignore mode by passing a command line option we do
946 * not ignore any changed submodule SHA-1s when
947 * comparing index and parent, no matter what is
948 * configured. Otherwise we won't commit any
949 * submodules which were manually staged, which would
950 * be really confusing.
952 int diff_flags
= DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG
;
953 if (ignore_submodule_arg
&&
954 !strcmp(ignore_submodule_arg
, "all"))
955 diff_flags
|= DIFF_OPT_IGNORE_SUBMODULES
;
956 commitable
= index_differs_from(parent
, diff_flags
);
959 strbuf_release(&committer_ident
);
964 * Reject an attempt to record a non-merge empty commit without
965 * explicit --allow-empty. In the cherry-pick case, it may be
966 * empty due to conflict resolution, which the user should okay.
968 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
969 !(amend
&& is_a_merge(current_head
))) {
970 s
->display_comment_prefix
= old_display_comment_prefix
;
971 run_status(stdout
, index_file
, prefix
, 0, s
);
973 fputs(_(empty_amend_advice
), stderr
);
974 else if (whence
== FROM_CHERRY_PICK
) {
975 fputs(_(empty_cherry_pick_advice
), stderr
);
976 if (!sequencer_in_use
)
977 fputs(_(empty_cherry_pick_advice_single
), stderr
);
979 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
985 * Re-read the index as pre-commit hook could have updated it,
986 * and write it out as a tree. We must do this before we invoke
987 * the editor and after we invoke run_status above.
990 read_cache_from(index_file
);
991 if (update_main_cache_tree(0)) {
992 error(_("Error building trees"));
996 if (run_commit_hook(use_editor
, index_file
, "prepare-commit-msg",
997 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
1001 char index
[PATH_MAX
];
1002 const char *env
[2] = { NULL
};
1004 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
1005 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
1007 _("Please supply the message using either -m or -F option.\n"));
1013 run_commit_hook(use_editor
, index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
1020 static int rest_is_empty(struct strbuf
*sb
, int start
)
1025 /* Check if the rest is just whitespace and Signed-of-by's. */
1026 for (i
= start
; i
< sb
->len
; i
++) {
1027 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1033 if (strlen(sign_off_header
) <= eol
- i
&&
1034 starts_with(sb
->buf
+ i
, sign_off_header
)) {
1039 if (!isspace(sb
->buf
[i
++]))
1047 * Find out if the message in the strbuf contains only whitespace and
1048 * Signed-off-by lines.
1050 static int message_is_empty(struct strbuf
*sb
)
1052 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
1054 return rest_is_empty(sb
, 0);
1058 * See if the user edited the message in the editor or left what
1059 * was in the template intact
1061 static int template_untouched(struct strbuf
*sb
)
1063 struct strbuf tmpl
= STRBUF_INIT
;
1066 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
1069 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
1072 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
1073 if (!skip_prefix(sb
->buf
, tmpl
.buf
, &start
))
1075 strbuf_release(&tmpl
);
1076 return rest_is_empty(sb
, start
- sb
->buf
);
1079 static const char *find_author_by_nickname(const char *name
)
1081 struct rev_info revs
;
1082 struct commit
*commit
;
1083 struct strbuf buf
= STRBUF_INIT
;
1084 struct string_list mailmap
= STRING_LIST_INIT_NODUP
;
1088 init_revisions(&revs
, NULL
);
1089 strbuf_addf(&buf
, "--author=%s", name
);
1094 setup_revisions(ac
, av
, &revs
, NULL
);
1095 revs
.mailmap
= &mailmap
;
1096 read_mailmap(revs
.mailmap
, NULL
);
1098 if (prepare_revision_walk(&revs
))
1099 die(_("revision walk setup failed"));
1100 commit
= get_revision(&revs
);
1102 struct pretty_print_context ctx
= {0};
1103 ctx
.date_mode
= DATE_NORMAL
;
1104 strbuf_release(&buf
);
1105 format_commit_message(commit
, "%aN <%aE>", &buf
, &ctx
);
1106 clear_mailmap(&mailmap
);
1107 return strbuf_detach(&buf
, NULL
);
1109 die(_("No existing author found with '%s'"), name
);
1113 static void handle_untracked_files_arg(struct wt_status
*s
)
1115 if (!untracked_files_arg
)
1116 ; /* default already initialized */
1117 else if (!strcmp(untracked_files_arg
, "no"))
1118 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1119 else if (!strcmp(untracked_files_arg
, "normal"))
1120 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1121 else if (!strcmp(untracked_files_arg
, "all"))
1122 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1124 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
1127 static const char *read_commit_message(const char *name
)
1129 const char *out_enc
;
1130 struct commit
*commit
;
1132 commit
= lookup_commit_reference_by_name(name
);
1134 die(_("could not lookup commit %s"), name
);
1135 out_enc
= get_commit_output_encoding();
1136 return logmsg_reencode(commit
, NULL
, out_enc
);
1140 * Enumerate what needs to be propagated when --porcelain
1141 * is not in effect here.
1143 static struct status_deferred_config
{
1144 enum status_format status_format
;
1146 } status_deferred_config
= {
1147 STATUS_FORMAT_UNSPECIFIED
,
1148 -1 /* unspecified */
1151 static void finalize_deferred_config(struct wt_status
*s
)
1153 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1154 !s
->null_termination
);
1156 if (s
->null_termination
) {
1157 if (status_format
== STATUS_FORMAT_NONE
||
1158 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1159 status_format
= STATUS_FORMAT_PORCELAIN
;
1160 else if (status_format
== STATUS_FORMAT_LONG
)
1161 die(_("--long and -z are incompatible"));
1164 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1165 status_format
= status_deferred_config
.status_format
;
1166 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1167 status_format
= STATUS_FORMAT_NONE
;
1169 if (use_deferred_config
&& s
->show_branch
< 0)
1170 s
->show_branch
= status_deferred_config
.show_branch
;
1171 if (s
->show_branch
< 0)
1175 static int parse_and_validate_options(int argc
, const char *argv
[],
1176 const struct option
*options
,
1177 const char * const usage
[],
1179 struct commit
*current_head
,
1180 struct wt_status
*s
)
1184 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1185 finalize_deferred_config(s
);
1187 if (force_author
&& !strchr(force_author
, '>'))
1188 force_author
= find_author_by_nickname(force_author
);
1190 if (force_author
&& renew_authorship
)
1191 die(_("Using both --reset-author and --author does not make sense"));
1193 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1196 use_editor
= edit_flag
;
1198 /* Sanity check options */
1199 if (amend
&& !current_head
)
1200 die(_("You have nothing to amend."));
1201 if (amend
&& whence
!= FROM_COMMIT
) {
1202 if (whence
== FROM_MERGE
)
1203 die(_("You are in the middle of a merge -- cannot amend."));
1204 else if (whence
== FROM_CHERRY_PICK
)
1205 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1207 if (fixup_message
&& squash_message
)
1208 die(_("Options --squash and --fixup cannot be used together"));
1218 die(_("Only one of -c/-C/-F/--fixup can be used."));
1219 if (message
.len
&& f
> 0)
1220 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1221 if (f
|| message
.len
)
1222 template_file
= NULL
;
1224 use_message
= edit_message
;
1225 if (amend
&& !use_message
&& !fixup_message
)
1226 use_message
= "HEAD";
1227 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1228 die(_("--reset-author can be used only with -C, -c or --amend."));
1230 use_message_buffer
= read_commit_message(use_message
);
1231 if (!renew_authorship
) {
1232 author_message
= use_message
;
1233 author_message_buffer
= use_message_buffer
;
1236 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1237 author_message
= "CHERRY_PICK_HEAD";
1238 author_message_buffer
= read_commit_message(author_message
);
1241 if (patch_interactive
)
1244 if (also
+ only
+ all
+ interactive
> 1)
1245 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1246 if (argc
== 0 && (also
|| (only
&& !amend
)))
1247 die(_("No paths with --include/--only does not make sense."));
1248 if (argc
== 0 && only
&& amend
)
1249 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1250 if (argc
> 0 && !also
&& !only
)
1251 only_include_assumed
= _("Explicit paths specified without -i or -o; assuming --only paths...");
1252 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1253 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1254 else if (!strcmp(cleanup_arg
, "verbatim"))
1255 cleanup_mode
= CLEANUP_NONE
;
1256 else if (!strcmp(cleanup_arg
, "whitespace"))
1257 cleanup_mode
= CLEANUP_SPACE
;
1258 else if (!strcmp(cleanup_arg
, "strip"))
1259 cleanup_mode
= CLEANUP_ALL
;
1260 else if (!strcmp(cleanup_arg
, "scissors"))
1261 cleanup_mode
= use_editor
? CLEANUP_SCISSORS
: CLEANUP_SPACE
;
1263 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1265 handle_untracked_files_arg(s
);
1267 if (all
&& argc
> 0)
1268 die(_("Paths with -a does not make sense."));
1270 if (status_format
!= STATUS_FORMAT_NONE
)
1276 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1277 const struct commit
*current_head
, struct wt_status
*s
)
1280 const char *index_file
;
1282 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1283 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1284 rollback_index_files();
1286 return commitable
? 0 : 1;
1289 static int parse_status_slot(const char *var
, int offset
)
1291 if (!strcasecmp(var
+offset
, "header"))
1292 return WT_STATUS_HEADER
;
1293 if (!strcasecmp(var
+offset
, "branch"))
1294 return WT_STATUS_ONBRANCH
;
1295 if (!strcasecmp(var
+offset
, "updated")
1296 || !strcasecmp(var
+offset
, "added"))
1297 return WT_STATUS_UPDATED
;
1298 if (!strcasecmp(var
+offset
, "changed"))
1299 return WT_STATUS_CHANGED
;
1300 if (!strcasecmp(var
+offset
, "untracked"))
1301 return WT_STATUS_UNTRACKED
;
1302 if (!strcasecmp(var
+offset
, "nobranch"))
1303 return WT_STATUS_NOBRANCH
;
1304 if (!strcasecmp(var
+offset
, "unmerged"))
1305 return WT_STATUS_UNMERGED
;
1309 static int git_status_config(const char *k
, const char *v
, void *cb
)
1311 struct wt_status
*s
= cb
;
1313 if (starts_with(k
, "column."))
1314 return git_column_config(k
, v
, "status", &s
->colopts
);
1315 if (!strcmp(k
, "status.submodulesummary")) {
1317 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1318 if (is_bool
&& s
->submodule_summary
)
1319 s
->submodule_summary
= -1;
1322 if (!strcmp(k
, "status.short")) {
1323 if (git_config_bool(k
, v
))
1324 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1326 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1329 if (!strcmp(k
, "status.branch")) {
1330 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1333 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1334 s
->use_color
= git_config_colorbool(k
, v
);
1337 if (!strcmp(k
, "status.displaycommentprefix")) {
1338 s
->display_comment_prefix
= git_config_bool(k
, v
);
1341 if (starts_with(k
, "status.color.") || starts_with(k
, "color.status.")) {
1342 int slot
= parse_status_slot(k
, 13);
1346 return config_error_nonbool(k
);
1347 color_parse(v
, k
, s
->color_palette
[slot
]);
1350 if (!strcmp(k
, "status.relativepaths")) {
1351 s
->relative_paths
= git_config_bool(k
, v
);
1354 if (!strcmp(k
, "status.showuntrackedfiles")) {
1356 return config_error_nonbool(k
);
1357 else if (!strcmp(v
, "no"))
1358 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1359 else if (!strcmp(v
, "normal"))
1360 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1361 else if (!strcmp(v
, "all"))
1362 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1364 return error(_("Invalid untracked files mode '%s'"), v
);
1367 return git_diff_ui_config(k
, v
, NULL
);
1370 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1372 static struct wt_status s
;
1374 unsigned char sha1
[20];
1375 static struct option builtin_status_options
[] = {
1376 OPT__VERBOSE(&verbose
, N_("be verbose")),
1377 OPT_SET_INT('s', "short", &status_format
,
1378 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1379 OPT_BOOL('b', "branch", &s
.show_branch
,
1380 N_("show branch information")),
1381 OPT_SET_INT(0, "porcelain", &status_format
,
1382 N_("machine-readable output"),
1383 STATUS_FORMAT_PORCELAIN
),
1384 OPT_SET_INT(0, "long", &status_format
,
1385 N_("show status in long format (default)"),
1386 STATUS_FORMAT_LONG
),
1387 OPT_BOOL('z', "null", &s
.null_termination
,
1388 N_("terminate entries with NUL")),
1389 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1391 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1392 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1393 OPT_BOOL(0, "ignored", &show_ignored_in_status
,
1394 N_("show ignored files")),
1395 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1396 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1397 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1398 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1402 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1403 usage_with_options(builtin_status_usage
, builtin_status_options
);
1405 status_init_config(&s
, git_status_config
);
1406 argc
= parse_options(argc
, argv
, prefix
,
1407 builtin_status_options
,
1408 builtin_status_usage
, 0);
1409 finalize_colopts(&s
.colopts
, -1);
1410 finalize_deferred_config(&s
);
1412 handle_untracked_files_arg(&s
);
1413 if (show_ignored_in_status
)
1414 s
.show_ignored_files
= 1;
1415 parse_pathspec(&s
.pathspec
, 0,
1416 PATHSPEC_PREFER_FULL
,
1419 read_cache_preload(&s
.pathspec
);
1420 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, &s
.pathspec
, NULL
, NULL
);
1422 fd
= hold_locked_index(&index_lock
, 0);
1424 update_index_if_able(&the_index
, &index_lock
);
1426 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1427 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1428 wt_status_collect(&s
);
1430 if (s
.relative_paths
)
1433 switch (status_format
) {
1434 case STATUS_FORMAT_SHORT
:
1435 wt_shortstatus_print(&s
);
1437 case STATUS_FORMAT_PORCELAIN
:
1438 wt_porcelain_print(&s
);
1440 case STATUS_FORMAT_UNSPECIFIED
:
1441 die("BUG: finalize_deferred_config() should have been called");
1443 case STATUS_FORMAT_NONE
:
1444 case STATUS_FORMAT_LONG
:
1445 s
.verbose
= verbose
;
1446 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1447 wt_status_print(&s
);
1453 static const char *implicit_ident_advice(void)
1455 char *user_config
= NULL
;
1456 char *xdg_config
= NULL
;
1459 home_config_paths(&user_config
, &xdg_config
, "config");
1460 config_exists
= file_exists(user_config
) || file_exists(xdg_config
);
1465 return _(implicit_ident_advice_config
);
1467 return _(implicit_ident_advice_noconfig
);
1471 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1474 struct rev_info rev
;
1475 struct commit
*commit
;
1476 struct strbuf format
= STRBUF_INIT
;
1477 unsigned char junk_sha1
[20];
1479 struct pretty_print_context pctx
= {0};
1480 struct strbuf author_ident
= STRBUF_INIT
;
1481 struct strbuf committer_ident
= STRBUF_INIT
;
1483 commit
= lookup_commit(sha1
);
1485 die(_("couldn't look up newly created commit"));
1486 if (parse_commit(commit
))
1487 die(_("could not parse newly created commit"));
1489 strbuf_addstr(&format
, "format:%h] %s");
1491 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1492 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1493 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1494 strbuf_addstr(&format
, "\n Author: ");
1495 strbuf_addbuf_percentquote(&format
, &author_ident
);
1497 if (author_date_is_interesting()) {
1498 struct strbuf date
= STRBUF_INIT
;
1499 format_commit_message(commit
, "%ad", &date
, &pctx
);
1500 strbuf_addstr(&format
, "\n Date: ");
1501 strbuf_addbuf_percentquote(&format
, &date
);
1502 strbuf_release(&date
);
1504 if (!committer_ident_sufficiently_given()) {
1505 strbuf_addstr(&format
, "\n Committer: ");
1506 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1507 if (advice_implicit_identity
) {
1508 strbuf_addch(&format
, '\n');
1509 strbuf_addstr(&format
, implicit_ident_advice());
1512 strbuf_release(&author_ident
);
1513 strbuf_release(&committer_ident
);
1515 init_revisions(&rev
, prefix
);
1516 setup_revisions(0, NULL
, &rev
, NULL
);
1519 rev
.diffopt
.output_format
=
1520 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1522 rev
.verbose_header
= 1;
1523 rev
.show_root_diff
= 1;
1524 get_commit_format(format
.buf
, &rev
);
1525 rev
.always_show_header
= 0;
1526 rev
.diffopt
.detect_rename
= 1;
1527 rev
.diffopt
.break_opt
= 0;
1528 diff_setup_done(&rev
.diffopt
);
1530 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1532 starts_with(head
, "refs/heads/") ?
1534 !strcmp(head
, "HEAD") ?
1535 _("detached HEAD") :
1537 initial_commit
? _(" (root-commit)") : "");
1539 if (!log_tree_commit(&rev
, commit
)) {
1540 rev
.always_show_header
= 1;
1541 rev
.use_terminator
= 1;
1542 log_tree_commit(&rev
, commit
);
1545 strbuf_release(&format
);
1548 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1550 struct wt_status
*s
= cb
;
1553 if (!strcmp(k
, "commit.template"))
1554 return git_config_pathname(&template_file
, k
, v
);
1555 if (!strcmp(k
, "commit.status")) {
1556 include_status
= git_config_bool(k
, v
);
1559 if (!strcmp(k
, "commit.cleanup"))
1560 return git_config_string(&cleanup_arg
, k
, v
);
1561 if (!strcmp(k
, "commit.gpgsign")) {
1562 sign_commit
= git_config_bool(k
, v
) ? "" : NULL
;
1566 status
= git_gpg_config(k
, v
, NULL
);
1569 return git_status_config(k
, v
, s
);
1572 static int run_rewrite_hook(const unsigned char *oldsha1
,
1573 const unsigned char *newsha1
)
1575 /* oldsha1 SP newsha1 LF NUL */
1576 static char buf
[2*40 + 3];
1577 struct child_process proc
= CHILD_PROCESS_INIT
;
1578 const char *argv
[3];
1582 argv
[0] = find_hook("post-rewrite");
1591 proc
.stdout_to_stderr
= 1;
1593 code
= start_command(&proc
);
1596 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1597 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1598 write_in_full(proc
.in
, buf
, n
);
1600 return finish_command(&proc
);
1603 int run_commit_hook(int editor_is_used
, const char *index_file
, const char *name
, ...)
1605 const char *hook_env
[3] = { NULL
};
1606 char index
[PATH_MAX
];
1610 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
1611 hook_env
[0] = index
;
1614 * Let the hook know that no editor will be launched.
1616 if (!editor_is_used
)
1617 hook_env
[1] = "GIT_EDITOR=:";
1619 va_start(args
, name
);
1620 ret
= run_hook_ve(hook_env
, name
, args
);
1626 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1628 static struct wt_status s
;
1629 static struct option builtin_commit_options
[] = {
1630 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1631 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1633 OPT_GROUP(N_("Commit message options")),
1634 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1635 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1636 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1637 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1638 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1639 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1640 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1641 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1642 OPT_BOOL(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1643 OPT_BOOL('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1644 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1645 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1646 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1647 OPT_BOOL(0, "status", &include_status
, N_("include status in commit message template")),
1648 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key-id"),
1649 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1650 /* end commit message options */
1652 OPT_GROUP(N_("Commit contents options")),
1653 OPT_BOOL('a', "all", &all
, N_("commit all changed files")),
1654 OPT_BOOL('i', "include", &also
, N_("add specified files to index for commit")),
1655 OPT_BOOL(0, "interactive", &interactive
, N_("interactively add files")),
1656 OPT_BOOL('p', "patch", &patch_interactive
, N_("interactively add changes")),
1657 OPT_BOOL('o', "only", &only
, N_("commit only specified files")),
1658 OPT_BOOL('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1659 OPT_BOOL(0, "dry-run", &dry_run
, N_("show what would be committed")),
1660 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1661 STATUS_FORMAT_SHORT
),
1662 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1663 OPT_SET_INT(0, "porcelain", &status_format
,
1664 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1665 OPT_SET_INT(0, "long", &status_format
,
1666 N_("show status in long format (default)"),
1667 STATUS_FORMAT_LONG
),
1668 OPT_BOOL('z', "null", &s
.null_termination
,
1669 N_("terminate entries with NUL")),
1670 OPT_BOOL(0, "amend", &amend
, N_("amend previous commit")),
1671 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1672 { 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" },
1673 /* end commit contents options */
1675 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty
,
1676 N_("ok to record an empty change")),
1677 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message
,
1678 N_("ok to record a change with an empty message")),
1683 struct strbuf sb
= STRBUF_INIT
;
1684 struct strbuf author_ident
= STRBUF_INIT
;
1685 const char *index_file
, *reflog_msg
;
1687 unsigned char sha1
[20];
1688 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1689 struct stat statbuf
;
1690 struct commit
*current_head
= NULL
;
1691 struct commit_extra_header
*extra
= NULL
;
1692 struct ref_transaction
*transaction
;
1693 struct strbuf err
= STRBUF_INIT
;
1695 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1696 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1698 status_init_config(&s
, git_commit_config
);
1699 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1702 if (get_sha1("HEAD", sha1
))
1703 current_head
= NULL
;
1705 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1706 if (parse_commit(current_head
))
1707 die(_("could not parse HEAD commit"));
1709 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1710 builtin_commit_usage
,
1711 prefix
, current_head
, &s
);
1713 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1714 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1716 /* Set up everything for writing the commit object. This includes
1717 running hooks, writing the trees, and interacting with the user. */
1718 if (!prepare_to_commit(index_file
, prefix
,
1719 current_head
, &s
, &author_ident
)) {
1720 rollback_index_files();
1724 /* Determine parents */
1725 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1726 if (!current_head
) {
1728 reflog_msg
= "commit (initial)";
1730 struct commit_list
*c
;
1733 reflog_msg
= "commit (amend)";
1734 for (c
= current_head
->parents
; c
; c
= c
->next
)
1735 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1736 } else if (whence
== FROM_MERGE
) {
1737 struct strbuf m
= STRBUF_INIT
;
1739 int allow_fast_forward
= 1;
1742 reflog_msg
= "commit (merge)";
1743 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1744 fp
= fopen(git_path("MERGE_HEAD"), "r");
1746 die_errno(_("could not open '%s' for reading"),
1747 git_path("MERGE_HEAD"));
1748 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1749 struct commit
*parent
;
1751 parent
= get_merge_parent(m
.buf
);
1753 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1754 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1758 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1759 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1760 die_errno(_("could not read MERGE_MODE"));
1761 if (!strcmp(sb
.buf
, "no-ff"))
1762 allow_fast_forward
= 0;
1764 if (allow_fast_forward
)
1765 parents
= reduce_heads(parents
);
1768 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1769 ? "commit (cherry-pick)"
1771 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1774 /* Finally, get the commit message */
1776 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1777 int saved_errno
= errno
;
1778 rollback_index_files();
1779 die(_("could not read commit message: %s"), strerror(saved_errno
));
1782 if (verbose
|| /* Truncate the message just before the diff, if any. */
1783 cleanup_mode
== CLEANUP_SCISSORS
)
1784 wt_status_truncate_message_at_cut_line(&sb
);
1786 if (cleanup_mode
!= CLEANUP_NONE
)
1787 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1788 if (template_untouched(&sb
) && !allow_empty_message
) {
1789 rollback_index_files();
1790 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1793 if (message_is_empty(&sb
) && !allow_empty_message
) {
1794 rollback_index_files();
1795 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1800 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1801 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1803 struct commit_extra_header
**tail
= &extra
;
1804 append_merge_tag_headers(parents
, &tail
);
1807 if (commit_tree_extended(sb
.buf
, sb
.len
, active_cache_tree
->sha1
,
1808 parents
, sha1
, author_ident
.buf
, sign_commit
, extra
)) {
1809 rollback_index_files();
1810 die(_("failed to write commit object"));
1812 strbuf_release(&author_ident
);
1813 free_commit_extra_headers(extra
);
1815 nl
= strchr(sb
.buf
, '\n');
1817 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1819 strbuf_addch(&sb
, '\n');
1820 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1821 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1823 transaction
= ref_transaction_begin(&err
);
1825 ref_transaction_update(transaction
, "HEAD", sha1
,
1827 ? current_head
->object
.sha1
: NULL
,
1828 0, !!current_head
, &err
) ||
1829 ref_transaction_commit(transaction
, sb
.buf
, &err
)) {
1830 rollback_index_files();
1833 ref_transaction_free(transaction
);
1835 unlink(git_path("CHERRY_PICK_HEAD"));
1836 unlink(git_path("REVERT_HEAD"));
1837 unlink(git_path("MERGE_HEAD"));
1838 unlink(git_path("MERGE_MSG"));
1839 unlink(git_path("MERGE_MODE"));
1840 unlink(git_path("SQUASH_MSG"));
1842 if (commit_index_files())
1843 die (_("Repository has been updated, but unable to write\n"
1844 "new_index file. Check that disk is not full or quota is\n"
1845 "not exceeded, and then \"git reset HEAD\" to recover."));
1848 run_commit_hook(use_editor
, get_index_file(), "post-commit", NULL
);
1849 if (amend
&& !no_post_rewrite
) {
1850 struct notes_rewrite_cfg
*cfg
;
1851 cfg
= init_copy_notes_for_rewrite("amend");
1853 /* we are amending, so current_head is not NULL */
1854 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1855 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1857 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1860 print_summary(prefix
, sha1
, !current_head
);
1862 strbuf_release(&err
);