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"
29 static const char * const builtin_commit_usage
[] = {
30 "git commit [options] [--] <filepattern>...",
34 static const char * const builtin_status_usage
[] = {
35 "git status [options] [--] <filepattern>...",
39 static const char implicit_ident_advice
[] =
40 "Your name and email address were configured automatically based\n"
41 "on your username and hostname. Please check that they are accurate.\n"
42 "You can suppress this message by setting them explicitly:\n"
44 " git config --global user.name \"Your Name\"\n"
45 " git config --global user.email you@example.com\n"
47 "If the identity used for this commit is wrong, you can fix it with:\n"
49 " git commit --amend --author='Your Name <you@example.com>'\n";
51 static const char empty_amend_advice
[] =
52 "You asked to amend the most recent commit, but doing so would make\n"
53 "it empty. You can repeat your command with --allow-empty, or you can\n"
54 "remove the commit entirely with \"git reset HEAD^\".\n";
56 static unsigned char head_sha1
[20];
58 static char *use_message_buffer
;
59 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
60 static struct lock_file index_lock
; /* real index */
61 static struct lock_file false_lock
; /* used only for partial commits */
68 static const char *logfile
, *force_author
;
69 static const char *template_file
;
70 static char *edit_message
, *use_message
;
71 static char *author_name
, *author_email
, *author_date
;
72 static int all
, edit_flag
, also
, interactive
, only
, amend
, signoff
;
73 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
74 static int no_post_rewrite
;
75 static char *untracked_files_arg
, *force_date
;
77 * The default commit message cleanup mode will remove the lines
78 * beginning with # (shell comments) and leading and trailing
79 * whitespaces (empty lines or containing only whitespaces)
80 * if editor is used, and only the whitespaces if the message
81 * is specified explicitly.
88 static char *cleanup_arg
;
90 static int use_editor
= 1, initial_commit
, in_merge
, include_status
= 1;
91 static const char *only_include_assumed
;
92 static struct strbuf message
;
94 static int null_termination
;
98 STATUS_FORMAT_PORCELAIN
,
99 } status_format
= STATUS_FORMAT_LONG
;
101 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
103 struct strbuf
*buf
= opt
->value
;
105 strbuf_setlen(buf
, 0);
107 strbuf_addstr(buf
, arg
);
108 strbuf_addstr(buf
, "\n\n");
113 static struct option builtin_commit_options
[] = {
115 OPT__VERBOSE(&verbose
),
117 OPT_GROUP("Commit message options"),
118 OPT_FILENAME('F', "file", &logfile
, "read log from file"),
119 OPT_STRING(0, "author", &force_author
, "AUTHOR", "override author for commit"),
120 OPT_STRING(0, "date", &force_date
, "DATE", "override date for commit"),
121 OPT_CALLBACK('m', "message", &message
, "MESSAGE", "specify commit message", opt_parse_m
),
122 OPT_STRING('c', "reedit-message", &edit_message
, "COMMIT", "reuse and edit message from specified commit"),
123 OPT_STRING('C', "reuse-message", &use_message
, "COMMIT", "reuse message from specified commit"),
124 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C-c/--amend)"),
125 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
126 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
127 OPT_BOOLEAN('e', "edit", &edit_flag
, "force edit of commit"),
128 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
129 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
130 /* end commit message options */
132 OPT_GROUP("Commit contents options"),
133 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
134 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
135 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
136 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
137 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
138 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
139 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
140 STATUS_FORMAT_SHORT
),
141 OPT_SET_INT(0, "porcelain", &status_format
,
142 "show porcelain output format", STATUS_FORMAT_PORCELAIN
),
143 OPT_BOOLEAN('z', "null", &null_termination
,
144 "terminate entries with NUL"),
145 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
146 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
147 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
148 OPT_BOOLEAN(0, "allow-empty", &allow_empty
, "ok to record an empty change"),
149 /* end commit contents options */
154 static void rollback_index_files(void)
156 switch (commit_style
) {
158 break; /* nothing to do */
160 rollback_lock_file(&index_lock
);
163 rollback_lock_file(&index_lock
);
164 rollback_lock_file(&false_lock
);
169 static int commit_index_files(void)
173 switch (commit_style
) {
175 break; /* nothing to do */
177 err
= commit_lock_file(&index_lock
);
180 err
= commit_lock_file(&index_lock
);
181 rollback_lock_file(&false_lock
);
189 * Take a union of paths in the index and the named tree (typically, "HEAD"),
190 * and return the paths that match the given pattern in list.
192 static int list_paths(struct string_list
*list
, const char *with_tree
,
193 const char *prefix
, const char **pattern
)
198 for (i
= 0; pattern
[i
]; i
++)
203 overlay_tree_on_cache(with_tree
, prefix
);
205 for (i
= 0; i
< active_nr
; i
++) {
206 struct cache_entry
*ce
= active_cache
[i
];
207 struct string_list_item
*item
;
209 if (ce
->ce_flags
& CE_UPDATE
)
211 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
213 item
= string_list_insert(ce
->name
, list
);
214 if (ce_skip_worktree(ce
))
215 item
->util
= item
; /* better a valid pointer than a fake one */
218 return report_path_error(m
, pattern
, prefix
? strlen(prefix
) : 0);
221 static void add_remove_files(struct string_list
*list
)
224 for (i
= 0; i
< list
->nr
; i
++) {
226 struct string_list_item
*p
= &(list
->items
[i
]);
228 /* p->util is skip-worktree */
232 if (!lstat(p
->string
, &st
)) {
233 if (add_to_cache(p
->string
, &st
, 0))
234 die("updating files failed");
236 remove_file_from_cache(p
->string
);
240 static void create_base_index(void)
243 struct unpack_trees_options opts
;
246 if (initial_commit
) {
251 memset(&opts
, 0, sizeof(opts
));
255 opts
.src_index
= &the_index
;
256 opts
.dst_index
= &the_index
;
258 opts
.fn
= oneway_merge
;
259 tree
= parse_tree_indirect(head_sha1
);
261 die("failed to unpack HEAD tree object");
263 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
264 if (unpack_trees(1, &t
, &opts
))
265 exit(128); /* We've already reported the error, finish dying */
268 static void refresh_cache_or_die(int refresh_flags
)
271 * refresh_flags contains REFRESH_QUIET, so the only errors
272 * are for unmerged entries.
274 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
275 die_resolve_conflict("commit");
278 static char *prepare_index(int argc
, const char **argv
, const char *prefix
, int is_status
)
281 struct string_list partial
;
282 const char **pathspec
= NULL
;
283 int refresh_flags
= REFRESH_QUIET
;
286 refresh_flags
|= REFRESH_UNMERGED
;
288 if (interactive_add(argc
, argv
, prefix
) != 0)
289 die("interactive add failed");
290 if (read_cache_preload(NULL
) < 0)
291 die("index file corrupt");
292 commit_style
= COMMIT_AS_IS
;
293 return get_index_file();
297 pathspec
= get_pathspec(prefix
, argv
);
299 if (read_cache_preload(pathspec
) < 0)
300 die("index file corrupt");
303 * Non partial, non as-is commit.
305 * (1) get the real index;
306 * (2) update the_index as necessary;
307 * (3) write the_index out to the real index (still locked);
308 * (4) return the name of the locked index file.
310 * The caller should run hooks on the locked real index, and
311 * (A) if all goes well, commit the real index;
312 * (B) on failure, rollback the real index.
314 if (all
|| (also
&& pathspec
&& *pathspec
)) {
315 fd
= hold_locked_index(&index_lock
, 1);
316 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
317 refresh_cache_or_die(refresh_flags
);
318 if (write_cache(fd
, active_cache
, active_nr
) ||
319 close_lock_file(&index_lock
))
320 die("unable to write new_index file");
321 commit_style
= COMMIT_NORMAL
;
322 return index_lock
.filename
;
328 * (1) return the name of the real index file.
330 * The caller should run hooks on the real index,
331 * and create commit from the_index.
332 * We still need to refresh the index here.
334 if (!pathspec
|| !*pathspec
) {
335 fd
= hold_locked_index(&index_lock
, 1);
336 refresh_cache_or_die(refresh_flags
);
337 if (active_cache_changed
) {
338 if (write_cache(fd
, active_cache
, active_nr
) ||
339 commit_locked_index(&index_lock
))
340 die("unable to write new_index file");
342 rollback_lock_file(&index_lock
);
344 commit_style
= COMMIT_AS_IS
;
345 return get_index_file();
351 * (0) find the set of affected paths;
352 * (1) get lock on the real index file;
353 * (2) update the_index with the given paths;
354 * (3) write the_index out to the real index (still locked);
355 * (4) get lock on the false index file;
356 * (5) reset the_index from HEAD;
357 * (6) update the_index the same way as (2);
358 * (7) write the_index out to the false index file;
359 * (8) return the name of the false index file (still locked);
361 * The caller should run hooks on the locked false index, and
362 * create commit from it. Then
363 * (A) if all goes well, commit the real index;
364 * (B) on failure, rollback the real index;
365 * In either case, rollback the false index.
367 commit_style
= COMMIT_PARTIAL
;
370 die("cannot do a partial commit during a merge.");
372 memset(&partial
, 0, sizeof(partial
));
373 partial
.strdup_strings
= 1;
374 if (list_paths(&partial
, initial_commit
? NULL
: "HEAD", prefix
, pathspec
))
378 if (read_cache() < 0)
379 die("cannot read the index");
381 fd
= hold_locked_index(&index_lock
, 1);
382 add_remove_files(&partial
);
383 refresh_cache(REFRESH_QUIET
);
384 if (write_cache(fd
, active_cache
, active_nr
) ||
385 close_lock_file(&index_lock
))
386 die("unable to write new_index file");
388 fd
= hold_lock_file_for_update(&false_lock
,
389 git_path("next-index-%"PRIuMAX
,
390 (uintmax_t) getpid()),
394 add_remove_files(&partial
);
395 refresh_cache(REFRESH_QUIET
);
397 if (write_cache(fd
, active_cache
, active_nr
) ||
398 close_lock_file(&false_lock
))
399 die("unable to write temporary index file");
402 read_cache_from(false_lock
.filename
);
404 return false_lock
.filename
;
407 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
410 unsigned char sha1
[20];
412 if (s
->relative_paths
)
417 s
->reference
= "HEAD^1";
419 s
->verbose
= verbose
;
420 s
->index_file
= index_file
;
423 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
425 wt_status_collect(s
);
427 switch (status_format
) {
428 case STATUS_FORMAT_SHORT
:
429 wt_shortstatus_print(s
, null_termination
);
431 case STATUS_FORMAT_PORCELAIN
:
432 wt_porcelain_print(s
, null_termination
);
434 case STATUS_FORMAT_LONG
:
439 return s
->commitable
;
442 static int is_a_merge(const unsigned char *sha1
)
444 struct commit
*commit
= lookup_commit(sha1
);
445 if (!commit
|| parse_commit(commit
))
446 die("could not parse HEAD commit");
447 return !!(commit
->parents
&& commit
->parents
->next
);
450 static const char sign_off_header
[] = "Signed-off-by: ";
452 static void determine_author_info(void)
454 char *name
, *email
, *date
;
456 name
= getenv("GIT_AUTHOR_NAME");
457 email
= getenv("GIT_AUTHOR_EMAIL");
458 date
= getenv("GIT_AUTHOR_DATE");
460 if (use_message
&& !renew_authorship
) {
461 const char *a
, *lb
, *rb
, *eol
;
463 a
= strstr(use_message_buffer
, "\nauthor ");
465 die("invalid commit: %s", use_message
);
467 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
468 rb
= strchrnul(lb
, '>');
469 eol
= strchrnul(rb
, '\n');
470 if (!*lb
|| !*rb
|| !*eol
)
471 die("invalid commit: %s", use_message
);
473 if (lb
== a
+ strlen("\nauthor "))
474 /* \nauthor <foo@example.com> */
475 name
= xcalloc(1, 1);
477 name
= xmemdupz(a
+ strlen("\nauthor "),
479 (a
+ strlen("\nauthor "))));
480 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
481 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
485 const char *lb
= strstr(force_author
, " <");
486 const char *rb
= strchr(force_author
, '>');
489 die("malformed --author parameter");
490 name
= xstrndup(force_author
, lb
- force_author
);
491 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
498 author_email
= email
;
502 static int ends_rfc2822_footer(struct strbuf
*sb
)
509 const char *buf
= sb
->buf
;
511 for (i
= len
- 1; i
> 0; i
--) {
512 if (hit
&& buf
[i
] == '\n')
514 hit
= (buf
[i
] == '\n');
517 while (i
< len
- 1 && buf
[i
] == '\n')
520 for (; i
< len
; i
= k
) {
521 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
525 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
530 for (j
= 0; i
+ j
< len
; j
++) {
543 static int prepare_to_commit(const char *index_file
, const char *prefix
,
547 int commitable
, saved_color_setting
;
548 struct strbuf sb
= STRBUF_INIT
;
551 const char *hook_arg1
= NULL
;
552 const char *hook_arg2
= NULL
;
555 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
559 strbuf_addbuf(&sb
, &message
);
560 hook_arg1
= "message";
561 } else if (logfile
&& !strcmp(logfile
, "-")) {
563 fprintf(stderr
, "(reading log message from standard input)\n");
564 if (strbuf_read(&sb
, 0, 0) < 0)
565 die_errno("could not read log from standard input");
566 hook_arg1
= "message";
567 } else if (logfile
) {
568 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
569 die_errno("could not read log file '%s'",
571 hook_arg1
= "message";
572 } else if (use_message
) {
573 buffer
= strstr(use_message_buffer
, "\n\n");
574 if (!buffer
|| buffer
[2] == '\0')
575 die("commit has empty message");
576 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
577 hook_arg1
= "commit";
578 hook_arg2
= use_message
;
579 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
580 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
581 die_errno("could not read MERGE_MSG");
583 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
584 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
585 die_errno("could not read SQUASH_MSG");
586 hook_arg1
= "squash";
587 } else if (template_file
&& !stat(template_file
, &statbuf
)) {
588 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
589 die_errno("could not read '%s'", template_file
);
590 hook_arg1
= "template";
594 * This final case does not modify the template message,
595 * it just sets the argument to the prepare-commit-msg hook.
600 fp
= fopen(git_path(commit_editmsg
), "w");
602 die_errno("could not open '%s'", git_path(commit_editmsg
));
604 if (cleanup_mode
!= CLEANUP_NONE
)
608 struct strbuf sob
= STRBUF_INIT
;
611 strbuf_addstr(&sob
, sign_off_header
);
612 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
613 getenv("GIT_COMMITTER_EMAIL")));
614 strbuf_addch(&sob
, '\n');
615 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
617 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
618 if (!i
|| !ends_rfc2822_footer(&sb
))
619 strbuf_addch(&sb
, '\n');
620 strbuf_addbuf(&sb
, &sob
);
622 strbuf_release(&sob
);
625 if (fwrite(sb
.buf
, 1, sb
.len
, fp
) < sb
.len
)
626 die_errno("could not write commit template");
630 determine_author_info();
632 /* This checks if committer ident is explicitly given */
633 git_committer_info(0);
634 if (use_editor
&& include_status
) {
636 const char *committer_ident
;
641 "# It looks like you may be committing a MERGE.\n"
642 "# If this is not correct, please remove the file\n"
646 git_path("MERGE_HEAD"));
650 "# Please enter the commit message for your changes.");
651 if (cleanup_mode
== CLEANUP_ALL
)
654 "# with '#' will be ignored, and an empty"
655 " message aborts the commit.\n");
656 else /* CLEANUP_SPACE, that is. */
659 "# with '#' will be kept; you may remove them"
660 " yourself if you want to.\n"
661 "# An empty message aborts the commit.\n");
662 if (only_include_assumed
)
663 fprintf(fp
, "# %s\n", only_include_assumed
);
665 author_ident
= xstrdup(fmt_name(author_name
, author_email
));
666 committer_ident
= fmt_name(getenv("GIT_COMMITTER_NAME"),
667 getenv("GIT_COMMITTER_EMAIL"));
668 if (strcmp(author_ident
, committer_ident
))
672 ident_shown
++ ? "" : "#\n",
676 if (!user_ident_sufficiently_given())
680 ident_shown
++ ? "" : "#\n",
686 saved_color_setting
= s
->use_color
;
688 commitable
= run_status(fp
, index_file
, prefix
, 1, s
);
689 s
->use_color
= saved_color_setting
;
691 unsigned char sha1
[20];
692 const char *parent
= "HEAD";
694 if (!active_nr
&& read_cache() < 0)
695 die("Cannot read index");
700 if (get_sha1(parent
, sha1
))
701 commitable
= !!active_nr
;
703 commitable
= index_differs_from(parent
, 0);
708 if (!commitable
&& !in_merge
&& !allow_empty
&&
709 !(amend
&& is_a_merge(head_sha1
))) {
710 run_status(stdout
, index_file
, prefix
, 0, s
);
712 fputs(empty_amend_advice
, stderr
);
717 * Re-read the index as pre-commit hook could have updated it,
718 * and write it out as a tree. We must do this before we invoke
719 * the editor and after we invoke run_status above.
722 read_cache_from(index_file
);
723 if (!active_cache_tree
)
724 active_cache_tree
= cache_tree();
725 if (cache_tree_update(active_cache_tree
,
726 active_cache
, active_nr
, 0, 0) < 0) {
727 error("Error building trees");
731 if (run_hook(index_file
, "prepare-commit-msg",
732 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
736 char index
[PATH_MAX
];
737 const char *env
[2] = { index
, NULL
};
738 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
739 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
741 "Please supply the message using either -m or -F option.\n");
747 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
755 * Find out if the message in the strbuf contains only whitespace and
756 * Signed-off-by lines.
758 static int message_is_empty(struct strbuf
*sb
)
760 struct strbuf tmpl
= STRBUF_INIT
;
762 int eol
, i
, start
= 0;
764 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
767 /* See if the template is just a prefix of the message. */
768 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
769 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
770 if (start
+ tmpl
.len
<= sb
->len
&&
771 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
774 strbuf_release(&tmpl
);
776 /* Check if the rest is just whitespace and Signed-of-by's. */
777 for (i
= start
; i
< sb
->len
; i
++) {
778 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
784 if (strlen(sign_off_header
) <= eol
- i
&&
785 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
790 if (!isspace(sb
->buf
[i
++]))
797 static const char *find_author_by_nickname(const char *name
)
799 struct rev_info revs
;
800 struct commit
*commit
;
801 struct strbuf buf
= STRBUF_INIT
;
805 init_revisions(&revs
, NULL
);
806 strbuf_addf(&buf
, "--author=%s", name
);
811 setup_revisions(ac
, av
, &revs
, NULL
);
812 prepare_revision_walk(&revs
);
813 commit
= get_revision(&revs
);
815 struct pretty_print_context ctx
= {0};
816 ctx
.date_mode
= DATE_NORMAL
;
817 strbuf_release(&buf
);
818 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
819 return strbuf_detach(&buf
, NULL
);
821 die("No existing author found with '%s'", name
);
825 static void handle_untracked_files_arg(struct wt_status
*s
)
827 if (!untracked_files_arg
)
828 ; /* default already initialized */
829 else if (!strcmp(untracked_files_arg
, "no"))
830 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
831 else if (!strcmp(untracked_files_arg
, "normal"))
832 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
833 else if (!strcmp(untracked_files_arg
, "all"))
834 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
836 die("Invalid untracked files mode '%s'", untracked_files_arg
);
839 static int parse_and_validate_options(int argc
, const char *argv
[],
840 const char * const usage
[],
846 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
849 if (force_author
&& !strchr(force_author
, '>'))
850 force_author
= find_author_by_nickname(force_author
);
852 if (force_author
&& renew_authorship
)
853 die("Using both --reset-author and --author does not make sense");
855 if (logfile
|| message
.len
|| use_message
)
860 setenv("GIT_EDITOR", ":", 1);
862 if (get_sha1("HEAD", head_sha1
))
865 /* Sanity check options */
866 if (amend
&& initial_commit
)
867 die("You have nothing to amend.");
868 if (amend
&& in_merge
)
869 die("You are in the middle of a merge -- cannot amend.");
878 die("Only one of -c/-C/-F can be used.");
879 if (message
.len
&& f
> 0)
880 die("Option -m cannot be combined with -c/-C/-F.");
882 use_message
= edit_message
;
883 if (amend
&& !use_message
)
884 use_message
= "HEAD";
885 if (!use_message
&& renew_authorship
)
886 die("--reset-author can be used only with -C, -c or --amend.");
888 unsigned char sha1
[20];
889 static char utf8
[] = "UTF-8";
892 struct commit
*commit
;
894 if (get_sha1(use_message
, sha1
))
895 die("could not lookup commit %s", use_message
);
896 commit
= lookup_commit_reference(sha1
);
897 if (!commit
|| parse_commit(commit
))
898 die("could not parse commit %s", use_message
);
900 enc
= strstr(commit
->buffer
, "\nencoding");
902 end
= strchr(enc
+ 10, '\n');
903 enc
= xstrndup(enc
+ 10, end
- (enc
+ 10));
907 out_enc
= git_commit_encoding
? git_commit_encoding
: utf8
;
909 if (strcmp(out_enc
, enc
))
911 reencode_string(commit
->buffer
, out_enc
, enc
);
914 * If we failed to reencode the buffer, just copy it
915 * byte for byte so the user can try to fix it up.
916 * This also handles the case where input and output
917 * encodings are identical.
919 if (use_message_buffer
== NULL
)
920 use_message_buffer
= xstrdup(commit
->buffer
);
925 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
926 die("Only one of --include/--only/--all/--interactive can be used.");
927 if (argc
== 0 && (also
|| (only
&& !amend
)))
928 die("No paths with --include/--only does not make sense.");
929 if (argc
== 0 && only
&& amend
)
930 only_include_assumed
= "Clever... amending the last one with dirty index.";
931 if (argc
> 0 && !also
&& !only
)
932 only_include_assumed
= "Explicit paths specified without -i nor -o; assuming --only paths...";
933 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
934 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
935 else if (!strcmp(cleanup_arg
, "verbatim"))
936 cleanup_mode
= CLEANUP_NONE
;
937 else if (!strcmp(cleanup_arg
, "whitespace"))
938 cleanup_mode
= CLEANUP_SPACE
;
939 else if (!strcmp(cleanup_arg
, "strip"))
940 cleanup_mode
= CLEANUP_ALL
;
942 die("Invalid cleanup mode %s", cleanup_arg
);
944 handle_untracked_files_arg(s
);
947 die("Paths with -a does not make sense.");
948 else if (interactive
&& argc
> 0)
949 die("Paths with --interactive does not make sense.");
951 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
952 status_format
= STATUS_FORMAT_PORCELAIN
;
953 if (status_format
!= STATUS_FORMAT_LONG
)
959 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
963 const char *index_file
;
965 index_file
= prepare_index(argc
, argv
, prefix
, 1);
966 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
967 rollback_index_files();
969 return commitable
? 0 : 1;
972 static int parse_status_slot(const char *var
, int offset
)
974 if (!strcasecmp(var
+offset
, "header"))
975 return WT_STATUS_HEADER
;
976 if (!strcasecmp(var
+offset
, "updated")
977 || !strcasecmp(var
+offset
, "added"))
978 return WT_STATUS_UPDATED
;
979 if (!strcasecmp(var
+offset
, "changed"))
980 return WT_STATUS_CHANGED
;
981 if (!strcasecmp(var
+offset
, "untracked"))
982 return WT_STATUS_UNTRACKED
;
983 if (!strcasecmp(var
+offset
, "nobranch"))
984 return WT_STATUS_NOBRANCH
;
985 if (!strcasecmp(var
+offset
, "unmerged"))
986 return WT_STATUS_UNMERGED
;
990 static int git_status_config(const char *k
, const char *v
, void *cb
)
992 struct wt_status
*s
= cb
;
994 if (!strcmp(k
, "status.submodulesummary")) {
996 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
997 if (is_bool
&& s
->submodule_summary
)
998 s
->submodule_summary
= -1;
1001 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1002 s
->use_color
= git_config_colorbool(k
, v
, -1);
1005 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1006 int slot
= parse_status_slot(k
, 13);
1010 return config_error_nonbool(k
);
1011 color_parse(v
, k
, s
->color_palette
[slot
]);
1014 if (!strcmp(k
, "status.relativepaths")) {
1015 s
->relative_paths
= git_config_bool(k
, v
);
1018 if (!strcmp(k
, "status.showuntrackedfiles")) {
1020 return config_error_nonbool(k
);
1021 else if (!strcmp(v
, "no"))
1022 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1023 else if (!strcmp(v
, "normal"))
1024 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1025 else if (!strcmp(v
, "all"))
1026 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1028 return error("Invalid untracked files mode '%s'", v
);
1031 return git_diff_ui_config(k
, v
, NULL
);
1034 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1038 unsigned char sha1
[20];
1039 static struct option builtin_status_options
[] = {
1040 OPT__VERBOSE(&verbose
),
1041 OPT_SET_INT('s', "short", &status_format
,
1042 "show status concisely", STATUS_FORMAT_SHORT
),
1043 OPT_SET_INT(0, "porcelain", &status_format
,
1044 "show porcelain output format",
1045 STATUS_FORMAT_PORCELAIN
),
1046 OPT_BOOLEAN('z', "null", &null_termination
,
1047 "terminate entries with NUL"),
1048 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1050 "show untracked files, optional modes: all, normal, no. (Default: all)",
1051 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1055 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1056 status_format
= STATUS_FORMAT_PORCELAIN
;
1058 wt_status_prepare(&s
);
1059 git_config(git_status_config
, &s
);
1060 in_merge
= file_exists(git_path("MERGE_HEAD"));
1061 argc
= parse_options(argc
, argv
, prefix
,
1062 builtin_status_options
,
1063 builtin_status_usage
, 0);
1064 handle_untracked_files_arg(&s
);
1067 s
.pathspec
= get_pathspec(prefix
, argv
);
1069 read_cache_preload(s
.pathspec
);
1070 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1072 fd
= hold_locked_index(&index_lock
, 0);
1074 if (active_cache_changed
&&
1075 !write_cache(fd
, active_cache
, active_nr
))
1076 commit_locked_index(&index_lock
);
1078 rollback_lock_file(&index_lock
);
1081 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1082 s
.in_merge
= in_merge
;
1083 wt_status_collect(&s
);
1085 if (s
.relative_paths
)
1087 if (s
.use_color
== -1)
1088 s
.use_color
= git_use_color_default
;
1089 if (diff_use_color_default
== -1)
1090 diff_use_color_default
= git_use_color_default
;
1092 switch (status_format
) {
1093 case STATUS_FORMAT_SHORT
:
1094 wt_shortstatus_print(&s
, null_termination
);
1096 case STATUS_FORMAT_PORCELAIN
:
1097 wt_porcelain_print(&s
, null_termination
);
1099 case STATUS_FORMAT_LONG
:
1100 s
.verbose
= verbose
;
1101 wt_status_print(&s
);
1107 static void print_summary(const char *prefix
, const unsigned char *sha1
)
1109 struct rev_info rev
;
1110 struct commit
*commit
;
1111 struct strbuf format
= STRBUF_INIT
;
1112 unsigned char junk_sha1
[20];
1113 const char *head
= resolve_ref("HEAD", junk_sha1
, 0, NULL
);
1114 struct pretty_print_context pctx
= {0};
1115 struct strbuf author_ident
= STRBUF_INIT
;
1116 struct strbuf committer_ident
= STRBUF_INIT
;
1118 commit
= lookup_commit(sha1
);
1120 die("couldn't look up newly created commit");
1121 if (!commit
|| parse_commit(commit
))
1122 die("could not parse newly created commit");
1124 strbuf_addstr(&format
, "format:%h] %s");
1126 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1127 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1128 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1129 strbuf_addstr(&format
, "\n Author: ");
1130 strbuf_addbuf_percentquote(&format
, &author_ident
);
1132 if (!user_ident_sufficiently_given()) {
1133 strbuf_addstr(&format
, "\n Committer: ");
1134 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1135 if (advice_implicit_identity
) {
1136 strbuf_addch(&format
, '\n');
1137 strbuf_addstr(&format
, implicit_ident_advice
);
1140 strbuf_release(&author_ident
);
1141 strbuf_release(&committer_ident
);
1143 init_revisions(&rev
, prefix
);
1144 setup_revisions(0, NULL
, &rev
, NULL
);
1148 rev
.diffopt
.output_format
=
1149 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1151 rev
.verbose_header
= 1;
1152 rev
.show_root_diff
= 1;
1153 get_commit_format(format
.buf
, &rev
);
1154 rev
.always_show_header
= 0;
1155 rev
.diffopt
.detect_rename
= 1;
1156 rev
.diffopt
.rename_limit
= 100;
1157 rev
.diffopt
.break_opt
= 0;
1158 diff_setup_done(&rev
.diffopt
);
1161 !prefixcmp(head
, "refs/heads/") ?
1163 !strcmp(head
, "HEAD") ?
1166 initial_commit
? " (root-commit)" : "");
1168 if (!log_tree_commit(&rev
, commit
)) {
1169 rev
.always_show_header
= 1;
1170 rev
.use_terminator
= 1;
1171 log_tree_commit(&rev
, commit
);
1174 strbuf_release(&format
);
1177 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1179 struct wt_status
*s
= cb
;
1181 if (!strcmp(k
, "commit.template"))
1182 return git_config_pathname(&template_file
, k
, v
);
1183 if (!strcmp(k
, "commit.status")) {
1184 include_status
= git_config_bool(k
, v
);
1188 return git_status_config(k
, v
, s
);
1191 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1193 static int run_rewrite_hook(const unsigned char *oldsha1
,
1194 const unsigned char *newsha1
)
1196 /* oldsha1 SP newsha1 LF NUL */
1197 static char buf
[2*40 + 3];
1198 struct child_process proc
;
1199 const char *argv
[3];
1203 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1206 argv
[0] = git_path(post_rewrite_hook
);
1210 memset(&proc
, 0, sizeof(proc
));
1213 proc
.stdout_to_stderr
= 1;
1215 code
= start_command(&proc
);
1218 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1219 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1220 write_in_full(proc
.in
, buf
, n
);
1222 return finish_command(&proc
);
1225 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1227 struct strbuf sb
= STRBUF_INIT
;
1228 const char *index_file
, *reflog_msg
;
1230 unsigned char commit_sha1
[20];
1231 struct ref_lock
*ref_lock
;
1232 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1233 struct stat statbuf
;
1234 int allow_fast_forward
= 1;
1237 wt_status_prepare(&s
);
1238 git_config(git_commit_config
, &s
);
1239 in_merge
= file_exists(git_path("MERGE_HEAD"));
1240 s
.in_merge
= in_merge
;
1242 if (s
.use_color
== -1)
1243 s
.use_color
= git_use_color_default
;
1244 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1247 if (diff_use_color_default
== -1)
1248 diff_use_color_default
= git_use_color_default
;
1249 return dry_run_commit(argc
, argv
, prefix
, &s
);
1251 index_file
= prepare_index(argc
, argv
, prefix
, 0);
1253 /* Set up everything for writing the commit object. This includes
1254 running hooks, writing the trees, and interacting with the user. */
1255 if (!prepare_to_commit(index_file
, prefix
, &s
)) {
1256 rollback_index_files();
1260 /* Determine parents */
1261 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1262 if (initial_commit
) {
1264 reflog_msg
= "commit (initial)";
1266 struct commit_list
*c
;
1267 struct commit
*commit
;
1270 reflog_msg
= "commit (amend)";
1271 commit
= lookup_commit(head_sha1
);
1272 if (!commit
|| parse_commit(commit
))
1273 die("could not parse HEAD commit");
1275 for (c
= commit
->parents
; c
; c
= c
->next
)
1276 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1277 } else if (in_merge
) {
1278 struct strbuf m
= STRBUF_INIT
;
1282 reflog_msg
= "commit (merge)";
1283 pptr
= &commit_list_insert(lookup_commit(head_sha1
), pptr
)->next
;
1284 fp
= fopen(git_path("MERGE_HEAD"), "r");
1286 die_errno("could not open '%s' for reading",
1287 git_path("MERGE_HEAD"));
1288 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1289 unsigned char sha1
[20];
1290 if (get_sha1_hex(m
.buf
, sha1
) < 0)
1291 die("Corrupt MERGE_HEAD file (%s)", m
.buf
);
1292 pptr
= &commit_list_insert(lookup_commit(sha1
), pptr
)->next
;
1296 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1297 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1298 die_errno("could not read MERGE_MODE");
1299 if (!strcmp(sb
.buf
, "no-ff"))
1300 allow_fast_forward
= 0;
1302 if (allow_fast_forward
)
1303 parents
= reduce_heads(parents
);
1306 reflog_msg
= "commit";
1307 pptr
= &commit_list_insert(lookup_commit(head_sha1
), pptr
)->next
;
1310 /* Finally, get the commit message */
1312 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1313 int saved_errno
= errno
;
1314 rollback_index_files();
1315 die("could not read commit message: %s", strerror(saved_errno
));
1318 /* Truncate the message just before the diff, if any. */
1320 p
= strstr(sb
.buf
, "\ndiff --git ");
1322 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1325 if (cleanup_mode
!= CLEANUP_NONE
)
1326 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1327 if (message_is_empty(&sb
)) {
1328 rollback_index_files();
1329 fprintf(stderr
, "Aborting commit due to empty commit message.\n");
1333 if (commit_tree(sb
.buf
, active_cache_tree
->sha1
, parents
, commit_sha1
,
1334 fmt_ident(author_name
, author_email
, author_date
,
1335 IDENT_ERROR_ON_NO_NAME
))) {
1336 rollback_index_files();
1337 die("failed to write commit object");
1340 ref_lock
= lock_any_ref_for_update("HEAD",
1341 initial_commit
? NULL
: head_sha1
,
1344 nl
= strchr(sb
.buf
, '\n');
1346 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1348 strbuf_addch(&sb
, '\n');
1349 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1350 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1353 rollback_index_files();
1354 die("cannot lock HEAD ref");
1356 if (write_ref_sha1(ref_lock
, commit_sha1
, sb
.buf
) < 0) {
1357 rollback_index_files();
1358 die("cannot update HEAD ref");
1361 unlink(git_path("MERGE_HEAD"));
1362 unlink(git_path("MERGE_MSG"));
1363 unlink(git_path("MERGE_MODE"));
1364 unlink(git_path("SQUASH_MSG"));
1366 if (commit_index_files())
1367 die ("Repository has been updated, but unable to write\n"
1368 "new_index file. Check that disk is not full or quota is\n"
1369 "not exceeded, and then \"git reset HEAD\" to recover.");
1372 run_hook(get_index_file(), "post-commit", NULL
);
1373 if (amend
&& !no_post_rewrite
) {
1374 struct notes_rewrite_cfg
*cfg
;
1375 cfg
= init_copy_notes_for_rewrite("amend");
1377 copy_note_for_rewrite(cfg
, head_sha1
, commit_sha1
);
1378 finish_copy_notes_for_rewrite(cfg
);
1380 run_rewrite_hook(head_sha1
, commit_sha1
);
1383 print_summary(prefix
, commit_sha1
);