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"
34 static const char * const builtin_commit_usage
[] = {
35 N_("git commit [options] [--] <pathspec>..."),
39 static const char * const builtin_status_usage
[] = {
40 N_("git status [options] [--] <pathspec>..."),
44 static const char implicit_ident_advice
[] =
45 N_("Your name and email address were configured automatically based\n"
46 "on your username and hostname. Please check that they are accurate.\n"
47 "You can suppress this message by setting them explicitly:\n"
49 " git config --global user.name \"Your Name\"\n"
50 " git config --global user.email you@example.com\n"
52 "After doing this, you may fix the identity used for this commit with:\n"
54 " git commit --amend --reset-author\n");
56 static const char empty_amend_advice
[] =
57 N_("You asked to amend the most recent commit, but doing so would make\n"
58 "it empty. You can repeat your command with --allow-empty, or you can\n"
59 "remove the commit entirely with \"git reset HEAD^\".\n");
61 static const char empty_cherry_pick_advice
[] =
62 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
63 "If you wish to commit it anyway, use:\n"
65 " git commit --allow-empty\n"
68 static const char empty_cherry_pick_advice_single
[] =
69 N_("Otherwise, please use 'git reset'\n");
71 static const char empty_cherry_pick_advice_multi
[] =
72 N_("If you wish to skip this commit, use:\n"
76 "Then \"git cherry-pick --continue\" will resume cherry-picking\n"
77 "the remaining commits.\n");
79 static const char *use_message_buffer
;
80 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
81 static struct lock_file index_lock
; /* real index */
82 static struct lock_file false_lock
; /* used only for partial commits */
89 static const char *logfile
, *force_author
;
90 static const char *template_file
;
92 * The _message variables are commit names from which to take
93 * the commit message and/or authorship.
95 static const char *author_message
, *author_message_buffer
;
96 static char *edit_message
, *use_message
;
97 static char *fixup_message
, *squash_message
;
98 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
99 static int edit_flag
= -1; /* unspecified */
100 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
101 static int no_post_rewrite
, allow_empty_message
;
102 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
103 static char *sign_commit
;
106 * The default commit message cleanup mode will remove the lines
107 * beginning with # (shell comments) and leading and trailing
108 * whitespaces (empty lines or containing only whitespaces)
109 * if editor is used, and only the whitespaces if the message
110 * is specified explicitly.
117 static const char *cleanup_arg
;
119 static enum commit_whence whence
;
120 static int sequencer_in_use
;
121 static int use_editor
= 1, include_status
= 1;
122 static int show_ignored_in_status
, have_option_m
;
123 static const char *only_include_assumed
;
124 static struct strbuf message
= STRBUF_INIT
;
126 static enum status_format
{
127 STATUS_FORMAT_NONE
= 0,
130 STATUS_FORMAT_PORCELAIN
,
132 STATUS_FORMAT_UNSPECIFIED
133 } status_format
= STATUS_FORMAT_UNSPECIFIED
;
135 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
137 struct strbuf
*buf
= opt
->value
;
140 strbuf_setlen(buf
, 0);
144 strbuf_addch(buf
, '\n');
145 strbuf_addstr(buf
, arg
);
146 strbuf_complete_line(buf
);
151 static void determine_whence(struct wt_status
*s
)
153 if (file_exists(git_path("MERGE_HEAD")))
155 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
156 whence
= FROM_CHERRY_PICK
;
157 if (file_exists(git_path("sequencer")))
158 sequencer_in_use
= 1;
161 whence
= FROM_COMMIT
;
166 static void status_init_config(struct wt_status
*s
, config_fn_t fn
)
168 wt_status_prepare(s
);
172 s
->hints
= advice_status_hints
; /* must come after git_config() */
175 static void rollback_index_files(void)
177 switch (commit_style
) {
179 break; /* nothing to do */
181 rollback_lock_file(&index_lock
);
184 rollback_lock_file(&index_lock
);
185 rollback_lock_file(&false_lock
);
190 static int commit_index_files(void)
194 switch (commit_style
) {
196 break; /* nothing to do */
198 err
= commit_lock_file(&index_lock
);
201 err
= commit_lock_file(&index_lock
);
202 rollback_lock_file(&false_lock
);
210 * Take a union of paths in the index and the named tree (typically, "HEAD"),
211 * and return the paths that match the given pattern in list.
213 static int list_paths(struct string_list
*list
, const char *with_tree
,
214 const char *prefix
, const char **pattern
)
222 for (i
= 0; pattern
[i
]; i
++)
227 char *max_prefix
= common_prefix(pattern
);
228 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
232 for (i
= 0; i
< active_nr
; i
++) {
233 const struct cache_entry
*ce
= active_cache
[i
];
234 struct string_list_item
*item
;
236 if (ce
->ce_flags
& CE_UPDATE
)
238 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
240 item
= string_list_insert(list
, ce
->name
);
241 if (ce_skip_worktree(ce
))
242 item
->util
= item
; /* better a valid pointer than a fake one */
245 return report_path_error(m
, pattern
, prefix
);
248 static void add_remove_files(struct string_list
*list
)
251 for (i
= 0; i
< list
->nr
; i
++) {
253 struct string_list_item
*p
= &(list
->items
[i
]);
255 /* p->util is skip-worktree */
259 if (!lstat(p
->string
, &st
)) {
260 if (add_to_cache(p
->string
, &st
, 0))
261 die(_("updating files failed"));
263 remove_file_from_cache(p
->string
);
267 static void create_base_index(const struct commit
*current_head
)
270 struct unpack_trees_options opts
;
278 memset(&opts
, 0, sizeof(opts
));
282 opts
.src_index
= &the_index
;
283 opts
.dst_index
= &the_index
;
285 opts
.fn
= oneway_merge
;
286 tree
= parse_tree_indirect(current_head
->object
.sha1
);
288 die(_("failed to unpack HEAD tree object"));
290 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
291 if (unpack_trees(1, &t
, &opts
))
292 exit(128); /* We've already reported the error, finish dying */
295 static void refresh_cache_or_die(int refresh_flags
)
298 * refresh_flags contains REFRESH_QUIET, so the only errors
299 * are for unmerged entries.
301 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
302 die_resolve_conflict("commit");
305 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
306 const struct commit
*current_head
, int is_status
)
309 struct string_list partial
;
310 const char **pathspec
= NULL
;
311 char *old_index_env
= NULL
;
312 int refresh_flags
= REFRESH_QUIET
;
315 refresh_flags
|= REFRESH_UNMERGED
;
318 pathspec
= get_pathspec(prefix
, argv
);
320 if (read_cache_preload(pathspec
) < 0)
321 die(_("index file corrupt"));
324 fd
= hold_locked_index(&index_lock
, 1);
326 refresh_cache_or_die(refresh_flags
);
328 if (write_cache(fd
, active_cache
, active_nr
) ||
329 close_lock_file(&index_lock
))
330 die(_("unable to create temporary index"));
332 old_index_env
= getenv(INDEX_ENVIRONMENT
);
333 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
335 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
336 die(_("interactive add failed"));
338 if (old_index_env
&& *old_index_env
)
339 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
341 unsetenv(INDEX_ENVIRONMENT
);
344 read_cache_from(index_lock
.filename
);
346 commit_style
= COMMIT_NORMAL
;
347 return index_lock
.filename
;
351 * Non partial, non as-is commit.
353 * (1) get the real index;
354 * (2) update the_index as necessary;
355 * (3) write the_index out to the real index (still locked);
356 * (4) return the name of the locked index file.
358 * The caller should run hooks on the locked real index, and
359 * (A) if all goes well, commit the real index;
360 * (B) on failure, rollback the real index.
362 if (all
|| (also
&& pathspec
&& *pathspec
)) {
363 fd
= hold_locked_index(&index_lock
, 1);
364 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
365 refresh_cache_or_die(refresh_flags
);
366 update_main_cache_tree(WRITE_TREE_SILENT
);
367 if (write_cache(fd
, active_cache
, active_nr
) ||
368 close_lock_file(&index_lock
))
369 die(_("unable to write new_index file"));
370 commit_style
= COMMIT_NORMAL
;
371 return index_lock
.filename
;
377 * (1) return the name of the real index file.
379 * The caller should run hooks on the real index,
380 * and create commit from the_index.
381 * We still need to refresh the index here.
383 if (!only
&& (!pathspec
|| !*pathspec
)) {
384 fd
= hold_locked_index(&index_lock
, 1);
385 refresh_cache_or_die(refresh_flags
);
386 if (active_cache_changed
) {
387 update_main_cache_tree(WRITE_TREE_SILENT
);
388 if (write_cache(fd
, active_cache
, active_nr
) ||
389 commit_locked_index(&index_lock
))
390 die(_("unable to write new_index file"));
392 rollback_lock_file(&index_lock
);
394 commit_style
= COMMIT_AS_IS
;
395 return get_index_file();
401 * (0) find the set of affected paths;
402 * (1) get lock on the real index file;
403 * (2) update the_index with the given paths;
404 * (3) write the_index out to the real index (still locked);
405 * (4) get lock on the false index file;
406 * (5) reset the_index from HEAD;
407 * (6) update the_index the same way as (2);
408 * (7) write the_index out to the false index file;
409 * (8) return the name of the false index file (still locked);
411 * The caller should run hooks on the locked false index, and
412 * create commit from it. Then
413 * (A) if all goes well, commit the real index;
414 * (B) on failure, rollback the real index;
415 * In either case, rollback the false index.
417 commit_style
= COMMIT_PARTIAL
;
419 if (whence
!= FROM_COMMIT
) {
420 if (whence
== FROM_MERGE
)
421 die(_("cannot do a partial commit during a merge."));
422 else if (whence
== FROM_CHERRY_PICK
)
423 die(_("cannot do a partial commit during a cherry-pick."));
426 memset(&partial
, 0, sizeof(partial
));
427 partial
.strdup_strings
= 1;
428 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
432 if (read_cache() < 0)
433 die(_("cannot read the index"));
435 fd
= hold_locked_index(&index_lock
, 1);
436 add_remove_files(&partial
);
437 refresh_cache(REFRESH_QUIET
);
438 if (write_cache(fd
, active_cache
, active_nr
) ||
439 close_lock_file(&index_lock
))
440 die(_("unable to write new_index file"));
442 fd
= hold_lock_file_for_update(&false_lock
,
443 git_path("next-index-%"PRIuMAX
,
444 (uintmax_t) getpid()),
447 create_base_index(current_head
);
448 add_remove_files(&partial
);
449 refresh_cache(REFRESH_QUIET
);
451 if (write_cache(fd
, active_cache
, active_nr
) ||
452 close_lock_file(&false_lock
))
453 die(_("unable to write temporary index file"));
456 read_cache_from(false_lock
.filename
);
458 return false_lock
.filename
;
461 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
464 unsigned char sha1
[20];
466 if (s
->relative_paths
)
471 s
->reference
= "HEAD^1";
473 s
->verbose
= verbose
;
474 s
->index_file
= index_file
;
477 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
479 wt_status_collect(s
);
481 switch (status_format
) {
482 case STATUS_FORMAT_SHORT
:
483 wt_shortstatus_print(s
);
485 case STATUS_FORMAT_PORCELAIN
:
486 wt_porcelain_print(s
);
488 case STATUS_FORMAT_UNSPECIFIED
:
489 die("BUG: finalize_deferred_config() should have been called");
491 case STATUS_FORMAT_NONE
:
492 case STATUS_FORMAT_LONG
:
497 return s
->commitable
;
500 static int is_a_merge(const struct commit
*current_head
)
502 return !!(current_head
->parents
&& current_head
->parents
->next
);
505 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
507 struct strbuf buf
= STRBUF_INIT
;
509 strbuf_addch(&buf
, hack
);
510 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
511 setenv(var
, buf
.buf
, 1);
512 strbuf_release(&buf
);
515 static int sane_ident_split(struct ident_split
*person
)
517 if (!person
->name_begin
|| !person
->name_end
||
518 person
->name_begin
== person
->name_end
)
519 return 0; /* no human readable name */
520 if (!person
->mail_begin
|| !person
->mail_end
||
521 person
->mail_begin
== person
->mail_end
)
522 return 0; /* no usable mail */
523 if (!person
->date_begin
|| !person
->date_end
||
524 !person
->tz_begin
|| !person
->tz_end
)
529 static void determine_author_info(struct strbuf
*author_ident
)
531 char *name
, *email
, *date
;
532 struct ident_split author
;
534 name
= getenv("GIT_AUTHOR_NAME");
535 email
= getenv("GIT_AUTHOR_EMAIL");
536 date
= getenv("GIT_AUTHOR_DATE");
538 if (author_message
) {
539 const char *a
, *lb
, *rb
, *eol
;
542 a
= strstr(author_message_buffer
, "\nauthor ");
544 die(_("invalid commit: %s"), author_message
);
546 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
547 rb
= strchrnul(lb
, '>');
548 eol
= strchrnul(rb
, '\n');
549 if (!*lb
|| !*rb
|| !*eol
)
550 die(_("invalid commit: %s"), author_message
);
552 if (lb
== a
+ strlen("\nauthor "))
553 /* \nauthor <foo@example.com> */
554 name
= xcalloc(1, 1);
556 name
= xmemdupz(a
+ strlen("\nauthor "),
558 (a
+ strlen("\nauthor "))));
559 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
560 len
= eol
- (rb
+ strlen("> "));
561 date
= xmalloc(len
+ 2);
563 memcpy(date
+ 1, rb
+ strlen("> "), len
);
564 date
[len
+ 1] = '\0';
568 const char *lb
= strstr(force_author
, " <");
569 const char *rb
= strchr(force_author
, '>');
572 die(_("malformed --author parameter"));
573 name
= xstrndup(force_author
, lb
- force_author
);
574 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
579 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
580 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
581 sane_ident_split(&author
)) {
582 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
583 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
584 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
588 static char *cut_ident_timestamp_part(char *string
)
590 char *ket
= strrchr(string
, '>');
591 if (!ket
|| ket
[1] != ' ')
592 die(_("Malformed ident string: '%s'"), string
);
597 static int prepare_to_commit(const char *index_file
, const char *prefix
,
598 struct commit
*current_head
,
600 struct strbuf
*author_ident
)
603 struct strbuf committer_ident
= STRBUF_INIT
;
604 int commitable
, saved_color_setting
;
605 struct strbuf sb
= STRBUF_INIT
;
607 const char *hook_arg1
= NULL
;
608 const char *hook_arg2
= NULL
;
610 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
612 /* This checks and barfs if author is badly specified */
613 determine_author_info(author_ident
);
615 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
618 if (squash_message
) {
620 * Insert the proper subject line before other commit
621 * message options add their content.
623 if (use_message
&& !strcmp(use_message
, squash_message
))
624 strbuf_addstr(&sb
, "squash! ");
626 struct pretty_print_context ctx
= {0};
628 c
= lookup_commit_reference_by_name(squash_message
);
630 die(_("could not lookup commit %s"), squash_message
);
631 ctx
.output_encoding
= get_commit_output_encoding();
632 format_commit_message(c
, "squash! %s\n\n", &sb
,
638 strbuf_addbuf(&sb
, &message
);
639 hook_arg1
= "message";
640 } else if (logfile
&& !strcmp(logfile
, "-")) {
642 fprintf(stderr
, _("(reading log message from standard input)\n"));
643 if (strbuf_read(&sb
, 0, 0) < 0)
644 die_errno(_("could not read log from standard input"));
645 hook_arg1
= "message";
646 } else if (logfile
) {
647 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
648 die_errno(_("could not read log file '%s'"),
650 hook_arg1
= "message";
651 } else if (use_message
) {
652 buffer
= strstr(use_message_buffer
, "\n\n");
653 if (!use_editor
&& (!buffer
|| buffer
[2] == '\0'))
654 die(_("commit has empty message"));
655 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
656 hook_arg1
= "commit";
657 hook_arg2
= use_message
;
658 } else if (fixup_message
) {
659 struct pretty_print_context ctx
= {0};
660 struct commit
*commit
;
661 commit
= lookup_commit_reference_by_name(fixup_message
);
663 die(_("could not lookup commit %s"), fixup_message
);
664 ctx
.output_encoding
= get_commit_output_encoding();
665 format_commit_message(commit
, "fixup! %s\n\n",
667 hook_arg1
= "message";
668 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
669 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
670 die_errno(_("could not read MERGE_MSG"));
672 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
673 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
674 die_errno(_("could not read SQUASH_MSG"));
675 hook_arg1
= "squash";
676 } else if (template_file
) {
677 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
678 die_errno(_("could not read '%s'"), template_file
);
679 hook_arg1
= "template";
680 clean_message_contents
= 0;
684 * The remaining cases don't modify the template message, but
685 * just set the argument(s) to the prepare-commit-msg hook.
687 else if (whence
== FROM_MERGE
)
689 else if (whence
== FROM_CHERRY_PICK
) {
690 hook_arg1
= "commit";
691 hook_arg2
= "CHERRY_PICK_HEAD";
694 if (squash_message
) {
696 * If squash_commit was used for the commit subject,
697 * then we're possibly hijacking other commit log options.
698 * Reset the hook args to tell the real story.
700 hook_arg1
= "message";
704 s
->fp
= fopen(git_path(commit_editmsg
), "w");
706 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
709 * Most hints are counter-productive when the commit has
714 if (clean_message_contents
)
719 * See if we have a Conflicts: block at the end. If yes, count
720 * its size, so we can ignore it.
722 int ignore_footer
= 0;
723 int i
, eol
, previous
= 0;
726 for (i
= 0; i
< sb
.len
; i
++) {
727 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
732 if (!prefixcmp(sb
.buf
+ previous
, "\nConflicts:\n")) {
733 ignore_footer
= sb
.len
- previous
;
741 append_signoff(&sb
, ignore_footer
, 0);
744 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
745 die_errno(_("could not write commit template"));
749 /* This checks if committer ident is explicitly given */
750 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
751 if (use_editor
&& include_status
) {
752 char *ai_tmp
, *ci_tmp
;
753 if (whence
!= FROM_COMMIT
)
754 status_printf_ln(s
, GIT_COLOR_NORMAL
,
757 "It looks like you may be committing a merge.\n"
758 "If this is not correct, please remove the file\n"
762 "It looks like you may be committing a cherry-pick.\n"
763 "If this is not correct, please remove the file\n"
766 git_path(whence
== FROM_MERGE
768 : "CHERRY_PICK_HEAD"));
770 fprintf(s
->fp
, "\n");
771 if (cleanup_mode
== CLEANUP_ALL
)
772 status_printf(s
, GIT_COLOR_NORMAL
,
773 _("Please enter the commit message for your changes."
774 " Lines starting\nwith '%c' will be ignored, and an empty"
775 " message aborts the commit.\n"), comment_line_char
);
776 else /* CLEANUP_SPACE, that is. */
777 status_printf(s
, GIT_COLOR_NORMAL
,
778 _("Please enter the commit message for your changes."
780 "with '%c' will be kept; you may remove them"
781 " yourself if you want to.\n"
782 "An empty message aborts the commit.\n"), comment_line_char
);
783 if (only_include_assumed
)
784 status_printf_ln(s
, GIT_COLOR_NORMAL
,
785 "%s", only_include_assumed
);
787 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
788 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
789 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
790 status_printf_ln(s
, GIT_COLOR_NORMAL
,
793 ident_shown
++ ? "" : "\n",
796 if (!committer_ident_sufficiently_given())
797 status_printf_ln(s
, GIT_COLOR_NORMAL
,
800 ident_shown
++ ? "" : "\n",
801 committer_ident
.buf
);
804 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
806 saved_color_setting
= s
->use_color
;
808 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
809 s
->use_color
= saved_color_setting
;
814 unsigned char sha1
[20];
815 const char *parent
= "HEAD";
817 if (!active_nr
&& read_cache() < 0)
818 die(_("Cannot read index"));
823 if (get_sha1(parent
, sha1
))
824 commitable
= !!active_nr
;
826 commitable
= index_differs_from(parent
, 0);
828 strbuf_release(&committer_ident
);
833 * Reject an attempt to record a non-merge empty commit without
834 * explicit --allow-empty. In the cherry-pick case, it may be
835 * empty due to conflict resolution, which the user should okay.
837 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
838 !(amend
&& is_a_merge(current_head
))) {
839 run_status(stdout
, index_file
, prefix
, 0, s
);
841 fputs(_(empty_amend_advice
), stderr
);
842 else if (whence
== FROM_CHERRY_PICK
) {
843 fputs(_(empty_cherry_pick_advice
), stderr
);
844 if (!sequencer_in_use
)
845 fputs(_(empty_cherry_pick_advice_single
), stderr
);
847 fputs(_(empty_cherry_pick_advice_multi
), stderr
);
853 * Re-read the index as pre-commit hook could have updated it,
854 * and write it out as a tree. We must do this before we invoke
855 * the editor and after we invoke run_status above.
858 read_cache_from(index_file
);
859 if (update_main_cache_tree(0)) {
860 error(_("Error building trees"));
864 if (run_hook(index_file
, "prepare-commit-msg",
865 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
869 char index
[PATH_MAX
];
870 const char *env
[2] = { NULL
};
872 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
873 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
875 _("Please supply the message using either -m or -F option.\n"));
881 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
888 static int rest_is_empty(struct strbuf
*sb
, int start
)
893 /* Check if the rest is just whitespace and Signed-of-by's. */
894 for (i
= start
; i
< sb
->len
; i
++) {
895 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
901 if (strlen(sign_off_header
) <= eol
- i
&&
902 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
907 if (!isspace(sb
->buf
[i
++]))
915 * Find out if the message in the strbuf contains only whitespace and
916 * Signed-off-by lines.
918 static int message_is_empty(struct strbuf
*sb
)
920 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
922 return rest_is_empty(sb
, 0);
926 * See if the user edited the message in the editor or left what
927 * was in the template intact
929 static int template_untouched(struct strbuf
*sb
)
931 struct strbuf tmpl
= STRBUF_INIT
;
934 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
937 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
940 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
941 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
944 strbuf_release(&tmpl
);
945 return rest_is_empty(sb
, start
- sb
->buf
);
948 static const char *find_author_by_nickname(const char *name
)
950 struct rev_info revs
;
951 struct commit
*commit
;
952 struct strbuf buf
= STRBUF_INIT
;
956 init_revisions(&revs
, NULL
);
957 strbuf_addf(&buf
, "--author=%s", name
);
962 setup_revisions(ac
, av
, &revs
, NULL
);
963 prepare_revision_walk(&revs
);
964 commit
= get_revision(&revs
);
966 struct pretty_print_context ctx
= {0};
967 ctx
.date_mode
= DATE_NORMAL
;
968 strbuf_release(&buf
);
969 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
970 return strbuf_detach(&buf
, NULL
);
972 die(_("No existing author found with '%s'"), name
);
976 static void handle_untracked_files_arg(struct wt_status
*s
)
978 if (!untracked_files_arg
)
979 ; /* default already initialized */
980 else if (!strcmp(untracked_files_arg
, "no"))
981 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
982 else if (!strcmp(untracked_files_arg
, "normal"))
983 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
984 else if (!strcmp(untracked_files_arg
, "all"))
985 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
987 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
990 static const char *read_commit_message(const char *name
)
993 struct commit
*commit
;
995 commit
= lookup_commit_reference_by_name(name
);
997 die(_("could not lookup commit %s"), name
);
998 out_enc
= get_commit_output_encoding();
999 return logmsg_reencode(commit
, NULL
, out_enc
);
1003 * Enumerate what needs to be propagated when --porcelain
1004 * is not in effect here.
1006 static struct status_deferred_config
{
1007 enum status_format status_format
;
1009 } status_deferred_config
= {
1010 STATUS_FORMAT_UNSPECIFIED
,
1011 -1 /* unspecified */
1014 static void finalize_deferred_config(struct wt_status
*s
)
1016 int use_deferred_config
= (status_format
!= STATUS_FORMAT_PORCELAIN
&&
1017 !s
->null_termination
);
1019 if (s
->null_termination
) {
1020 if (status_format
== STATUS_FORMAT_NONE
||
1021 status_format
== STATUS_FORMAT_UNSPECIFIED
)
1022 status_format
= STATUS_FORMAT_PORCELAIN
;
1023 else if (status_format
== STATUS_FORMAT_LONG
)
1024 die(_("--long and -z are incompatible"));
1027 if (use_deferred_config
&& status_format
== STATUS_FORMAT_UNSPECIFIED
)
1028 status_format
= status_deferred_config
.status_format
;
1029 if (status_format
== STATUS_FORMAT_UNSPECIFIED
)
1030 status_format
= STATUS_FORMAT_NONE
;
1032 if (use_deferred_config
&& s
->show_branch
< 0)
1033 s
->show_branch
= status_deferred_config
.show_branch
;
1034 if (s
->show_branch
< 0)
1038 static int parse_and_validate_options(int argc
, const char *argv
[],
1039 const struct option
*options
,
1040 const char * const usage
[],
1042 struct commit
*current_head
,
1043 struct wt_status
*s
)
1047 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
1048 finalize_deferred_config(s
);
1050 if (force_author
&& !strchr(force_author
, '>'))
1051 force_author
= find_author_by_nickname(force_author
);
1053 if (force_author
&& renew_authorship
)
1054 die(_("Using both --reset-author and --author does not make sense"));
1056 if (logfile
|| have_option_m
|| use_message
|| fixup_message
)
1059 use_editor
= edit_flag
;
1061 setenv("GIT_EDITOR", ":", 1);
1063 /* Sanity check options */
1064 if (amend
&& !current_head
)
1065 die(_("You have nothing to amend."));
1066 if (amend
&& whence
!= FROM_COMMIT
) {
1067 if (whence
== FROM_MERGE
)
1068 die(_("You are in the middle of a merge -- cannot amend."));
1069 else if (whence
== FROM_CHERRY_PICK
)
1070 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1072 if (fixup_message
&& squash_message
)
1073 die(_("Options --squash and --fixup cannot be used together"));
1083 die(_("Only one of -c/-C/-F/--fixup can be used."));
1084 if (message
.len
&& f
> 0)
1085 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1086 if (f
|| message
.len
)
1087 template_file
= NULL
;
1089 use_message
= edit_message
;
1090 if (amend
&& !use_message
&& !fixup_message
)
1091 use_message
= "HEAD";
1092 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1093 die(_("--reset-author can be used only with -C, -c or --amend."));
1095 use_message_buffer
= read_commit_message(use_message
);
1096 if (!renew_authorship
) {
1097 author_message
= use_message
;
1098 author_message_buffer
= use_message_buffer
;
1101 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1102 author_message
= "CHERRY_PICK_HEAD";
1103 author_message_buffer
= read_commit_message(author_message
);
1106 if (patch_interactive
)
1109 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1110 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1111 if (argc
== 0 && (also
|| (only
&& !amend
)))
1112 die(_("No paths with --include/--only does not make sense."));
1113 if (argc
== 0 && only
&& amend
)
1114 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1115 if (argc
> 0 && !also
&& !only
)
1116 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1117 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1118 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1119 else if (!strcmp(cleanup_arg
, "verbatim"))
1120 cleanup_mode
= CLEANUP_NONE
;
1121 else if (!strcmp(cleanup_arg
, "whitespace"))
1122 cleanup_mode
= CLEANUP_SPACE
;
1123 else if (!strcmp(cleanup_arg
, "strip"))
1124 cleanup_mode
= CLEANUP_ALL
;
1126 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1128 handle_untracked_files_arg(s
);
1130 if (all
&& argc
> 0)
1131 die(_("Paths with -a does not make sense."));
1133 if (status_format
!= STATUS_FORMAT_NONE
)
1139 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1140 const struct commit
*current_head
, struct wt_status
*s
)
1143 const char *index_file
;
1145 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1146 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1147 rollback_index_files();
1149 return commitable
? 0 : 1;
1152 static int parse_status_slot(const char *var
, int offset
)
1154 if (!strcasecmp(var
+offset
, "header"))
1155 return WT_STATUS_HEADER
;
1156 if (!strcasecmp(var
+offset
, "branch"))
1157 return WT_STATUS_ONBRANCH
;
1158 if (!strcasecmp(var
+offset
, "updated")
1159 || !strcasecmp(var
+offset
, "added"))
1160 return WT_STATUS_UPDATED
;
1161 if (!strcasecmp(var
+offset
, "changed"))
1162 return WT_STATUS_CHANGED
;
1163 if (!strcasecmp(var
+offset
, "untracked"))
1164 return WT_STATUS_UNTRACKED
;
1165 if (!strcasecmp(var
+offset
, "nobranch"))
1166 return WT_STATUS_NOBRANCH
;
1167 if (!strcasecmp(var
+offset
, "unmerged"))
1168 return WT_STATUS_UNMERGED
;
1172 static int git_status_config(const char *k
, const char *v
, void *cb
)
1174 struct wt_status
*s
= cb
;
1176 if (!prefixcmp(k
, "column."))
1177 return git_column_config(k
, v
, "status", &s
->colopts
);
1178 if (!strcmp(k
, "status.submodulesummary")) {
1180 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1181 if (is_bool
&& s
->submodule_summary
)
1182 s
->submodule_summary
= -1;
1185 if (!strcmp(k
, "status.short")) {
1186 if (git_config_bool(k
, v
))
1187 status_deferred_config
.status_format
= STATUS_FORMAT_SHORT
;
1189 status_deferred_config
.status_format
= STATUS_FORMAT_NONE
;
1192 if (!strcmp(k
, "status.branch")) {
1193 status_deferred_config
.show_branch
= git_config_bool(k
, v
);
1196 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1197 s
->use_color
= git_config_colorbool(k
, v
);
1200 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1201 int slot
= parse_status_slot(k
, 13);
1205 return config_error_nonbool(k
);
1206 color_parse(v
, k
, s
->color_palette
[slot
]);
1209 if (!strcmp(k
, "status.relativepaths")) {
1210 s
->relative_paths
= git_config_bool(k
, v
);
1213 if (!strcmp(k
, "status.showuntrackedfiles")) {
1215 return config_error_nonbool(k
);
1216 else if (!strcmp(v
, "no"))
1217 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1218 else if (!strcmp(v
, "normal"))
1219 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1220 else if (!strcmp(v
, "all"))
1221 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1223 return error(_("Invalid untracked files mode '%s'"), v
);
1226 return git_diff_ui_config(k
, v
, NULL
);
1229 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1231 static struct wt_status s
;
1233 unsigned char sha1
[20];
1234 static struct option builtin_status_options
[] = {
1235 OPT__VERBOSE(&verbose
, N_("be verbose")),
1236 OPT_SET_INT('s', "short", &status_format
,
1237 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1238 OPT_BOOL('b', "branch", &s
.show_branch
,
1239 N_("show branch information")),
1240 OPT_SET_INT(0, "porcelain", &status_format
,
1241 N_("machine-readable output"),
1242 STATUS_FORMAT_PORCELAIN
),
1243 OPT_SET_INT(0, "long", &status_format
,
1244 N_("show status in long format (default)"),
1245 STATUS_FORMAT_LONG
),
1246 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1247 N_("terminate entries with NUL")),
1248 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1250 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1251 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1252 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1253 N_("show ignored files")),
1254 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1255 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1256 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1257 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1261 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1262 usage_with_options(builtin_status_usage
, builtin_status_options
);
1264 status_init_config(&s
, git_status_config
);
1265 argc
= parse_options(argc
, argv
, prefix
,
1266 builtin_status_options
,
1267 builtin_status_usage
, 0);
1268 finalize_colopts(&s
.colopts
, -1);
1269 finalize_deferred_config(&s
);
1271 handle_untracked_files_arg(&s
);
1272 if (show_ignored_in_status
)
1273 s
.show_ignored_files
= 1;
1275 s
.pathspec
= get_pathspec(prefix
, argv
);
1277 read_cache_preload(s
.pathspec
);
1278 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1280 fd
= hold_locked_index(&index_lock
, 0);
1282 update_index_if_able(&the_index
, &index_lock
);
1284 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1285 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1286 wt_status_collect(&s
);
1288 if (s
.relative_paths
)
1291 switch (status_format
) {
1292 case STATUS_FORMAT_SHORT
:
1293 wt_shortstatus_print(&s
);
1295 case STATUS_FORMAT_PORCELAIN
:
1296 wt_porcelain_print(&s
);
1298 case STATUS_FORMAT_UNSPECIFIED
:
1299 die("BUG: finalize_deferred_config() should have been called");
1301 case STATUS_FORMAT_NONE
:
1302 case STATUS_FORMAT_LONG
:
1303 s
.verbose
= verbose
;
1304 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1305 wt_status_print(&s
);
1311 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1314 struct rev_info rev
;
1315 struct commit
*commit
;
1316 struct strbuf format
= STRBUF_INIT
;
1317 unsigned char junk_sha1
[20];
1319 struct pretty_print_context pctx
= {0};
1320 struct strbuf author_ident
= STRBUF_INIT
;
1321 struct strbuf committer_ident
= STRBUF_INIT
;
1323 commit
= lookup_commit(sha1
);
1325 die(_("couldn't look up newly created commit"));
1326 if (!commit
|| parse_commit(commit
))
1327 die(_("could not parse newly created commit"));
1329 strbuf_addstr(&format
, "format:%h] %s");
1331 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1332 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1333 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1334 strbuf_addstr(&format
, "\n Author: ");
1335 strbuf_addbuf_percentquote(&format
, &author_ident
);
1337 if (!committer_ident_sufficiently_given()) {
1338 strbuf_addstr(&format
, "\n Committer: ");
1339 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1340 if (advice_implicit_identity
) {
1341 strbuf_addch(&format
, '\n');
1342 strbuf_addstr(&format
, _(implicit_ident_advice
));
1345 strbuf_release(&author_ident
);
1346 strbuf_release(&committer_ident
);
1348 init_revisions(&rev
, prefix
);
1349 setup_revisions(0, NULL
, &rev
, NULL
);
1352 rev
.diffopt
.output_format
=
1353 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1355 rev
.verbose_header
= 1;
1356 rev
.show_root_diff
= 1;
1357 get_commit_format(format
.buf
, &rev
);
1358 rev
.always_show_header
= 0;
1359 rev
.diffopt
.detect_rename
= 1;
1360 rev
.diffopt
.break_opt
= 0;
1361 diff_setup_done(&rev
.diffopt
);
1363 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1365 !prefixcmp(head
, "refs/heads/") ?
1367 !strcmp(head
, "HEAD") ?
1368 _("detached HEAD") :
1370 initial_commit
? _(" (root-commit)") : "");
1372 if (!log_tree_commit(&rev
, commit
)) {
1373 rev
.always_show_header
= 1;
1374 rev
.use_terminator
= 1;
1375 log_tree_commit(&rev
, commit
);
1378 strbuf_release(&format
);
1381 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1383 struct wt_status
*s
= cb
;
1386 if (!strcmp(k
, "commit.template"))
1387 return git_config_pathname(&template_file
, k
, v
);
1388 if (!strcmp(k
, "commit.status")) {
1389 include_status
= git_config_bool(k
, v
);
1392 if (!strcmp(k
, "commit.cleanup"))
1393 return git_config_string(&cleanup_arg
, k
, v
);
1395 status
= git_gpg_config(k
, v
, NULL
);
1398 return git_status_config(k
, v
, s
);
1401 static int run_rewrite_hook(const unsigned char *oldsha1
,
1402 const unsigned char *newsha1
)
1404 /* oldsha1 SP newsha1 LF NUL */
1405 static char buf
[2*40 + 3];
1406 struct child_process proc
;
1407 const char *argv
[3];
1411 argv
[0] = find_hook("post-rewrite");
1418 memset(&proc
, 0, sizeof(proc
));
1421 proc
.stdout_to_stderr
= 1;
1423 code
= start_command(&proc
);
1426 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1427 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1428 write_in_full(proc
.in
, buf
, n
);
1430 return finish_command(&proc
);
1433 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1435 static struct wt_status s
;
1436 static struct option builtin_commit_options
[] = {
1437 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1438 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1440 OPT_GROUP(N_("Commit message options")),
1441 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1442 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1443 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1444 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1445 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1446 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1447 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1448 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1449 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1450 OPT_BOOLEAN('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1451 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1452 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1453 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1454 OPT_BOOLEAN(0, "status", &include_status
, N_("include status in commit message template")),
1455 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key id"),
1456 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1457 /* end commit message options */
1459 OPT_GROUP(N_("Commit contents options")),
1460 OPT_BOOLEAN('a', "all", &all
, N_("commit all changed files")),
1461 OPT_BOOLEAN('i', "include", &also
, N_("add specified files to index for commit")),
1462 OPT_BOOLEAN(0, "interactive", &interactive
, N_("interactively add files")),
1463 OPT_BOOLEAN('p', "patch", &patch_interactive
, N_("interactively add changes")),
1464 OPT_BOOLEAN('o', "only", &only
, N_("commit only specified files")),
1465 OPT_BOOLEAN('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1466 OPT_BOOLEAN(0, "dry-run", &dry_run
, N_("show what would be committed")),
1467 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1468 STATUS_FORMAT_SHORT
),
1469 OPT_BOOL(0, "branch", &s
.show_branch
, N_("show branch information")),
1470 OPT_SET_INT(0, "porcelain", &status_format
,
1471 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1472 OPT_SET_INT(0, "long", &status_format
,
1473 N_("show status in long format (default)"),
1474 STATUS_FORMAT_LONG
),
1475 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1476 N_("terminate entries with NUL")),
1477 OPT_BOOLEAN(0, "amend", &amend
, N_("amend previous commit")),
1478 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1479 { 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" },
1480 /* end commit contents options */
1482 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
1483 N_("ok to record an empty change"),
1484 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1485 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
1486 N_("ok to record a change with an empty message"),
1487 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1492 struct strbuf sb
= STRBUF_INIT
;
1493 struct strbuf author_ident
= STRBUF_INIT
;
1494 const char *index_file
, *reflog_msg
;
1496 unsigned char sha1
[20];
1497 struct ref_lock
*ref_lock
;
1498 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1499 struct stat statbuf
;
1500 int allow_fast_forward
= 1;
1501 struct commit
*current_head
= NULL
;
1502 struct commit_extra_header
*extra
= NULL
;
1504 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1505 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1507 status_init_config(&s
, git_commit_config
);
1508 status_format
= STATUS_FORMAT_NONE
; /* Ignore status.short */
1511 if (get_sha1("HEAD", sha1
))
1512 current_head
= NULL
;
1514 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1515 if (!current_head
|| parse_commit(current_head
))
1516 die(_("could not parse HEAD commit"));
1518 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1519 builtin_commit_usage
,
1520 prefix
, current_head
, &s
);
1522 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1523 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1525 /* Set up everything for writing the commit object. This includes
1526 running hooks, writing the trees, and interacting with the user. */
1527 if (!prepare_to_commit(index_file
, prefix
,
1528 current_head
, &s
, &author_ident
)) {
1529 rollback_index_files();
1533 /* Determine parents */
1534 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1535 if (!current_head
) {
1537 reflog_msg
= "commit (initial)";
1539 struct commit_list
*c
;
1542 reflog_msg
= "commit (amend)";
1543 for (c
= current_head
->parents
; c
; c
= c
->next
)
1544 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1545 } else if (whence
== FROM_MERGE
) {
1546 struct strbuf m
= STRBUF_INIT
;
1550 reflog_msg
= "commit (merge)";
1551 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1552 fp
= fopen(git_path("MERGE_HEAD"), "r");
1554 die_errno(_("could not open '%s' for reading"),
1555 git_path("MERGE_HEAD"));
1556 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1557 struct commit
*parent
;
1559 parent
= get_merge_parent(m
.buf
);
1561 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1562 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1566 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1567 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1568 die_errno(_("could not read MERGE_MODE"));
1569 if (!strcmp(sb
.buf
, "no-ff"))
1570 allow_fast_forward
= 0;
1572 if (allow_fast_forward
)
1573 parents
= reduce_heads(parents
);
1576 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1577 ? "commit (cherry-pick)"
1579 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1582 /* Finally, get the commit message */
1584 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1585 int saved_errno
= errno
;
1586 rollback_index_files();
1587 die(_("could not read commit message: %s"), strerror(saved_errno
));
1590 /* Truncate the message just before the diff, if any. */
1592 p
= strstr(sb
.buf
, "\ndiff --git ");
1594 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1597 if (cleanup_mode
!= CLEANUP_NONE
)
1598 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1599 if (template_untouched(&sb
) && !allow_empty_message
) {
1600 rollback_index_files();
1601 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1604 if (message_is_empty(&sb
) && !allow_empty_message
) {
1605 rollback_index_files();
1606 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1611 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1612 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1614 struct commit_extra_header
**tail
= &extra
;
1615 append_merge_tag_headers(parents
, &tail
);
1618 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1619 author_ident
.buf
, sign_commit
, extra
)) {
1620 rollback_index_files();
1621 die(_("failed to write commit object"));
1623 strbuf_release(&author_ident
);
1624 free_commit_extra_headers(extra
);
1626 ref_lock
= lock_any_ref_for_update("HEAD",
1629 : current_head
->object
.sha1
,
1632 nl
= strchr(sb
.buf
, '\n');
1634 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1636 strbuf_addch(&sb
, '\n');
1637 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1638 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1641 rollback_index_files();
1642 die(_("cannot lock HEAD ref"));
1644 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1645 rollback_index_files();
1646 die(_("cannot update HEAD ref"));
1649 unlink(git_path("CHERRY_PICK_HEAD"));
1650 unlink(git_path("REVERT_HEAD"));
1651 unlink(git_path("MERGE_HEAD"));
1652 unlink(git_path("MERGE_MSG"));
1653 unlink(git_path("MERGE_MODE"));
1654 unlink(git_path("SQUASH_MSG"));
1656 if (commit_index_files())
1657 die (_("Repository has been updated, but unable to write\n"
1658 "new_index file. Check that disk is not full or quota is\n"
1659 "not exceeded, and then \"git reset HEAD\" to recover."));
1662 run_hook(get_index_file(), "post-commit", NULL
);
1663 if (amend
&& !no_post_rewrite
) {
1664 struct notes_rewrite_cfg
*cfg
;
1665 cfg
= init_copy_notes_for_rewrite("amend");
1667 /* we are amending, so current_head is not NULL */
1668 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1669 finish_copy_notes_for_rewrite(cfg
, "Notes added by 'git commit --amend'");
1671 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1674 print_summary(prefix
, sha1
, !current_head
);