blob: d3e7781e658a67d79df781df44a7d716a5094b30 [file] [log] [blame]
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001/*
2 * Builtin "git commit"
3 *
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
7
Nguyễn Thái Ngọc Duyf8adbec2019-01-24 15:29:12 +07008#define USE_THE_INDEX_COMPATIBILITY_MACROS
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05009#include "cache.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -070010#include "config.h"
Michael Haggerty697cc8e2014-10-01 12:28:42 +020011#include "lockfile.h"
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -050012#include "cache-tree.h"
Matthias Kestenholz6b2f2d92008-02-18 08:26:03 +010013#include "color.h"
Junio C Hamano28886052007-11-18 01:52:55 -080014#include "dir.h"
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -050015#include "builtin.h"
16#include "diff.h"
17#include "diffcore.h"
18#include "commit.h"
19#include "revision.h"
20#include "wt-status.h"
21#include "run-command.h"
22#include "refs.h"
23#include "log-tree.h"
24#include "strbuf.h"
25#include "utf8.h"
26#include "parse-options.h"
Johannes Schindelinc455c872008-07-21 19:03:49 +010027#include "string-list.h"
Stephan Beyer5b2fd952008-07-09 14:58:57 +020028#include "rerere.h"
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -080029#include "unpack-trees.h"
Junio C Hamano76e2f7c2009-08-07 23:31:57 -070030#include "quote.h"
Jens Lehmann302ad7a2010-08-06 00:40:48 +020031#include "submodule.h"
Junio C Hamanoba3c69a2011-10-05 17:23:20 -070032#include "gpg-interface.h"
Nguyễn Thái Ngọc Duy323d0532012-04-13 17:54:39 +070033#include "column.h"
Miklos Vajna5ed75e22012-09-14 08:52:03 +020034#include "sequencer.h"
Antoine Pelisseea167942013-08-23 15:48:31 +020035#include "mailmap.h"
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +020036#include "help.h"
Derrick Stolee64043552018-07-20 16:33:04 +000037#include "commit-reach.h"
Derrick Stolee859fdc02018-08-29 05:49:04 -070038#include "commit-graph.h"
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -050039
40static const char * const builtin_commit_usage[] = {
Alex Henrie9c9b4f22015-01-13 00:44:47 -070041 N_("git commit [<options>] [--] <pathspec>..."),
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -050042 NULL
43};
44
Shawn Bohrer2f02b252007-12-02 23:02:09 -060045static const char * const builtin_status_usage[] = {
Alex Henrie9c9b4f22015-01-13 00:44:47 -070046 N_("git status [<options>] [--] <pathspec>..."),
Shawn Bohrer2f02b252007-12-02 23:02:09 -060047 NULL
48};
49
Jeff Kingf197ed22010-06-06 20:41:46 -040050static const char empty_amend_advice[] =
Ævar Arnfjörð Bjarmasonfc88e312011-02-22 23:41:49 +000051N_("You asked to amend the most recent commit, but doing so would make\n"
Jeff Kingf197ed22010-06-06 20:41:46 -040052"it empty. You can repeat your command with --allow-empty, or you can\n"
Ævar Arnfjörð Bjarmasonfc88e312011-02-22 23:41:49 +000053"remove the commit entirely with \"git reset HEAD^\".\n");
Jeff Kingf197ed22010-06-06 20:41:46 -040054
Jay Soffian37f7a852011-02-19 23:12:29 -050055static const char empty_cherry_pick_advice[] =
Junio C Hamano6c80cd22011-04-01 17:55:55 -070056N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
Jay Soffian37f7a852011-02-19 23:12:29 -050057"If you wish to commit it anyway, use:\n"
58"\n"
59" git commit --allow-empty\n"
Jeff Kingc17592a2013-07-26 19:39:28 -040060"\n");
61
Phillip Wood430b75f2019-12-06 16:06:12 +000062static const char empty_rebase_pick_advice[] =
63N_("Otherwise, please use 'git rebase --skip'\n");
64
Jeff Kingc17592a2013-07-26 19:39:28 -040065static const char empty_cherry_pick_advice_single[] =
Rohit Ashiwaldcb500d2019-07-02 14:41:29 +053066N_("Otherwise, please use 'git cherry-pick --skip'\n");
Jeff Kingc17592a2013-07-26 19:39:28 -040067
68static const char empty_cherry_pick_advice_multi[] =
Rohit Ashiwaldcb500d2019-07-02 14:41:29 +053069N_("and then use:\n"
Jay Soffian37f7a852011-02-19 23:12:29 -050070"\n"
Rohit Ashiwaldcb500d2019-07-02 14:41:29 +053071" git cherry-pick --continue\n"
Jeff Kingc17592a2013-07-26 19:39:28 -040072"\n"
Rohit Ashiwaldcb500d2019-07-02 14:41:29 +053073"to resume cherry-picking the remaining commits.\n"
74"If you wish to skip this commit, use:\n"
75"\n"
76" git cherry-pick --skip\n"
77"\n");
Jay Soffian37f7a852011-02-19 23:12:29 -050078
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020079static const char *color_status_slots[] = {
80 [WT_STATUS_HEADER] = "header",
81 [WT_STATUS_UPDATED] = "updated",
82 [WT_STATUS_CHANGED] = "changed",
83 [WT_STATUS_UNTRACKED] = "untracked",
84 [WT_STATUS_NOBRANCH] = "noBranch",
85 [WT_STATUS_UNMERGED] = "unmerged",
86 [WT_STATUS_LOCAL_BRANCH] = "localBranch",
87 [WT_STATUS_REMOTE_BRANCH] = "remoteBranch",
88 [WT_STATUS_ONBRANCH] = "branch",
89};
90
Jay Soffian37f7a852011-02-19 23:12:29 -050091static const char *use_message_buffer;
Junio C Hamano28886052007-11-18 01:52:55 -080092static struct lock_file index_lock; /* real index */
93static struct lock_file false_lock; /* used only for partial commits */
94static enum {
95 COMMIT_AS_IS = 1,
96 COMMIT_NORMAL,
Gary V. Vaughan4b055482010-05-14 09:31:35 +000097 COMMIT_PARTIAL
Junio C Hamano28886052007-11-18 01:52:55 -080098} commit_style;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -050099
Junio C Hamanodbd0f5c2008-08-06 11:43:47 -0700100static const char *logfile, *force_author;
Brian Hetro984c6e72008-07-05 01:24:40 -0400101static const char *template_file;
Jay Soffian37f7a852011-02-19 23:12:29 -0500102/*
103 * The _message variables are commit names from which to take
104 * the commit message and/or authorship.
105 */
106static const char *author_message, *author_message_buffer;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500107static char *edit_message, *use_message;
Pat Notz89ac1222010-11-02 13:59:11 -0600108static char *fixup_message, *squash_message;
Junio C Hamanoca1ba202011-12-06 13:09:55 -0800109static int all, also, interactive, patch_interactive, only, amend, signoff;
110static int edit_flag = -1; /* unspecified */
Erick Mattosc51f6ce2009-11-04 01:20:11 -0200111static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
Pranit Bauvaaaab8422016-05-05 15:20:02 +0530112static int config_commit_verbose = -1; /* unspecified */
Alexandr Miloslavskiye440fc52019-11-19 16:48:55 +0000113static int no_post_rewrite, allow_empty_message, pathspec_file_nul;
Jameson Millereec0f7f2017-10-30 13:21:37 -0400114static char *untracked_files_arg, *force_date, *ignore_submodule_arg, *ignored_arg;
Alexandr Miloslavskiye440fc52019-11-19 16:48:55 +0000115static char *sign_commit, *pathspec_from_file;
Junio C Hamanoba3c69a2011-10-05 17:23:20 -0700116
Alex Riesen5f065732007-12-22 19:46:24 +0100117/*
118 * The default commit message cleanup mode will remove the lines
119 * beginning with # (shell comments) and leading and trailing
120 * whitespaces (empty lines or containing only whitespaces)
121 * if editor is used, and only the whitespaces if the message
122 * is specified explicitly.
123 */
Phillip Woodd0aaa462017-11-10 11:09:42 +0000124static enum commit_msg_cleanup_mode cleanup_mode;
Ralf Thielow51fb3a32013-01-10 18:45:59 +0100125static const char *cleanup_arg;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500126
Jay Soffian37f7a852011-02-19 23:12:29 -0500127static enum commit_whence whence;
Junio C Hamano06bb6432011-08-19 11:58:18 -0700128static int use_editor = 1, include_status = 1;
Jameson Millereec0f7f2017-10-30 13:21:37 -0400129static int have_option_m;
Jeff King2c477892011-12-18 00:03:22 -0500130static struct strbuf message = STRBUF_INIT;
Johannes Schindelinf9568532007-11-11 17:36:39 +0000131
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -0400132static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
Junio C Hamano84b42022013-06-24 11:41:40 -0700133
Jeff Hostetlerc4f596b2016-08-05 18:00:28 -0400134static int opt_parse_porcelain(const struct option *opt, const char *arg, int unset)
135{
136 enum wt_status_format *value = (enum wt_status_format *)opt->value;
137 if (unset)
138 *value = STATUS_FORMAT_NONE;
139 else if (!arg)
140 *value = STATUS_FORMAT_PORCELAIN;
141 else if (!strcmp(arg, "v1") || !strcmp(arg, "1"))
142 *value = STATUS_FORMAT_PORCELAIN;
Jeff Hostetler1ecdecc2016-08-11 10:45:57 -0400143 else if (!strcmp(arg, "v2") || !strcmp(arg, "2"))
144 *value = STATUS_FORMAT_PORCELAIN_V2;
Jeff Hostetlerc4f596b2016-08-05 18:00:28 -0400145 else
146 die("unsupported porcelain version '%s'", arg);
147
148 return 0;
149}
Jeff King7c9f7032009-09-05 04:59:56 -0400150
Johannes Schindelinf9568532007-11-11 17:36:39 +0000151static int opt_parse_m(const struct option *opt, const char *arg, int unset)
152{
153 struct strbuf *buf = opt->value;
René Scharfe25206772013-05-25 23:43:34 +0200154 if (unset) {
155 have_option_m = 0;
Johannes Schindelinf9568532007-11-11 17:36:39 +0000156 strbuf_setlen(buf, 0);
René Scharfe25206772013-05-25 23:43:34 +0200157 } else {
158 have_option_m = 1;
Brandon Caseya24a41e2013-02-18 20:17:06 -0800159 if (buf->len)
160 strbuf_addch(buf, '\n');
Johannes Schindelinf9568532007-11-11 17:36:39 +0000161 strbuf_addstr(buf, arg);
Brandon Caseya24a41e2013-02-18 20:17:06 -0800162 strbuf_complete_line(buf);
Johannes Schindelinf9568532007-11-11 17:36:39 +0000163 }
164 return 0;
165}
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500166
Ben Pearte8b2dc22018-05-11 15:38:58 +0000167static int opt_parse_rename_score(const struct option *opt, const char *arg, int unset)
168{
169 const char **value = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500170
171 BUG_ON_OPT_NEG(unset);
172
Ben Pearte8b2dc22018-05-11 15:38:58 +0000173 if (arg != NULL && *arg == '=')
174 arg = arg + 1;
175
176 *value = arg;
177 return 0;
178}
179
Jay Soffian37f7a852011-02-19 23:12:29 -0500180static void determine_whence(struct wt_status *s)
181{
Stefan Beller102de882018-05-17 15:51:51 -0700182 if (file_exists(git_path_merge_head(the_repository)))
Jay Soffian37f7a852011-02-19 23:12:29 -0500183 whence = FROM_MERGE;
Phillip Wood901ba7b2019-12-06 16:06:11 +0000184 else if (!sequencer_determine_whence(the_repository, &whence))
Jay Soffian37f7a852011-02-19 23:12:29 -0500185 whence = FROM_COMMIT;
186 if (s)
187 s->whence = whence;
188}
189
Matthieu Moy5c25dfa2013-09-12 12:50:04 +0200190static void status_init_config(struct wt_status *s, config_fn_t fn)
191{
Nguyễn Thái Ngọc Duy5b02ca32018-11-10 06:48:49 +0100192 wt_status_prepare(the_repository, s);
Eckhard S. Maaßdc6b1d92018-05-04 13:12:15 +0200193 init_diff_ui_defaults();
Matthieu Moy5c25dfa2013-09-12 12:50:04 +0200194 git_config(fn, s);
195 determine_whence(s);
Matthieu Moy6a964f52013-09-12 12:50:05 +0200196 s->hints = advice_status_hints; /* must come after git_config() */
Matthieu Moy5c25dfa2013-09-12 12:50:04 +0200197}
198
Junio C Hamano28886052007-11-18 01:52:55 -0800199static void rollback_index_files(void)
200{
201 switch (commit_style) {
202 case COMMIT_AS_IS:
203 break; /* nothing to do */
204 case COMMIT_NORMAL:
205 rollback_lock_file(&index_lock);
206 break;
207 case COMMIT_PARTIAL:
208 rollback_lock_file(&index_lock);
209 rollback_lock_file(&false_lock);
210 break;
211 }
212}
213
Brandon Casey5a9dd392008-01-23 11:21:22 -0600214static int commit_index_files(void)
Junio C Hamano28886052007-11-18 01:52:55 -0800215{
Brandon Casey5a9dd392008-01-23 11:21:22 -0600216 int err = 0;
217
Junio C Hamano28886052007-11-18 01:52:55 -0800218 switch (commit_style) {
219 case COMMIT_AS_IS:
220 break; /* nothing to do */
221 case COMMIT_NORMAL:
Brandon Casey5a9dd392008-01-23 11:21:22 -0600222 err = commit_lock_file(&index_lock);
Junio C Hamano28886052007-11-18 01:52:55 -0800223 break;
224 case COMMIT_PARTIAL:
Brandon Casey5a9dd392008-01-23 11:21:22 -0600225 err = commit_lock_file(&index_lock);
Junio C Hamano28886052007-11-18 01:52:55 -0800226 rollback_lock_file(&false_lock);
227 break;
228 }
Brandon Casey5a9dd392008-01-23 11:21:22 -0600229
230 return err;
Junio C Hamano28886052007-11-18 01:52:55 -0800231}
232
233/*
234 * Take a union of paths in the index and the named tree (typically, "HEAD"),
235 * and return the paths that match the given pattern in list.
236 */
Johannes Schindelinc455c872008-07-21 19:03:49 +0100237static int list_paths(struct string_list *list, const char *with_tree,
Jeff Kingc5c33502019-03-20 04:15:48 -0400238 const struct pathspec *pattern)
Junio C Hamano28886052007-11-18 01:52:55 -0800239{
Stefan Beller5d0b9bf2015-03-20 17:28:07 -0700240 int i, ret;
Junio C Hamano28886052007-11-18 01:52:55 -0800241 char *m;
242
Nguyễn Thái Ngọc Duy17ddc662013-07-14 15:35:53 +0700243 if (!pattern->nr)
Junio C Hamanob9a08012012-07-15 21:39:48 -0700244 return 0;
245
Nguyễn Thái Ngọc Duy17ddc662013-07-14 15:35:53 +0700246 m = xcalloc(1, pattern->nr);
Junio C Hamano28886052007-11-18 01:52:55 -0800247
Clemens Buchacher8894d532011-07-30 19:13:47 +0200248 if (with_tree) {
Clemens Buchacherf950eb92011-09-04 12:42:01 +0200249 char *max_prefix = common_prefix(pattern);
Brandon Williams86238e02018-04-03 10:57:45 -0700250 overlay_tree_on_index(&the_index, with_tree, max_prefix);
Clemens Buchacher5879f562011-09-04 12:41:59 +0200251 free(max_prefix);
Clemens Buchacher8894d532011-07-30 19:13:47 +0200252 }
Junio C Hamano28886052007-11-18 01:52:55 -0800253
254 for (i = 0; i < active_nr; i++) {
Nguyễn Thái Ngọc Duy9c5e6c82013-07-09 22:29:00 +0700255 const struct cache_entry *ce = active_cache[i];
Nguyễn Thái Ngọc Duy7fce6e32009-12-14 18:43:59 +0700256 struct string_list_item *item;
257
Linus Torvalds7a51ed62008-01-14 16:03:17 -0800258 if (ce->ce_flags & CE_UPDATE)
Junio C Hamanoe87e22d2008-01-14 13:54:24 -0800259 continue;
Nguyễn Thái Ngọc Duy6d2df282018-08-13 18:14:22 +0200260 if (!ce_path_match(&the_index, ce, pattern, m))
Junio C Hamano28886052007-11-18 01:52:55 -0800261 continue;
Julian Phillips78a395d2010-06-26 00:41:35 +0100262 item = string_list_insert(list, ce->name);
Nguyễn Thái Ngọc Duy7fce6e32009-12-14 18:43:59 +0700263 if (ce_skip_worktree(ce))
264 item->util = item; /* better a valid pointer than a fake one */
Junio C Hamano28886052007-11-18 01:52:55 -0800265 }
266
Jeff Kingc5c33502019-03-20 04:15:48 -0400267 ret = report_path_error(m, pattern);
Stefan Beller5d0b9bf2015-03-20 17:28:07 -0700268 free(m);
269 return ret;
Junio C Hamano28886052007-11-18 01:52:55 -0800270}
271
Johannes Schindelinc455c872008-07-21 19:03:49 +0100272static void add_remove_files(struct string_list *list)
Junio C Hamano28886052007-11-18 01:52:55 -0800273{
274 int i;
275 for (i = 0; i < list->nr; i++) {
Linus Torvaldsd177cab2008-05-09 09:11:43 -0700276 struct stat st;
Johannes Schindelinc455c872008-07-21 19:03:49 +0100277 struct string_list_item *p = &(list->items[i]);
Linus Torvaldsd177cab2008-05-09 09:11:43 -0700278
Nguyễn Thái Ngọc Duy7fce6e32009-12-14 18:43:59 +0700279 /* p->util is skip-worktree */
280 if (p->util)
Nguyễn Thái Ngọc Duyb4d16902009-08-20 20:46:58 +0700281 continue;
Linus Torvaldsd177cab2008-05-09 09:11:43 -0700282
Johannes Schindelinc455c872008-07-21 19:03:49 +0100283 if (!lstat(p->string, &st)) {
284 if (add_to_cache(p->string, &st, 0))
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000285 die(_("updating files failed"));
Alex Riesen960b8ad2008-05-12 19:57:45 +0200286 } else
Johannes Schindelinc455c872008-07-21 19:03:49 +0100287 remove_file_from_cache(p->string);
Junio C Hamano28886052007-11-18 01:52:55 -0800288 }
289}
290
Junio C Hamano06bb6432011-08-19 11:58:18 -0700291static void create_base_index(const struct commit *current_head)
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800292{
293 struct tree *tree;
294 struct unpack_trees_options opts;
295 struct tree_desc t;
296
Junio C Hamano06bb6432011-08-19 11:58:18 -0700297 if (!current_head) {
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800298 discard_cache();
299 return;
300 }
301
302 memset(&opts, 0, sizeof(opts));
303 opts.head_idx = 1;
304 opts.index_only = 1;
305 opts.merge = 1;
Linus Torvalds34110cd2008-03-06 18:12:28 -0800306 opts.src_index = &the_index;
307 opts.dst_index = &the_index;
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800308
309 opts.fn = oneway_merge;
brian m. carlsona9dbc172017-05-06 22:10:37 +0000310 tree = parse_tree_indirect(&current_head->object.oid);
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800311 if (!tree)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000312 die(_("failed to unpack HEAD tree object"));
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800313 parse_tree(tree);
314 init_tree_desc(&t, tree->buffer, tree->size);
Daniel Barkalow203a2fe2008-02-07 11:39:48 -0500315 if (unpack_trees(1, &t, &opts))
316 exit(128); /* We've already reported the error, finish dying */
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800317}
318
Matthieu Moyd38a30d2010-01-12 10:54:44 +0100319static void refresh_cache_or_die(int refresh_flags)
320{
321 /*
322 * refresh_flags contains REFRESH_QUIET, so the only errors
323 * are for unmerged entries.
324 */
325 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
326 die_resolve_conflict("commit");
327}
328
Michael Haggerty35ff08b2014-10-01 12:28:17 +0200329static const char *prepare_index(int argc, const char **argv, const char *prefix,
330 const struct commit *current_head, int is_status)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500331{
Martin Ågrendd1055e2017-09-23 01:34:49 +0200332 struct string_list partial = STRING_LIST_INIT_DUP;
Nguyễn Thái Ngọc Duy6654c882013-07-14 15:35:38 +0700333 struct pathspec pathspec;
Junio C Hamano50b7e702009-08-04 23:49:33 -0700334 int refresh_flags = REFRESH_QUIET;
Michael Haggertyb4fb09e2015-08-10 11:47:39 +0200335 const char *ret;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500336
Junio C Hamano50b7e702009-08-04 23:49:33 -0700337 if (is_status)
338 refresh_flags |= REFRESH_UNMERGED;
Nguyễn Thái Ngọc Duy6654c882013-07-14 15:35:38 +0700339 parse_pathspec(&pathspec, 0,
340 PATHSPEC_PREFER_FULL,
341 prefix, argv);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500342
Alexandr Miloslavskiye440fc52019-11-19 16:48:55 +0000343 if (pathspec_from_file) {
344 if (interactive)
345 die(_("--pathspec-from-file is incompatible with --interactive/--patch"));
346
Alexandr Miloslavskiy509efef2019-12-16 15:47:52 +0000347 if (all)
348 die(_("--pathspec-from-file with -a does not make sense"));
349
Alexandr Miloslavskiye440fc52019-11-19 16:48:55 +0000350 if (pathspec.nr)
351 die(_("--pathspec-from-file is incompatible with pathspec arguments"));
352
353 parse_pathspec_file(&pathspec, 0,
354 PATHSPEC_PREFER_FULL,
355 prefix, pathspec_from_file, pathspec_file_nul);
356 } else if (pathspec_file_nul) {
357 die(_("--pathspec-file-nul requires --pathspec-from-file"));
358 }
359
360 if (!pathspec.nr && (also || (only && !amend && !allow_empty)))
361 die(_("No paths with --include/--only does not make sense."));
362
Nguyễn Thái Ngọc Duy5ab2a2d2013-07-14 15:35:49 +0700363 if (read_cache_preload(&pathspec) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000364 die(_("index file corrupt"));
Linus Torvalds671c9b72008-11-13 16:36:30 -0800365
Conrad Irwin1020d082011-05-06 22:59:59 -0700366 if (interactive) {
Johannes Schindelinc480eeb2019-12-21 21:57:16 +0000367 char *old_index_env = NULL, *old_repo_index_file;
Junio C Hamanob3e83cc2016-12-07 10:33:54 -0800368 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
Conrad Irwin1020d082011-05-06 22:59:59 -0700369
370 refresh_cache_or_die(refresh_flags);
371
Martin Ågren812d6b02017-10-06 22:12:12 +0200372 if (write_locked_index(&the_index, &index_lock, 0))
Conrad Irwin1020d082011-05-06 22:59:59 -0700373 die(_("unable to create temporary index"));
374
Johannes Schindelinc480eeb2019-12-21 21:57:16 +0000375 old_repo_index_file = the_repository->index_file;
376 the_repository->index_file =
377 (char *)get_lock_file_path(&index_lock);
Jeff King406bab32019-01-11 17:15:40 -0500378 old_index_env = xstrdup_or_null(getenv(INDEX_ENVIRONMENT));
Johannes Schindelinc480eeb2019-12-21 21:57:16 +0000379 setenv(INDEX_ENVIRONMENT, the_repository->index_file, 1);
Conrad Irwin1020d082011-05-06 22:59:59 -0700380
Conrad Irwinb4bd4662011-05-07 10:58:07 -0700381 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
Conrad Irwin1020d082011-05-06 22:59:59 -0700382 die(_("interactive add failed"));
383
Johannes Schindelinc480eeb2019-12-21 21:57:16 +0000384 the_repository->index_file = old_repo_index_file;
Conrad Irwin1020d082011-05-06 22:59:59 -0700385 if (old_index_env && *old_index_env)
386 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
387 else
388 unsetenv(INDEX_ENVIRONMENT);
Jeff King406bab32019-01-11 17:15:40 -0500389 FREE_AND_NULL(old_index_env);
Conrad Irwin1020d082011-05-06 22:59:59 -0700390
391 discard_cache();
Michael Haggertyb4fb09e2015-08-10 11:47:39 +0200392 read_cache_from(get_lock_file_path(&index_lock));
David Turner9c4d6c02014-07-13 13:28:19 -0700393 if (update_main_cache_tree(WRITE_TREE_SILENT) == 0) {
Junio C Hamano3fd13cb2014-09-11 10:33:32 -0700394 if (reopen_lock_file(&index_lock) < 0)
David Turner9c4d6c02014-07-13 13:28:19 -0700395 die(_("unable to write index file"));
Martin Ågren812d6b02017-10-06 22:12:12 +0200396 if (write_locked_index(&the_index, &index_lock, 0))
Junio C Hamano3fd13cb2014-09-11 10:33:32 -0700397 die(_("unable to update temporary index"));
David Turner9c4d6c02014-07-13 13:28:19 -0700398 } else
399 warning(_("Failed to update main cache tree"));
Conrad Irwin1020d082011-05-06 22:59:59 -0700400
401 commit_style = COMMIT_NORMAL;
Martin Ågrendd1055e2017-09-23 01:34:49 +0200402 ret = get_lock_file_path(&index_lock);
403 goto out;
Conrad Irwin1020d082011-05-06 22:59:59 -0700404 }
405
Junio C Hamano28886052007-11-18 01:52:55 -0800406 /*
407 * Non partial, non as-is commit.
408 *
409 * (1) get the real index;
410 * (2) update the_index as necessary;
411 * (3) write the_index out to the real index (still locked);
412 * (4) return the name of the locked index file.
413 *
414 * The caller should run hooks on the locked real index, and
415 * (A) if all goes well, commit the real index;
416 * (B) on failure, rollback the real index.
417 */
Nguyễn Thái Ngọc Duy6654c882013-07-14 15:35:38 +0700418 if (all || (also && pathspec.nr)) {
Junio C Hamanob3e83cc2016-12-07 10:33:54 -0800419 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
Thomas Gummerer610d55a2016-09-14 22:07:47 +0100420 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
Matthieu Moyd38a30d2010-01-12 10:54:44 +0100421 refresh_cache_or_die(refresh_flags);
Nguyễn Thái Ngọc Duye859c692012-01-16 09:36:46 +0700422 update_main_cache_tree(WRITE_TREE_SILENT);
Martin Ågren812d6b02017-10-06 22:12:12 +0200423 if (write_locked_index(&the_index, &index_lock, 0))
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000424 die(_("unable to write new_index file"));
Junio C Hamano28886052007-11-18 01:52:55 -0800425 commit_style = COMMIT_NORMAL;
Martin Ågrendd1055e2017-09-23 01:34:49 +0200426 ret = get_lock_file_path(&index_lock);
427 goto out;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500428 }
429
Junio C Hamano28886052007-11-18 01:52:55 -0800430 /*
431 * As-is commit.
432 *
433 * (1) return the name of the real index file.
434 *
Markus Heidelberg73276232010-04-02 14:27:18 +0200435 * The caller should run hooks on the real index,
436 * and create commit from the_index.
Junio C Hamano28886052007-11-18 01:52:55 -0800437 * We still need to refresh the index here.
438 */
Nguyễn Thái Ngọc Duy6654c882013-07-14 15:35:38 +0700439 if (!only && !pathspec.nr) {
Junio C Hamanob3e83cc2016-12-07 10:33:54 -0800440 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
Matthieu Moyd38a30d2010-01-12 10:54:44 +0100441 refresh_cache_or_die(refresh_flags);
David Turner9c4d6c02014-07-13 13:28:19 -0700442 if (active_cache_changed
David Turner475a3442015-08-27 13:07:54 -0400443 || !cache_tree_fully_valid(active_cache_tree))
Nguyễn Thái Ngọc Duye859c692012-01-16 09:36:46 +0700444 update_main_cache_tree(WRITE_TREE_SILENT);
Martin Ågren61000812018-03-01 21:40:20 +0100445 if (write_locked_index(&the_index, &index_lock,
446 COMMIT_LOCK | SKIP_IF_UNCHANGED))
447 die(_("unable to write new_index file"));
Junio C Hamano28886052007-11-18 01:52:55 -0800448 commit_style = COMMIT_AS_IS;
Martin Ågrendd1055e2017-09-23 01:34:49 +0200449 ret = get_index_file();
450 goto out;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500451 }
452
Junio C Hamano28886052007-11-18 01:52:55 -0800453 /*
454 * A partial commit.
455 *
456 * (0) find the set of affected paths;
457 * (1) get lock on the real index file;
458 * (2) update the_index with the given paths;
459 * (3) write the_index out to the real index (still locked);
460 * (4) get lock on the false index file;
461 * (5) reset the_index from HEAD;
462 * (6) update the_index the same way as (2);
463 * (7) write the_index out to the false index file;
464 * (8) return the name of the false index file (still locked);
465 *
466 * The caller should run hooks on the locked false index, and
467 * create commit from it. Then
468 * (A) if all goes well, commit the real index;
469 * (B) on failure, rollback the real index;
470 * In either case, rollback the false index.
471 */
472 commit_style = COMMIT_PARTIAL;
473
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +0000474 if (whence != FROM_COMMIT) {
475 if (whence == FROM_MERGE)
476 die(_("cannot do a partial commit during a merge."));
Phillip Wood8d57f752019-12-06 16:06:10 +0000477 else if (is_from_cherry_pick(whence))
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +0000478 die(_("cannot do a partial commit during a cherry-pick."));
Phillip Wood430b75f2019-12-06 16:06:12 +0000479 else if (is_from_rebase(whence))
480 die(_("cannot do a partial commit during a rebase."));
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +0000481 }
Junio C Hamano28886052007-11-18 01:52:55 -0800482
Jeff Kingc5c33502019-03-20 04:15:48 -0400483 if (list_paths(&partial, !current_head ? NULL : "HEAD", &pathspec))
Junio C Hamano28886052007-11-18 01:52:55 -0800484 exit(1);
485
486 discard_cache();
487 if (read_cache() < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000488 die(_("cannot read the index"));
Junio C Hamano28886052007-11-18 01:52:55 -0800489
Junio C Hamanob3e83cc2016-12-07 10:33:54 -0800490 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
Junio C Hamano28886052007-11-18 01:52:55 -0800491 add_remove_files(&partial);
Kristian Høgsbergef12b502007-11-12 15:48:22 -0500492 refresh_cache(REFRESH_QUIET);
David Turner9c4d6c02014-07-13 13:28:19 -0700493 update_main_cache_tree(WRITE_TREE_SILENT);
Martin Ågren812d6b02017-10-06 22:12:12 +0200494 if (write_locked_index(&the_index, &index_lock, 0))
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000495 die(_("unable to write new_index file"));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500496
Nguyễn Thái Ngọc Duy03b86642014-06-13 19:19:23 +0700497 hold_lock_file_for_update(&false_lock,
498 git_path("next-index-%"PRIuMAX,
499 (uintmax_t) getpid()),
500 LOCK_DIE_ON_ERROR);
Linus Torvaldsfa9dcf82008-01-13 00:30:56 -0800501
Junio C Hamano06bb6432011-08-19 11:58:18 -0700502 create_base_index(current_head);
Junio C Hamano28886052007-11-18 01:52:55 -0800503 add_remove_files(&partial);
Kristian Høgsbergd37d3202007-11-09 11:40:27 -0500504 refresh_cache(REFRESH_QUIET);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500505
Martin Ågren812d6b02017-10-06 22:12:12 +0200506 if (write_locked_index(&the_index, &false_lock, 0))
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000507 die(_("unable to write temporary index file"));
Jeff King959ba672008-02-14 12:18:23 -0500508
509 discard_cache();
Michael Haggertyb4fb09e2015-08-10 11:47:39 +0200510 ret = get_lock_file_path(&false_lock);
511 read_cache_from(ret);
Martin Ågrendd1055e2017-09-23 01:34:49 +0200512out:
513 string_list_clear(&partial, 0);
514 clear_pathspec(&pathspec);
Michael Haggertyb4fb09e2015-08-10 11:47:39 +0200515 return ret;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500516}
517
Junio C Hamanod249b092009-08-09 21:59:30 -0700518static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
519 struct wt_status *s)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500520{
brian m. carlson8066df42017-02-20 00:10:14 +0000521 struct object_id oid;
Junio C Hamano76e2f7c2009-08-07 23:31:57 -0700522
Junio C Hamanod249b092009-08-09 21:59:30 -0700523 if (s->relative_paths)
524 s->prefix = prefix;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500525
526 if (amend) {
Junio C Hamanod249b092009-08-09 21:59:30 -0700527 s->amend = 1;
528 s->reference = "HEAD^1";
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500529 }
Junio C Hamanod249b092009-08-09 21:59:30 -0700530 s->verbose = verbose;
531 s->index_file = index_file;
532 s->fp = fp;
533 s->nowarn = nowarn;
brian m. carlsone82caf32017-07-13 23:49:28 +0000534 s->is_initial = get_oid(s->reference, &oid) ? 1 : 0;
Jeff Hostetlerd9fc7462016-08-11 10:45:59 -0400535 if (!s->is_initial)
brian m. carlsone0cb7cd2019-08-18 20:04:21 +0000536 oidcpy(&s->oid_commit, &oid);
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -0400537 s->status_format = status_format;
538 s->ignore_submodule_arg = ignore_submodule_arg;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500539
Junio C Hamano76e2f7c2009-08-07 23:31:57 -0700540 wt_status_collect(s);
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -0400541 wt_status_print(s);
Stephen P. Smith73ba5d72018-09-30 07:12:45 -0700542 wt_status_collect_free_buffers(s);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500543
Stephen P. Smith6fa90192018-09-05 17:53:27 -0700544 return s->committable;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500545}
546
Junio C Hamano06bb6432011-08-19 11:58:18 -0700547static int is_a_merge(const struct commit *current_head)
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100548{
Junio C Hamano06bb6432011-08-19 11:58:18 -0700549 return !!(current_head->parents && current_head->parents->next);
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100550}
551
Jeff Kingfac90832014-12-10 10:42:10 -0500552static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
553{
Jeff Kingc83a5092014-12-10 10:43:42 -0500554 if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)
Johannes Schindelin033abf92018-05-02 11:38:39 +0200555 BUG("unable to parse our own ident: %s", buf->buf);
Jeff Kingfac90832014-12-10 10:42:10 -0500556}
557
Junio C Hamano7dfe8ad2012-03-11 03:12:10 -0700558static void export_one(const char *var, const char *s, const char *e, int hack)
559{
560 struct strbuf buf = STRBUF_INIT;
561 if (hack)
562 strbuf_addch(&buf, hack);
René Scharfe147ee352019-12-07 12:16:04 +0100563 strbuf_add(&buf, s, e - s);
Junio C Hamano7dfe8ad2012-03-11 03:12:10 -0700564 setenv(var, buf.buf, 1);
565 strbuf_release(&buf);
566}
567
Jeff Kingc33ddc22014-08-27 03:57:08 -0400568static int parse_force_date(const char *in, struct strbuf *out)
Jeff King14ac2862014-05-01 21:12:42 -0400569{
Jeff Kingc33ddc22014-08-27 03:57:08 -0400570 strbuf_addch(out, '@');
Jeff King14ac2862014-05-01 21:12:42 -0400571
Jeff Kingc33ddc22014-08-27 03:57:08 -0400572 if (parse_date(in, out) < 0) {
Jeff King14ac2862014-05-01 21:12:42 -0400573 int errors = 0;
574 unsigned long t = approxidate_careful(in, &errors);
575 if (errors)
576 return -1;
Jeff Kingc33ddc22014-08-27 03:57:08 -0400577 strbuf_addf(out, "%lu", t);
Jeff King14ac2862014-05-01 21:12:42 -0400578 }
579
580 return 0;
581}
582
Jeff Kingf4ef5172014-08-27 03:57:56 -0400583static void set_ident_var(char **buf, char *val)
584{
585 free(*buf);
586 *buf = val;
587}
588
Junio C Hamano4c28e4a2010-12-20 17:00:36 -0800589static void determine_author_info(struct strbuf *author_ident)
Santi Béjara45d46b2008-05-04 18:04:49 +0200590{
591 char *name, *email, *date;
Junio C Hamano7dfe8ad2012-03-11 03:12:10 -0700592 struct ident_split author;
Santi Béjara45d46b2008-05-04 18:04:49 +0200593
Jeff Kingeaa541e2015-01-12 20:58:33 -0500594 name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
595 email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
596 date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
Santi Béjara45d46b2008-05-04 18:04:49 +0200597
Jay Soffian37f7a852011-02-19 23:12:29 -0500598 if (author_message) {
Jeff Kingf0f96622014-08-27 03:57:28 -0400599 struct ident_split ident;
Junio C Hamano2c733fb2012-02-02 13:41:43 -0800600 size_t len;
Jeff Kingf0f96622014-08-27 03:57:28 -0400601 const char *a;
Santi Béjara45d46b2008-05-04 18:04:49 +0200602
Jeff Kingf0f96622014-08-27 03:57:28 -0400603 a = find_commit_header(author_message_buffer, "author", &len);
Santi Béjara45d46b2008-05-04 18:04:49 +0200604 if (!a)
Jeff Kingf0f96622014-08-27 03:57:28 -0400605 die(_("commit '%s' lacks author header"), author_message);
606 if (split_ident_line(&ident, a, len) < 0)
607 die(_("commit '%s' has malformed author line"), author_message);
Santi Béjara45d46b2008-05-04 18:04:49 +0200608
Jeff Kingf4ef5172014-08-27 03:57:56 -0400609 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
610 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
Santi Béjara45d46b2008-05-04 18:04:49 +0200611
Jeff Kingf0f96622014-08-27 03:57:28 -0400612 if (ident.date_begin) {
Jeff Kingf4ef5172014-08-27 03:57:56 -0400613 struct strbuf date_buf = STRBUF_INIT;
Jeff Kingf0f96622014-08-27 03:57:28 -0400614 strbuf_addch(&date_buf, '@');
615 strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);
616 strbuf_addch(&date_buf, ' ');
617 strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);
Jeff Kingf4ef5172014-08-27 03:57:56 -0400618 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
Jeff Kingf0f96622014-08-27 03:57:28 -0400619 }
Santi Béjara45d46b2008-05-04 18:04:49 +0200620 }
621
622 if (force_author) {
Jeff Kingf0f96622014-08-27 03:57:28 -0400623 struct ident_split ident;
Santi Béjara45d46b2008-05-04 18:04:49 +0200624
Jeff Kingf0f96622014-08-27 03:57:28 -0400625 if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000626 die(_("malformed --author parameter"));
Jeff Kingf4ef5172014-08-27 03:57:56 -0400627 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
628 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
Santi Béjara45d46b2008-05-04 18:04:49 +0200629 }
630
Jeff King14ac2862014-05-01 21:12:42 -0400631 if (force_date) {
Jeff Kingf4ef5172014-08-27 03:57:56 -0400632 struct strbuf date_buf = STRBUF_INIT;
Jeff Kingc33ddc22014-08-27 03:57:08 -0400633 if (parse_force_date(force_date, &date_buf))
Jeff King14ac2862014-05-01 21:12:42 -0400634 die(_("invalid date format: %s"), force_date);
Jeff Kingf4ef5172014-08-27 03:57:56 -0400635 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
Jeff King14ac2862014-05-01 21:12:42 -0400636 }
637
William Hubbs39ab4d02019-02-04 12:48:50 -0600638 strbuf_addstr(author_ident, fmt_ident(name, email, WANT_AUTHOR_IDENT, date,
639 IDENT_STRICT));
Jeff Kingc83a5092014-12-10 10:43:42 -0500640 assert_split_ident(&author, author_ident);
641 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
642 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
643 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
Jeff Kingf4ef5172014-08-27 03:57:56 -0400644 free(name);
645 free(email);
646 free(date);
Santi Béjara45d46b2008-05-04 18:04:49 +0200647}
648
Jeff Kingb7242b82014-05-01 21:10:01 -0400649static int author_date_is_interesting(void)
650{
651 return author_message || force_date;
Junio C Hamano4c28e4a2010-12-20 17:00:36 -0800652}
653
Nguyễn Thái Ngọc Duy84c9dc22014-05-17 08:52:23 +0700654static void adjust_comment_line_char(const struct strbuf *sb)
655{
656 char candidates[] = "#;@!$%^&|:";
657 char *candidate;
658 const char *p;
659
660 comment_line_char = candidates[0];
661 if (!memchr(sb->buf, comment_line_char, sb->len))
662 return;
663
664 p = sb->buf;
665 candidate = strchr(candidates, *p);
666 if (candidate)
667 *candidate = ' ';
668 for (p = sb->buf; *p; p++) {
669 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
670 candidate = strchr(candidates, p[1]);
671 if (candidate)
672 *candidate = ' ';
673 }
674 }
675
676 for (p = candidates; *p == ' '; p++)
677 ;
678 if (!*p)
679 die(_("unable to select a comment character that is not used\n"
680 "in the current commit message"));
681 comment_line_char = *p;
682}
683
Junio C Hamanod249b092009-08-09 21:59:30 -0700684static int prepare_to_commit(const char *index_file, const char *prefix,
Junio C Hamano06bb6432011-08-19 11:58:18 -0700685 struct commit *current_head,
Junio C Hamano4c28e4a2010-12-20 17:00:36 -0800686 struct wt_status *s,
687 struct strbuf *author_ident)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500688{
689 struct stat statbuf;
Junio C Hamano4c28e4a2010-12-20 17:00:36 -0800690 struct strbuf committer_ident = STRBUF_INIT;
Stephen P. Smith6fa90192018-09-05 17:53:27 -0700691 int committable;
Brandon Caseyf285a2d2008-10-09 14:12:12 -0500692 struct strbuf sb = STRBUF_INIT;
Paolo Bonzini8089c852008-02-05 08:04:18 +0100693 const char *hook_arg1 = NULL;
694 const char *hook_arg2 = NULL;
Phillip Woodd0aaa462017-11-10 11:09:42 +0000695 int clean_message_contents = (cleanup_mode != COMMIT_MSG_CLEANUP_NONE);
Matthieu Moy2556b992013-09-06 19:43:07 +0200696 int old_display_comment_prefix;
Denton Liu10559972019-04-17 11:23:28 +0100697 int merge_contains_scissors = 0;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500698
Junio C Hamano7dfe8ad2012-03-11 03:12:10 -0700699 /* This checks and barfs if author is badly specified */
700 determine_author_info(author_ident);
701
Benoit Pierre15048f82014-03-18 11:00:53 +0100702 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100703 return 0;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500704
Pat Notz89ac1222010-11-02 13:59:11 -0600705 if (squash_message) {
706 /*
707 * Insert the proper subject line before other commit
708 * message options add their content.
709 */
710 if (use_message && !strcmp(use_message, squash_message))
711 strbuf_addstr(&sb, "squash! ");
712 else {
713 struct pretty_print_context ctx = {0};
714 struct commit *c;
715 c = lookup_commit_reference_by_name(squash_message);
716 if (!c)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000717 die(_("could not lookup commit %s"), squash_message);
Pat Notz89ac1222010-11-02 13:59:11 -0600718 ctx.output_encoding = get_commit_output_encoding();
719 format_commit_message(c, "squash! %s\n\n", &sb,
720 &ctx);
721 }
722 }
723
Ævar Arnfjörð Bjarmason30884c92017-12-22 20:41:52 +0000724 if (have_option_m && !fixup_message) {
Johannes Schindelinf9568532007-11-11 17:36:39 +0000725 strbuf_addbuf(&sb, &message);
Paolo Bonzini8089c852008-02-05 08:04:18 +0100726 hook_arg1 = "message";
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500727 } else if (logfile && !strcmp(logfile, "-")) {
728 if (isatty(0))
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000729 fprintf(stderr, _("(reading log message from standard input)\n"));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500730 if (strbuf_read(&sb, 0, 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000731 die_errno(_("could not read log from standard input"));
Paolo Bonzini8089c852008-02-05 08:04:18 +0100732 hook_arg1 = "message";
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500733 } else if (logfile) {
734 if (strbuf_read_file(&sb, logfile, 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000735 die_errno(_("could not read log file '%s'"),
Thomas Rastd824cbb2009-06-27 17:58:46 +0200736 logfile);
Paolo Bonzini8089c852008-02-05 08:04:18 +0100737 hook_arg1 = "message";
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500738 } else if (use_message) {
Elia Pintoe23fd152014-01-30 07:15:56 -0800739 char *buffer;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500740 buffer = strstr(use_message_buffer, "\n\n");
Jeff King076cbd62014-04-25 19:11:15 -0400741 if (buffer)
Johannes Schindelin84e213a2016-06-29 16:14:42 +0200742 strbuf_addstr(&sb, skip_blank_lines(buffer + 2));
Paolo Bonzini8089c852008-02-05 08:04:18 +0100743 hook_arg1 = "commit";
744 hook_arg2 = use_message;
Pat Notzd71b8ba2010-11-02 13:59:09 -0600745 } else if (fixup_message) {
746 struct pretty_print_context ctx = {0};
747 struct commit *commit;
748 commit = lookup_commit_reference_by_name(fixup_message);
749 if (!commit)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000750 die(_("could not lookup commit %s"), fixup_message);
Pat Notzd71b8ba2010-11-02 13:59:09 -0600751 ctx.output_encoding = get_commit_output_encoding();
752 format_commit_message(commit, "fixup! %s\n\n",
753 &sb, &ctx);
Ævar Arnfjörð Bjarmason30884c92017-12-22 20:41:52 +0000754 if (have_option_m)
755 strbuf_addbuf(&sb, &message);
Pat Notzd71b8ba2010-11-02 13:59:09 -0600756 hook_arg1 = "message";
Stefan Beller102de882018-05-17 15:51:51 -0700757 } else if (!stat(git_path_merge_msg(the_repository), &statbuf)) {
Denton Liu10559972019-04-17 11:23:28 +0100758 size_t merge_msg_start;
759
Sven Strickrothb64c1e02016-03-21 23:29:40 +0100760 /*
761 * prepend SQUASH_MSG here if it exists and a
762 * "merge --squash" was originally performed
763 */
Stefan Beller102de882018-05-17 15:51:51 -0700764 if (!stat(git_path_squash_msg(the_repository), &statbuf)) {
765 if (strbuf_read_file(&sb, git_path_squash_msg(the_repository), 0) < 0)
Sven Strickrothb64c1e02016-03-21 23:29:40 +0100766 die_errno(_("could not read SQUASH_MSG"));
767 hook_arg1 = "squash";
768 } else
769 hook_arg1 = "merge";
Denton Liu10559972019-04-17 11:23:28 +0100770
771 merge_msg_start = sb.len;
Stefan Beller102de882018-05-17 15:51:51 -0700772 if (strbuf_read_file(&sb, git_path_merge_msg(the_repository), 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000773 die_errno(_("could not read MERGE_MSG"));
Denton Liu10559972019-04-17 11:23:28 +0100774
775 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS &&
776 wt_status_locate_end(sb.buf + merge_msg_start,
777 sb.len - merge_msg_start) <
778 sb.len - merge_msg_start)
779 merge_contains_scissors = 1;
Stefan Beller102de882018-05-17 15:51:51 -0700780 } else if (!stat(git_path_squash_msg(the_repository), &statbuf)) {
781 if (strbuf_read_file(&sb, git_path_squash_msg(the_repository), 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000782 die_errno(_("could not read SQUASH_MSG"));
Paolo Bonzini8089c852008-02-05 08:04:18 +0100783 hook_arg1 = "squash";
Jonathan Nieder2140b142011-02-25 03:07:57 -0600784 } else if (template_file) {
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500785 if (strbuf_read_file(&sb, template_file, 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000786 die_errno(_("could not read '%s'"), template_file);
Paolo Bonzini8089c852008-02-05 08:04:18 +0100787 hook_arg1 = "template";
Boris Faure8b1ae672011-05-08 12:31:02 +0200788 clean_message_contents = 0;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500789 }
790
Paolo Bonzini8089c852008-02-05 08:04:18 +0100791 /*
Jay Soffian37f7a852011-02-19 23:12:29 -0500792 * The remaining cases don't modify the template message, but
793 * just set the argument(s) to the prepare-commit-msg hook.
Paolo Bonzini8089c852008-02-05 08:04:18 +0100794 */
Jay Soffian37f7a852011-02-19 23:12:29 -0500795 else if (whence == FROM_MERGE)
Paolo Bonzini8089c852008-02-05 08:04:18 +0100796 hook_arg1 = "merge";
Phillip Wood430b75f2019-12-06 16:06:12 +0000797 else if (is_from_cherry_pick(whence) || whence == FROM_REBASE_PICK) {
Jay Soffian37f7a852011-02-19 23:12:29 -0500798 hook_arg1 = "commit";
799 hook_arg2 = "CHERRY_PICK_HEAD";
800 }
Paolo Bonzini8089c852008-02-05 08:04:18 +0100801
Pat Notz89ac1222010-11-02 13:59:11 -0600802 if (squash_message) {
803 /*
804 * If squash_commit was used for the commit subject,
805 * then we're possibly hijacking other commit log options.
806 * Reset the hook args to tell the real story.
807 */
808 hook_arg1 = "message";
809 hook_arg2 = "";
810 }
811
Pranit Bauvae51b0df2016-05-25 00:49:50 +0530812 s->fp = fopen_for_writing(git_path_commit_editmsg());
Jonathan Nieder37f30122011-02-25 23:10:49 -0600813 if (s->fp == NULL)
Pranit Bauvae51b0df2016-05-25 00:49:50 +0530814 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500815
Matthieu Moy2556b992013-09-06 19:43:07 +0200816 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
817 old_display_comment_prefix = s->display_comment_prefix;
818 s->display_comment_prefix = 1;
819
Matthieu Moyea9882b2013-09-12 12:50:06 +0200820 /*
821 * Most hints are counter-productive when the commit has
822 * already started.
823 */
824 s->hints = 0;
825
Boris Faure8b1ae672011-05-08 12:31:02 +0200826 if (clean_message_contents)
Tobias Klauser63af4a82015-10-16 17:16:42 +0200827 strbuf_stripspace(&sb, 0);
Johannes Schindelin13208572007-11-11 17:35:58 +0000828
Junio C Hamano073bd752014-10-28 12:44:09 -0700829 if (signoff)
Jonathan Tan710714a2016-11-02 10:29:17 -0700830 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
Johannes Schindelin13208572007-11-11 17:35:58 +0000831
Jonathan Nieder37f30122011-02-25 23:10:49 -0600832 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000833 die_errno(_("could not write commit template"));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500834
Nguyễn Thái Ngọc Duy84c9dc22014-05-17 08:52:23 +0700835 if (auto_comment_line_char)
836 adjust_comment_line_char(&sb);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500837 strbuf_release(&sb);
838
Santi Béjarbb1ae3f2008-05-04 18:04:51 +0200839 /* This checks if committer ident is explicitly given */
Jeff Kingf20f3872012-07-23 14:50:35 -0400840 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
James P. Howard, IIbed575e2009-12-07 17:45:27 -0500841 if (use_editor && include_status) {
Elia Pintoe23fd152014-01-30 07:15:56 -0800842 int ident_shown = 0;
843 int saved_color_setting;
Jeff King47010262014-05-01 21:06:57 -0400844 struct ident_split ci, ai;
845
Nguyễn Thái Ngọc Duy75df1f42014-02-17 19:15:32 +0700846 if (whence != FROM_COMMIT) {
Denton Liu10559972019-04-17 11:23:28 +0100847 if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS &&
848 !merge_contains_scissors)
Nguyễn Thái Ngọc Duy75df1f42014-02-17 19:15:32 +0700849 wt_status_add_cut_line(s->fp);
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600850 status_printf_ln(s, GIT_COLOR_NORMAL,
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +0000851 whence == FROM_MERGE
852 ? _("\n"
853 "It looks like you may be committing a merge.\n"
854 "If this is not correct, please remove the file\n"
855 " %s\n"
856 "and try again.\n")
857 : _("\n"
858 "It looks like you may be committing a cherry-pick.\n"
859 "If this is not correct, please remove the file\n"
860 " %s\n"
861 "and try again.\n"),
Jeff Kingca03e062017-04-20 17:08:54 -0400862 whence == FROM_MERGE ?
Stefan Beller102de882018-05-17 15:51:51 -0700863 git_path_merge_head(the_repository) :
864 git_path_cherry_pick_head(the_repository));
Nguyễn Thái Ngọc Duy75df1f42014-02-17 19:15:32 +0700865 }
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100866
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600867 fprintf(s->fp, "\n");
Phillip Woodd0aaa462017-11-10 11:09:42 +0000868 if (cleanup_mode == COMMIT_MSG_CLEANUP_ALL)
Ævar Arnfjörð Bjarmason4064e662012-04-30 15:33:14 +0000869 status_printf(s, GIT_COLOR_NORMAL,
870 _("Please enter the commit message for your changes."
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100871 " Lines starting\nwith '%c' will be ignored, and an empty"
872 " message aborts the commit.\n"), comment_line_char);
Denton Liu10559972019-04-17 11:23:28 +0100873 else if (cleanup_mode == COMMIT_MSG_CLEANUP_SCISSORS) {
874 if (whence == FROM_COMMIT && !merge_contains_scissors)
875 wt_status_add_cut_line(s->fp);
876 } else /* COMMIT_MSG_CLEANUP_SPACE, that is. */
Ævar Arnfjörð Bjarmason4064e662012-04-30 15:33:14 +0000877 status_printf(s, GIT_COLOR_NORMAL,
878 _("Please enter the commit message for your changes."
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100879 " Lines starting\n"
880 "with '%c' will be kept; you may remove them"
881 " yourself if you want to.\n"
882 "An empty message aborts the commit.\n"), comment_line_char);
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100883
Jeff Kingfac90832014-12-10 10:42:10 -0500884 /*
885 * These should never fail because they come from our own
886 * fmt_ident. They may fail the sane_ident test, but we know
887 * that the name and mail pointers will at least be valid,
888 * which is enough for our tests and printing here.
889 */
890 assert_split_ident(&ai, author_ident);
891 assert_split_ident(&ci, &committer_ident);
Jeff King47010262014-05-01 21:06:57 -0400892
893 if (ident_cmp(&ai, &ci))
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600894 status_printf_ln(s, GIT_COLOR_NORMAL,
Ævar Arnfjörð Bjarmasonfe8165c2011-02-22 23:41:46 +0000895 _("%s"
Jeff King47010262014-05-01 21:06:57 -0400896 "Author: %.*s <%.*s>"),
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600897 ident_shown++ ? "" : "\n",
Jeff King47010262014-05-01 21:06:57 -0400898 (int)(ai.name_end - ai.name_begin), ai.name_begin,
899 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
Santi Béjare83dbe82008-05-04 18:04:50 +0200900
Jeff Kingb7242b82014-05-01 21:10:01 -0400901 if (author_date_is_interesting())
902 status_printf_ln(s, GIT_COLOR_NORMAL,
903 _("%s"
904 "Date: %s"),
905 ident_shown++ ? "" : "\n",
Jeff Kinga5481a62015-06-25 12:55:02 -0400906 show_ident_date(&ai, DATE_MODE(NORMAL)));
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100907
Jeff Kingd6991ce2012-11-14 16:34:13 -0800908 if (!committer_ident_sufficiently_given())
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600909 status_printf_ln(s, GIT_COLOR_NORMAL,
Ævar Arnfjörð Bjarmasonfe8165c2011-02-22 23:41:46 +0000910 _("%s"
Jeff King47010262014-05-01 21:06:57 -0400911 "Committer: %.*s <%.*s>"),
Jonathan Niederb926c0d2011-02-25 23:11:37 -0600912 ident_shown++ ? "" : "\n",
Jeff King47010262014-05-01 21:06:57 -0400913 (int)(ci.name_end - ci.name_begin), ci.name_begin,
914 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
Santi Béjarbb1ae3f2008-05-04 18:04:51 +0200915
Kaartic Sivaraamb3cf1b72017-06-30 17:42:21 +0530916 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); /* Add new line for clarity */
Santi Béjarbb1ae3f2008-05-04 18:04:51 +0200917
Junio C Hamanod249b092009-08-09 21:59:30 -0700918 saved_color_setting = s->use_color;
919 s->use_color = 0;
Stephen P. Smith6fa90192018-09-05 17:53:27 -0700920 committable = run_status(s->fp, index_file, prefix, 1, s);
Junio C Hamanod249b092009-08-09 21:59:30 -0700921 s->use_color = saved_color_setting;
Elijah Newren3e73cc62018-09-27 10:36:57 -0700922 string_list_clear(&s->change, 1);
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100923 } else {
brian m. carlson8066df42017-02-20 00:10:14 +0000924 struct object_id oid;
Junio C Hamanofbcf1182007-12-19 19:23:03 -0800925 const char *parent = "HEAD";
Alex Riesen71686242007-11-28 22:13:08 +0100926
Alex Riesen71686242007-11-28 22:13:08 +0100927 if (!active_nr && read_cache() < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000928 die(_("Cannot read index"));
Alex Riesen71686242007-11-28 22:13:08 +0100929
Junio C Hamanofbcf1182007-12-19 19:23:03 -0800930 if (amend)
931 parent = "HEAD^1";
932
brian m. carlsone82caf32017-07-13 23:49:28 +0000933 if (get_oid(parent, &oid)) {
Nguyễn Thái Ngọc Duy2c49f7f2016-10-24 17:42:22 +0700934 int i, ita_nr = 0;
935
936 for (i = 0; i < active_nr; i++)
937 if (ce_intent_to_add(active_cache[i]))
938 ita_nr++;
Stephen P. Smith6fa90192018-09-05 17:53:27 -0700939 committable = active_nr - ita_nr > 0;
Nguyễn Thái Ngọc Duy2c49f7f2016-10-24 17:42:22 +0700940 } else {
Jens Lehmannc215d3d2014-04-05 18:59:36 +0200941 /*
942 * Unless the user did explicitly request a submodule
943 * ignore mode by passing a command line option we do
944 * not ignore any changed submodule SHA-1s when
945 * comparing index and parent, no matter what is
946 * configured. Otherwise we won't commit any
947 * submodules which were manually staged, which would
948 * be really confusing.
949 */
Brandon Williams02f2f562017-10-31 11:19:05 -0700950 struct diff_flags flags = DIFF_FLAGS_INIT;
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700951 flags.override_submodule_config = 1;
Jens Lehmannc215d3d2014-04-05 18:59:36 +0200952 if (ignore_submodule_arg &&
953 !strcmp(ignore_submodule_arg, "all"))
Brandon Williams0d1e0e72017-10-31 11:19:11 -0700954 flags.ignore_submodules = 1;
Nguyễn Thái Ngọc Duyffc00a42018-11-10 06:49:04 +0100955 committable = index_differs_from(the_repository,
956 parent, &flags, 1);
Jens Lehmannc215d3d2014-04-05 18:59:36 +0200957 }
Alex Riesen71686242007-11-28 22:13:08 +0100958 }
Junio C Hamano4c28e4a2010-12-20 17:00:36 -0800959 strbuf_release(&committer_ident);
Alex Riesen71686242007-11-28 22:13:08 +0100960
Jonathan Nieder37f30122011-02-25 23:10:49 -0600961 fclose(s->fp);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -0500962
Jay Soffian37f7a852011-02-19 23:12:29 -0500963 /*
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.
967 */
Stephen P. Smith6fa90192018-09-05 17:53:27 -0700968 if (!committable && whence != FROM_MERGE && !allow_empty &&
Junio C Hamano06bb6432011-08-19 11:58:18 -0700969 !(amend && is_a_merge(current_head))) {
Heba Waly5c4f55f2019-12-17 09:17:22 +0000970 s->hints = advice_status_hints;
Matthieu Moy2556b992013-09-06 19:43:07 +0200971 s->display_comment_prefix = old_display_comment_prefix;
Junio C Hamanod249b092009-08-09 21:59:30 -0700972 run_status(stdout, index_file, prefix, 0, s);
Jeff Kingf197ed22010-06-06 20:41:46 -0400973 if (amend)
Ævar Arnfjörð Bjarmasonfc88e312011-02-22 23:41:49 +0000974 fputs(_(empty_amend_advice), stderr);
Phillip Wood430b75f2019-12-06 16:06:12 +0000975 else if (is_from_cherry_pick(whence) ||
976 whence == FROM_REBASE_PICK) {
Junio C Hamano6c80cd22011-04-01 17:55:55 -0700977 fputs(_(empty_cherry_pick_advice), stderr);
Phillip Wood8d57f752019-12-06 16:06:10 +0000978 if (whence == FROM_CHERRY_PICK_SINGLE)
Jeff Kingc17592a2013-07-26 19:39:28 -0400979 fputs(_(empty_cherry_pick_advice_single), stderr);
Phillip Wood430b75f2019-12-06 16:06:12 +0000980 else if (whence == FROM_CHERRY_PICK_MULTI)
Jeff Kingc17592a2013-07-26 19:39:28 -0400981 fputs(_(empty_cherry_pick_advice_multi), stderr);
Phillip Wood430b75f2019-12-06 16:06:12 +0000982 else
983 fputs(_(empty_rebase_pick_advice), stderr);
Jeff Kingc17592a2013-07-26 19:39:28 -0400984 }
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100985 return 0;
986 }
987
Kevin Willford680ee552017-08-14 15:54:25 -0600988 if (!no_verify && find_hook("pre-commit")) {
989 /*
990 * Re-read the index as pre-commit hook could have updated it,
991 * and write it out as a tree. We must do this before we invoke
992 * the editor and after we invoke run_status above.
993 */
994 discard_cache();
995 }
Paolo Bonziniec84bd02008-02-05 11:01:46 +0100996 read_cache_from(index_file);
Kevin Willford680ee552017-08-14 15:54:25 -0600997
Thomas Rast996277c2011-12-06 18:43:37 +0100998 if (update_main_cache_tree(0)) {
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +0000999 error(_("Error building trees"));
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001000 return 0;
1001 }
1002
Benoit Pierre15048f82014-03-18 11:00:53 +01001003 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
Pranit Bauvae51b0df2016-05-25 00:49:50 +05301004 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
Paolo Bonzini8089c852008-02-05 08:04:18 +01001005 return 0;
1006
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001007 if (use_editor) {
Elia Pinto8d7aa4b2017-01-13 17:58:00 +00001008 struct argv_array env = ARGV_ARRAY_INIT;
1009
1010 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
1011 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
Stephan Beyer71982032008-07-25 18:28:42 +02001012 fprintf(stderr,
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001013 _("Please supply the message using either -m or -F option.\n"));
Stephan Beyer71982032008-07-25 18:28:42 +02001014 exit(1);
1015 }
Elia Pinto8d7aa4b2017-01-13 17:58:00 +00001016 argv_array_clear(&env);
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001017 }
1018
1019 if (!no_verify &&
Pranit Bauvae51b0df2016-05-25 00:49:50 +05301020 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001021 return 0;
1022 }
1023
1024 return 1;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001025}
1026
Junio C Hamano146ea062008-08-26 23:13:13 -07001027static const char *find_author_by_nickname(const char *name)
1028{
1029 struct rev_info revs;
1030 struct commit *commit;
1031 struct strbuf buf = STRBUF_INIT;
Antoine Pelisseea167942013-08-23 15:48:31 +02001032 struct string_list mailmap = STRING_LIST_INIT_NODUP;
Junio C Hamano146ea062008-08-26 23:13:13 -07001033 const char *av[20];
1034 int ac = 0;
1035
Nguyễn Thái Ngọc Duy2abf3502018-09-21 17:57:38 +02001036 repo_init_revisions(the_repository, &revs, NULL);
Junio C Hamano146ea062008-08-26 23:13:13 -07001037 strbuf_addf(&buf, "--author=%s", name);
1038 av[++ac] = "--all";
1039 av[++ac] = "-i";
1040 av[++ac] = buf.buf;
1041 av[++ac] = NULL;
1042 setup_revisions(ac, av, &revs, NULL);
Antoine Pelisseea167942013-08-23 15:48:31 +02001043 revs.mailmap = &mailmap;
1044 read_mailmap(revs.mailmap, NULL);
1045
Stefan Beller81c3ce32014-08-10 23:33:26 +02001046 if (prepare_revision_walk(&revs))
1047 die(_("revision walk setup failed"));
Junio C Hamano146ea062008-08-26 23:13:13 -07001048 commit = get_revision(&revs);
1049 if (commit) {
Thomas Rastdd2e7942009-10-19 17:48:08 +02001050 struct pretty_print_context ctx = {0};
Jeff Kinga5481a62015-06-25 12:55:02 -04001051 ctx.date_mode.type = DATE_NORMAL;
Junio C Hamano146ea062008-08-26 23:13:13 -07001052 strbuf_release(&buf);
Antoine Pelisseea167942013-08-23 15:48:31 +02001053 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1054 clear_mailmap(&mailmap);
Junio C Hamano146ea062008-08-26 23:13:13 -07001055 return strbuf_detach(&buf, NULL);
1056 }
Michael J Gruber1044b1f2015-01-26 16:48:33 +01001057 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
Junio C Hamano146ea062008-08-26 23:13:13 -07001058}
1059
Jameson Millereec0f7f2017-10-30 13:21:37 -04001060static void handle_ignored_arg(struct wt_status *s)
1061{
1062 if (!ignored_arg)
1063 ; /* default already initialized */
1064 else if (!strcmp(ignored_arg, "traditional"))
1065 s->show_ignored_mode = SHOW_TRADITIONAL_IGNORED;
1066 else if (!strcmp(ignored_arg, "no"))
1067 s->show_ignored_mode = SHOW_NO_IGNORED;
1068 else if (!strcmp(ignored_arg, "matching"))
1069 s->show_ignored_mode = SHOW_MATCHING_IGNORED;
1070 else
1071 die(_("Invalid ignored mode '%s'"), ignored_arg);
1072}
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001073
1074static void handle_untracked_files_arg(struct wt_status *s)
1075{
1076 if (!untracked_files_arg)
1077 ; /* default already initialized */
1078 else if (!strcmp(untracked_files_arg, "no"))
1079 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1080 else if (!strcmp(untracked_files_arg, "normal"))
1081 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1082 else if (!strcmp(untracked_files_arg, "all"))
1083 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
Nguyễn Thái Ngọc Duy5a59a232019-02-16 18:24:41 +07001084 /*
1085 * Please update $__git_untracked_file_modes in
1086 * git-completion.bash when you add new options
1087 */
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001088 else
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001089 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001090}
1091
Jay Soffian37f7a852011-02-19 23:12:29 -05001092static const char *read_commit_message(const char *name)
1093{
Jeff Kingdd0d3882013-01-26 04:44:06 -05001094 const char *out_enc;
Jay Soffian37f7a852011-02-19 23:12:29 -05001095 struct commit *commit;
1096
1097 commit = lookup_commit_reference_by_name(name);
1098 if (!commit)
Junio C Hamano6c80cd22011-04-01 17:55:55 -07001099 die(_("could not lookup commit %s"), name);
Jay Soffian37f7a852011-02-19 23:12:29 -05001100 out_enc = get_commit_output_encoding();
Nguyễn Thái Ngọc Duy5a10d232013-04-19 09:08:40 +10001101 return logmsg_reencode(commit, NULL, out_enc);
Jay Soffian37f7a852011-02-19 23:12:29 -05001102}
1103
Junio C Hamano84b42022013-06-24 11:41:40 -07001104/*
1105 * Enumerate what needs to be propagated when --porcelain
1106 * is not in effect here.
1107 */
1108static struct status_deferred_config {
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -04001109 enum wt_status_format status_format;
Junio C Hamano84b42022013-06-24 11:41:40 -07001110 int show_branch;
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001111 enum ahead_behind_flags ahead_behind;
Junio C Hamano84b42022013-06-24 11:41:40 -07001112} status_deferred_config = {
1113 STATUS_FORMAT_UNSPECIFIED,
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001114 -1, /* unspecified */
1115 AHEAD_BEHIND_UNSPECIFIED,
Junio C Hamano84b42022013-06-24 11:41:40 -07001116};
1117
1118static void finalize_deferred_config(struct wt_status *s)
1119{
1120 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
Jeff Hostetler1ecdecc2016-08-11 10:45:57 -04001121 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
Junio C Hamano84b42022013-06-24 11:41:40 -07001122 !s->null_termination);
1123
1124 if (s->null_termination) {
1125 if (status_format == STATUS_FORMAT_NONE ||
1126 status_format == STATUS_FORMAT_UNSPECIFIED)
1127 status_format = STATUS_FORMAT_PORCELAIN;
1128 else if (status_format == STATUS_FORMAT_LONG)
1129 die(_("--long and -z are incompatible"));
1130 }
1131
1132 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1133 status_format = status_deferred_config.status_format;
1134 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1135 status_format = STATUS_FORMAT_NONE;
1136
1137 if (use_deferred_config && s->show_branch < 0)
1138 s->show_branch = status_deferred_config.show_branch;
1139 if (s->show_branch < 0)
1140 s->show_branch = 0;
Jeff Hostetlerfd9b5442018-01-09 18:50:16 +00001141
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001142 /*
1143 * If the user did not give a "--[no]-ahead-behind" command
Jeff Hostetlerfb4db1a2019-06-18 13:21:28 -07001144 * line argument *AND* we will print in a human-readable format
1145 * (short, long etc.) then we inherit from the status.aheadbehind
1146 * config setting. In all other cases (and porcelain V[12] formats
1147 * in particular), we inherit _FULL for backwards compatibility.
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001148 */
Jeff Hostetlerfb4db1a2019-06-18 13:21:28 -07001149 if (use_deferred_config &&
1150 s->ahead_behind_flags == AHEAD_BEHIND_UNSPECIFIED)
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001151 s->ahead_behind_flags = status_deferred_config.ahead_behind;
1152
Jeff Hostetlerfd9b5442018-01-09 18:50:16 +00001153 if (s->ahead_behind_flags == AHEAD_BEHIND_UNSPECIFIED)
1154 s->ahead_behind_flags = AHEAD_BEHIND_FULL;
Junio C Hamano84b42022013-06-24 11:41:40 -07001155}
1156
Shawn Bohrer2f02b252007-12-02 23:02:09 -06001157static int parse_and_validate_options(int argc, const char *argv[],
Jeff King036dbbf2012-05-07 15:18:26 -04001158 const struct option *options,
Junio C Hamanodbd0f5c2008-08-06 11:43:47 -07001159 const char * const usage[],
Junio C Hamanod249b092009-08-09 21:59:30 -07001160 const char *prefix,
Junio C Hamano06bb6432011-08-19 11:58:18 -07001161 struct commit *current_head,
Junio C Hamanod249b092009-08-09 21:59:30 -07001162 struct wt_status *s)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001163{
1164 int f = 0;
1165
Jeff King036dbbf2012-05-07 15:18:26 -04001166 argc = parse_options(argc, argv, prefix, options, usage, 0);
Junio C Hamano84b42022013-06-24 11:41:40 -07001167 finalize_deferred_config(s);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001168
Junio C Hamano146ea062008-08-26 23:13:13 -07001169 if (force_author && !strchr(force_author, '>'))
1170 force_author = find_author_by_nickname(force_author);
1171
Erick Mattosc51f6ce2009-11-04 01:20:11 -02001172 if (force_author && renew_authorship)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001173 die(_("Using both --reset-author and --author does not make sense"));
Erick Mattosc51f6ce2009-11-04 01:20:11 -02001174
René Scharfe25206772013-05-25 23:43:34 +02001175 if (logfile || have_option_m || use_message || fixup_message)
Junio C Hamano48034662007-12-22 19:25:37 -08001176 use_editor = 0;
Junio C Hamanoca1ba202011-12-06 13:09:55 -08001177 if (0 <= edit_flag)
1178 use_editor = edit_flag;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001179
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001180 /* Sanity check options */
Junio C Hamano06bb6432011-08-19 11:58:18 -07001181 if (amend && !current_head)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001182 die(_("You have nothing to amend."));
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +00001183 if (amend && whence != FROM_COMMIT) {
1184 if (whence == FROM_MERGE)
1185 die(_("You are in the middle of a merge -- cannot amend."));
Phillip Wood8d57f752019-12-06 16:06:10 +00001186 else if (is_from_cherry_pick(whence))
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +00001187 die(_("You are in the middle of a cherry-pick -- cannot amend."));
Phillip Wood430b75f2019-12-06 16:06:12 +00001188 else if (whence == FROM_REBASE_PICK)
1189 die(_("You are in the middle of a rebase -- cannot amend."));
Ævar Arnfjörð Bjarmasonb0cea472012-04-30 15:33:13 +00001190 }
Pat Notz89ac1222010-11-02 13:59:11 -06001191 if (fixup_message && squash_message)
Ævar Arnfjörð Bjarmason9c227652011-02-22 23:41:45 +00001192 die(_("Options --squash and --fixup cannot be used together"));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001193 if (use_message)
1194 f++;
1195 if (edit_message)
1196 f++;
Pat Notzd71b8ba2010-11-02 13:59:09 -06001197 if (fixup_message)
1198 f++;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001199 if (logfile)
1200 f++;
1201 if (f > 1)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001202 die(_("Only one of -c/-C/-F/--fixup can be used."));
Ævar Arnfjörð Bjarmason30884c92017-12-22 20:41:52 +00001203 if (have_option_m && (edit_message || use_message || logfile))
1204 die((_("Option -m cannot be combined with -c/-C/-F.")));
Jeff King27014cb2016-04-07 12:56:26 -07001205 if (f || have_option_m)
Junio C Hamano010c7db2012-03-30 11:30:59 -07001206 template_file = NULL;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001207 if (edit_message)
1208 use_message = edit_message;
Pat Notzd71b8ba2010-11-02 13:59:09 -06001209 if (amend && !use_message && !fixup_message)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001210 use_message = "HEAD";
Phillip Wood430b75f2019-12-06 16:06:12 +00001211 if (!use_message && !is_from_cherry_pick(whence) &&
1212 !is_from_rebase(whence) && renew_authorship)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001213 die(_("--reset-author can be used only with -C, -c or --amend."));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001214 if (use_message) {
Jay Soffian37f7a852011-02-19 23:12:29 -05001215 use_message_buffer = read_commit_message(use_message);
1216 if (!renew_authorship) {
1217 author_message = use_message;
1218 author_message_buffer = use_message_buffer;
1219 }
1220 }
Phillip Wood430b75f2019-12-06 16:06:12 +00001221 if ((is_from_cherry_pick(whence) || whence == FROM_REBASE_PICK) &&
1222 !renew_authorship) {
Jay Soffian37f7a852011-02-19 23:12:29 -05001223 author_message = "CHERRY_PICK_HEAD";
1224 author_message_buffer = read_commit_message(author_message);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001225 }
1226
Conrad Irwinb4bd4662011-05-07 10:58:07 -07001227 if (patch_interactive)
1228 interactive = 1;
1229
Stefan Beller05efb7b2013-08-07 09:32:25 +02001230 if (also + only + all + interactive > 1)
Conrad Irwinb4bd4662011-05-07 10:58:07 -07001231 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
Denton Liuf29cd862019-04-17 11:23:25 +01001232 cleanup_mode = get_cleanup_mode(cleanup_arg, use_editor);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001233
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001234 handle_untracked_files_arg(s);
Marius Storm-Olsen4bfee302008-06-05 10:31:19 +02001235
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001236 if (all && argc > 0)
Nguyễn Thái Ngọc Duy5a1dbd42019-03-20 17:29:06 +07001237 die(_("paths '%s ...' with -a does not make sense"),
1238 argv[0]);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001239
Jeff Kingf3f47a12012-10-18 21:15:50 +07001240 if (status_format != STATUS_FORMAT_NONE)
Jeff King7c9f7032009-09-05 04:59:56 -04001241 dry_run = 1;
1242
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001243 return argc;
1244}
1245
Junio C Hamanod249b092009-08-09 21:59:30 -07001246static int dry_run_commit(int argc, const char **argv, const char *prefix,
Junio C Hamano06bb6432011-08-19 11:58:18 -07001247 const struct commit *current_head, struct wt_status *s)
Junio C Hamano3a5d13a2009-08-07 23:03:36 -07001248{
Stephen P. Smith6fa90192018-09-05 17:53:27 -07001249 int committable;
Junio C Hamano3a5d13a2009-08-07 23:03:36 -07001250 const char *index_file;
1251
Junio C Hamano06bb6432011-08-19 11:58:18 -07001252 index_file = prepare_index(argc, argv, prefix, current_head, 1);
Stephen P. Smith6fa90192018-09-05 17:53:27 -07001253 committable = run_status(stdout, index_file, prefix, 0, s);
Junio C Hamano3a5d13a2009-08-07 23:03:36 -07001254 rollback_index_files();
1255
Stephen P. Smith6fa90192018-09-05 17:53:27 -07001256 return committable ? 0 : 1;
Junio C Hamano3a5d13a2009-08-07 23:03:36 -07001257}
1258
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +02001259define_list_config_array_extra(color_status_slots, {"added"});
1260
Jonathan Nieder88521172014-10-07 15:16:57 -04001261static int parse_status_slot(const char *slot)
Junio C Hamanof766b362009-08-09 23:12:19 -07001262{
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +02001263 if (!strcasecmp(slot, "added"))
Junio C Hamanof766b362009-08-09 23:12:19 -07001264 return WT_STATUS_UPDATED;
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +02001265
1266 return LOOKUP_CONFIG(color_status_slots, slot);
Junio C Hamanof766b362009-08-09 23:12:19 -07001267}
1268
1269static int git_status_config(const char *k, const char *v, void *cb)
1270{
1271 struct wt_status *s = cb;
René Scharfee3f1da92014-10-04 20:54:50 +02001272 const char *slot_name;
Junio C Hamanof766b362009-08-09 23:12:19 -07001273
Christian Couder59556542013-11-30 21:55:40 +01001274 if (starts_with(k, "column."))
Jeff King4d2292e2012-05-07 15:35:03 -04001275 return git_column_config(k, v, "status", &s->colopts);
Junio C Hamanof766b362009-08-09 23:12:19 -07001276 if (!strcmp(k, "status.submodulesummary")) {
1277 int is_bool;
1278 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1279 if (is_bool && s->submodule_summary)
1280 s->submodule_summary = -1;
1281 return 0;
1282 }
Jorge Juan Garcia Garcia4fb51662013-06-11 15:34:04 +02001283 if (!strcmp(k, "status.short")) {
1284 if (git_config_bool(k, v))
Junio C Hamano84b42022013-06-24 11:41:40 -07001285 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
Jorge Juan Garcia Garcia4fb51662013-06-11 15:34:04 +02001286 else
Junio C Hamano84b42022013-06-24 11:41:40 -07001287 status_deferred_config.status_format = STATUS_FORMAT_NONE;
Jorge Juan Garcia Garcia4fb51662013-06-11 15:34:04 +02001288 return 0;
1289 }
Jorge Juan Garcia Garciaec85d072013-06-11 15:34:05 +02001290 if (!strcmp(k, "status.branch")) {
Junio C Hamano84b42022013-06-24 11:41:40 -07001291 status_deferred_config.show_branch = git_config_bool(k, v);
Jorge Juan Garcia Garciaec85d072013-06-11 15:34:05 +02001292 return 0;
1293 }
Jeff Hostetler06b324c2019-06-18 13:21:25 -07001294 if (!strcmp(k, "status.aheadbehind")) {
1295 status_deferred_config.ahead_behind = git_config_bool(k, v);
1296 return 0;
1297 }
Liam Beguinc1b5d012017-06-17 18:30:51 -04001298 if (!strcmp(k, "status.showstash")) {
1299 s->show_stash = git_config_bool(k, v);
1300 return 0;
1301 }
Junio C Hamanof766b362009-08-09 23:12:19 -07001302 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
Jeff Kinge269eb72011-08-17 22:03:48 -07001303 s->use_color = git_config_colorbool(k, v);
Junio C Hamanof766b362009-08-09 23:12:19 -07001304 return 0;
1305 }
Matthieu Moy2556b992013-09-06 19:43:07 +02001306 if (!strcmp(k, "status.displaycommentprefix")) {
1307 s->display_comment_prefix = git_config_bool(k, v);
1308 return 0;
1309 }
René Scharfee3f1da92014-10-04 20:54:50 +02001310 if (skip_prefix(k, "status.color.", &slot_name) ||
1311 skip_prefix(k, "color.status.", &slot_name)) {
Junio C Hamanob9465762014-10-20 12:23:48 -07001312 int slot = parse_status_slot(slot_name);
Jeff King8b8e8622009-12-12 07:25:24 -05001313 if (slot < 0)
1314 return 0;
Junio C Hamanof766b362009-08-09 23:12:19 -07001315 if (!v)
1316 return config_error_nonbool(k);
Jeff Kingf6c5a292014-10-07 15:33:09 -04001317 return color_parse(v, s->color_palette[slot]);
Junio C Hamanof766b362009-08-09 23:12:19 -07001318 }
1319 if (!strcmp(k, "status.relativepaths")) {
1320 s->relative_paths = git_config_bool(k, v);
1321 return 0;
1322 }
1323 if (!strcmp(k, "status.showuntrackedfiles")) {
1324 if (!v)
1325 return config_error_nonbool(k);
1326 else if (!strcmp(v, "no"))
1327 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1328 else if (!strcmp(v, "normal"))
1329 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1330 else if (!strcmp(v, "all"))
1331 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1332 else
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001333 return error(_("Invalid untracked files mode '%s'"), v);
Junio C Hamanof766b362009-08-09 23:12:19 -07001334 return 0;
1335 }
Ben Pearte8b2dc22018-05-11 15:38:58 +00001336 if (!strcmp(k, "diff.renamelimit")) {
1337 if (s->rename_limit == -1)
1338 s->rename_limit = git_config_int(k, v);
1339 return 0;
1340 }
1341 if (!strcmp(k, "status.renamelimit")) {
1342 s->rename_limit = git_config_int(k, v);
1343 return 0;
1344 }
1345 if (!strcmp(k, "diff.renames")) {
1346 if (s->detect_rename == -1)
1347 s->detect_rename = git_config_rename(k, v);
1348 return 0;
1349 }
1350 if (!strcmp(k, "status.renames")) {
1351 s->detect_rename = git_config_rename(k, v);
1352 return 0;
1353 }
Junio C Hamanof766b362009-08-09 23:12:19 -07001354 return git_diff_ui_config(k, v, NULL);
1355}
1356
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001357int cmd_status(int argc, const char **argv, const char *prefix)
1358{
Ben Pearte8b2dc22018-05-11 15:38:58 +00001359 static int no_renames = -1;
1360 static const char *rename_score_arg = (const char *)-1;
Jeff King036dbbf2012-05-07 15:18:26 -04001361 static struct wt_status s;
Nguyễn Thái Ngọc Duyae9af122018-09-15 19:56:04 +02001362 unsigned int progress_flag = 0;
Markus Heidelberg4bb66442010-04-02 23:44:21 +02001363 int fd;
brian m. carlson8066df42017-02-20 00:10:14 +00001364 struct object_id oid;
Junio C Hamano9e4b7ab2009-08-15 02:27:39 -07001365 static struct option builtin_status_options[] = {
Nguyễn Thái Ngọc Duyf2276312012-08-20 19:32:37 +07001366 OPT__VERBOSE(&verbose, N_("be verbose")),
Jeff Kingdd2be242009-09-05 04:54:14 -04001367 OPT_SET_INT('s', "short", &status_format,
Nguyễn Thái Ngọc Duyf2276312012-08-20 19:32:37 +07001368 N_("show status concisely"), STATUS_FORMAT_SHORT),
Junio C Hamano84b42022013-06-24 11:41:40 -07001369 OPT_BOOL('b', "branch", &s.show_branch,
1370 N_("show branch information")),
Liam Beguinc1b5d012017-06-17 18:30:51 -04001371 OPT_BOOL(0, "show-stash", &s.show_stash,
1372 N_("show stash information")),
Jeff Hostetlerfd9b5442018-01-09 18:50:16 +00001373 OPT_BOOL(0, "ahead-behind", &s.ahead_behind_flags,
1374 N_("compute full ahead/behind values")),
Jeff Hostetlerc4f596b2016-08-05 18:00:28 -04001375 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1376 N_("version"), N_("machine-readable output"),
1377 PARSE_OPT_OPTARG, opt_parse_porcelain },
Jeff Kingf3f47a12012-10-18 21:15:50 +07001378 OPT_SET_INT(0, "long", &status_format,
1379 N_("show status in long format (default)"),
1380 STATUS_FORMAT_LONG),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001381 OPT_BOOL('z', "null", &s.null_termination,
1382 N_("terminate entries with NUL")),
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001383 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
Nguyễn Thái Ngọc Duyf2276312012-08-20 19:32:37 +07001384 N_("mode"),
1385 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001386 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
Jameson Millereec0f7f2017-10-30 13:21:37 -04001387 { OPTION_STRING, 0, "ignored", &ignored_arg,
1388 N_("mode"),
1389 N_("show ignored files, optional modes: traditional, matching, no. (Default: traditional)"),
1390 PARSE_OPT_OPTARG, NULL, (intptr_t)"traditional" },
Nguyễn Thái Ngọc Duyf2276312012-08-20 19:32:37 +07001391 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1392 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
Jens Lehmann46a958b2010-06-25 16:56:47 +02001393 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001394 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
Ben Pearte8b2dc22018-05-11 15:38:58 +00001395 OPT_BOOL(0, "no-renames", &no_renames, N_("do not detect renames")),
1396 { OPTION_CALLBACK, 'M', "find-renames", &rename_score_arg,
1397 N_("n"), N_("detect renames, optionally set similarity index"),
Jeff Kingd6627fb2018-11-05 01:40:53 -05001398 PARSE_OPT_OPTARG | PARSE_OPT_NONEG, opt_parse_rename_score },
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001399 OPT_END(),
1400 };
1401
Nguyễn Thái Ngọc Duy5d3dd912010-10-22 01:45:47 -05001402 if (argc == 2 && !strcmp(argv[1], "-h"))
1403 usage_with_options(builtin_status_usage, builtin_status_options);
1404
Matthieu Moy5c25dfa2013-09-12 12:50:04 +02001405 status_init_config(&s, git_status_config);
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001406 argc = parse_options(argc, argv, prefix,
Junio C Hamano9e4b7ab2009-08-15 02:27:39 -07001407 builtin_status_options,
1408 builtin_status_usage, 0);
Jeff King4d2292e2012-05-07 15:35:03 -04001409 finalize_colopts(&s.colopts, -1);
Junio C Hamano84b42022013-06-24 11:41:40 -07001410 finalize_deferred_config(&s);
Junio C Hamano6c929722011-06-06 11:40:08 -07001411
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001412 handle_untracked_files_arg(&s);
Jameson Millereec0f7f2017-10-30 13:21:37 -04001413 handle_ignored_arg(&s);
1414
1415 if (s.show_ignored_mode == SHOW_MATCHING_IGNORED &&
1416 s.show_untracked_files == SHOW_NO_UNTRACKED_FILES)
1417 die(_("Unsupported combination of ignored and untracked-files arguments"));
1418
Nguyễn Thái Ngọc Duy15b55ae2013-07-14 15:35:39 +07001419 parse_pathspec(&s.pathspec, 0,
1420 PATHSPEC_PREFER_FULL,
1421 prefix, argv);
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001422
Nguyễn Thái Ngọc Duyae9af122018-09-15 19:56:04 +02001423 if (status_format != STATUS_FORMAT_PORCELAIN &&
1424 status_format != STATUS_FORMAT_PORCELAIN_V2)
1425 progress_flag = REFRESH_PROGRESS;
Nguyễn Thái Ngọc Duye1ff0a32019-01-12 09:13:26 +07001426 repo_read_index(the_repository);
Nguyễn Thái Ngọc Duyae9af122018-09-15 19:56:04 +02001427 refresh_index(&the_index,
1428 REFRESH_QUIET|REFRESH_UNMERGED|progress_flag,
1429 &s.pathspec, NULL, NULL);
Markus Heidelberg4bb66442010-04-02 23:44:21 +02001430
Jeff King27344d62017-09-27 02:54:30 -04001431 if (use_optional_locks())
1432 fd = hold_locked_index(&index_lock, 0);
1433 else
1434 fd = -1;
Markus Heidelberg4bb66442010-04-02 23:44:21 +02001435
brian m. carlsone82caf32017-07-13 23:49:28 +00001436 s.is_initial = get_oid(s.reference, &oid) ? 1 : 0;
Jeff Hostetlerd9fc7462016-08-11 10:45:59 -04001437 if (!s.is_initial)
brian m. carlsone0cb7cd2019-08-18 20:04:21 +00001438 oidcpy(&s.oid_commit, &oid);
Jeff Hostetlerd9fc7462016-08-11 10:45:59 -04001439
Jens Lehmann46a958b2010-06-25 16:56:47 +02001440 s.ignore_submodule_arg = ignore_submodule_arg;
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -04001441 s.status_format = status_format;
1442 s.verbose = verbose;
Ben Pearte8b2dc22018-05-11 15:38:58 +00001443 if (no_renames != -1)
1444 s.detect_rename = !no_renames;
1445 if ((intptr_t)rename_score_arg != -1) {
1446 if (s.detect_rename < DIFF_DETECT_RENAME)
1447 s.detect_rename = DIFF_DETECT_RENAME;
1448 if (rename_score_arg)
1449 s.rename_score = parse_rename_score(&rename_score_arg);
1450 }
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -04001451
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001452 wt_status_collect(&s);
1453
Nguyễn Thái Ngọc Duy226c0512015-03-08 17:12:41 +07001454 if (0 <= fd)
Nguyễn Thái Ngọc Duy1b0d9682019-01-12 09:13:27 +07001455 repo_update_index_if_able(the_repository, &index_lock);
Nguyễn Thái Ngọc Duy226c0512015-03-08 17:12:41 +07001456
Jeff King86617682009-12-07 00:26:25 -05001457 if (s.relative_paths)
1458 s.prefix = prefix;
Markus Heidelberg38920dd2009-01-08 19:53:05 +01001459
Jeff Hostetlerbe7e7952016-08-05 18:00:27 -04001460 wt_status_print(&s);
Stephen P. Smith73ba5d72018-09-30 07:12:45 -07001461 wt_status_collect_free_buffers(&s);
1462
Junio C Hamano76e2f7c2009-08-07 23:31:57 -07001463 return 0;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001464}
1465
Stephan Beyer186458b2008-07-24 01:09:35 +02001466static int git_commit_config(const char *k, const char *v, void *cb)
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001467{
Junio C Hamanod249b092009-08-09 21:59:30 -07001468 struct wt_status *s = cb;
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001469 int status;
Junio C Hamanod249b092009-08-09 21:59:30 -07001470
Brian Hetro984c6e72008-07-05 01:24:40 -04001471 if (!strcmp(k, "commit.template"))
Matthieu Moy395de252009-11-17 18:24:25 +01001472 return git_config_pathname(&template_file, k, v);
James P. Howard, IIbed575e2009-12-07 17:45:27 -05001473 if (!strcmp(k, "commit.status")) {
1474 include_status = git_config_bool(k, v);
1475 return 0;
1476 }
Ralf Thielow51fb3a32013-01-10 18:45:59 +01001477 if (!strcmp(k, "commit.cleanup"))
1478 return git_config_string(&cleanup_arg, k, v);
Nicolas Vigierd95bfb12013-11-05 00:14:41 +01001479 if (!strcmp(k, "commit.gpgsign")) {
1480 sign_commit = git_config_bool(k, v) ? "" : NULL;
1481 return 0;
1482 }
Pranit Bauvaaaab8422016-05-05 15:20:02 +05301483 if (!strcmp(k, "commit.verbose")) {
1484 int is_bool;
1485 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1486 return 0;
1487 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001488
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001489 status = git_gpg_config(k, v, NULL);
1490 if (status)
1491 return status;
Junio C Hamanod249b092009-08-09 21:59:30 -07001492 return git_status_config(k, v, s);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001493}
1494
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001495int cmd_commit(int argc, const char **argv, const char *prefix)
1496{
Ævar Arnfjörð Bjarmason095c7412018-02-28 23:04:25 +00001497 const char *argv_gc_auto[] = {"gc", "--auto", NULL};
Jeff King036dbbf2012-05-07 15:18:26 -04001498 static struct wt_status s;
1499 static struct option builtin_commit_options[] = {
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001500 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1501 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
Jeff King036dbbf2012-05-07 15:18:26 -04001502
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001503 OPT_GROUP(N_("Commit message options")),
1504 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1505 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1506 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1507 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1508 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1509 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1510 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1511 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001512 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1513 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001514 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1515 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
Denton Liuca04dc92019-04-17 11:23:26 +01001516 OPT_CLEANUP(&cleanup_arg),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001517 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
Junio C Hamanoe703d712014-03-23 15:58:12 -07001518 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001519 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
Jeff King036dbbf2012-05-07 15:18:26 -04001520 /* end commit message options */
1521
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001522 OPT_GROUP(N_("Commit contents options")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001523 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1524 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1525 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1526 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1527 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
Orgad Shanehdef480f2016-07-26 17:00:15 +03001528 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001529 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001530 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
Jeff King036dbbf2012-05-07 15:18:26 -04001531 STATUS_FORMAT_SHORT),
Junio C Hamano84b42022013-06-24 11:41:40 -07001532 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
Jeff Hostetlerfd9b5442018-01-09 18:50:16 +00001533 OPT_BOOL(0, "ahead-behind", &s.ahead_behind_flags,
1534 N_("compute full ahead/behind values")),
Jeff King036dbbf2012-05-07 15:18:26 -04001535 OPT_SET_INT(0, "porcelain", &status_format,
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001536 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
Jeff Kingf3f47a12012-10-18 21:15:50 +07001537 OPT_SET_INT(0, "long", &status_format,
1538 N_("show status in long format (default)"),
1539 STATUS_FORMAT_LONG),
Stefan Bellerd5d09d42013-08-03 13:51:19 +02001540 OPT_BOOL('z', "null", &s.null_termination,
1541 N_("terminate entries with NUL")),
1542 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1543 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
Nguyễn Thái Ngọc Duy9c23f4c2012-08-20 19:32:04 +07001544 { 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" },
Alexandr Miloslavskiye440fc52019-11-19 16:48:55 +00001545 OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
1546 OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
Jeff King036dbbf2012-05-07 15:18:26 -04001547 /* end commit contents options */
1548
Stefan Beller4741edd2013-08-03 13:51:18 +02001549 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1550 N_("ok to record an empty change")),
1551 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1552 N_("ok to record a change with an empty message")),
Jeff King036dbbf2012-05-07 15:18:26 -04001553
1554 OPT_END()
1555 };
1556
Brandon Caseyf285a2d2008-10-09 14:12:12 -05001557 struct strbuf sb = STRBUF_INIT;
Junio C Hamano4c28e4a2010-12-20 17:00:36 -08001558 struct strbuf author_ident = STRBUF_INIT;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001559 const char *index_file, *reflog_msg;
brian m. carlson8066df42017-02-20 00:10:14 +00001560 struct object_id oid;
René Scharfede9f7fa2016-10-29 14:55:36 +02001561 struct commit_list *parents = NULL;
Miklos Vajnacf10f9f2008-10-03 14:04:47 +02001562 struct stat statbuf;
Junio C Hamano06bb6432011-08-19 11:58:18 -07001563 struct commit *current_head = NULL;
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001564 struct commit_extra_header *extra = NULL;
Ronnie Sahlbergc0fe1ed2014-04-16 15:34:19 -07001565 struct strbuf err = STRBUF_INIT;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001566
Nguyễn Thái Ngọc Duy5d3dd912010-10-22 01:45:47 -05001567 if (argc == 2 && !strcmp(argv[1], "-h"))
1568 usage_with_options(builtin_commit_usage, builtin_commit_options);
1569
Matthieu Moy5c25dfa2013-09-12 12:50:04 +02001570 status_init_config(&s, git_commit_config);
Kaartic Sivaraam4ddb1352017-06-21 23:46:14 +05301571 s.commit_template = 1;
Ramkumar Ramachandraf0915cb2013-06-24 18:15:12 +05301572 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
Jeff King4d2292e2012-05-07 15:35:03 -04001573 s.colopts = 0;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001574
brian m. carlsone82caf32017-07-13 23:49:28 +00001575 if (get_oid("HEAD", &oid))
Junio C Hamano06bb6432011-08-19 11:58:18 -07001576 current_head = NULL;
1577 else {
brian m. carlsonbc832662017-05-06 22:10:10 +00001578 current_head = lookup_commit_or_die(&oid, "HEAD");
Jeff King5e7d4d32013-10-24 04:53:19 -04001579 if (parse_commit(current_head))
Junio C Hamano06bb6432011-08-19 11:58:18 -07001580 die(_("could not parse HEAD commit"));
1581 }
Pranit Bauvaaaab8422016-05-05 15:20:02 +05301582 verbose = -1; /* unspecified */
Jeff King036dbbf2012-05-07 15:18:26 -04001583 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1584 builtin_commit_usage,
Junio C Hamano06bb6432011-08-19 11:58:18 -07001585 prefix, current_head, &s);
Pranit Bauvaaaab8422016-05-05 15:20:02 +05301586 if (verbose == -1)
1587 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1588
Jeff Kingc9bfb952011-08-17 22:05:35 -07001589 if (dry_run)
Junio C Hamano06bb6432011-08-19 11:58:18 -07001590 return dry_run_commit(argc, argv, prefix, current_head, &s);
Junio C Hamano06bb6432011-08-19 11:58:18 -07001591 index_file = prepare_index(argc, argv, prefix, current_head, 0);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001592
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001593 /* Set up everything for writing the commit object. This includes
1594 running hooks, writing the trees, and interacting with the user. */
Junio C Hamano06bb6432011-08-19 11:58:18 -07001595 if (!prepare_to_commit(index_file, prefix,
1596 current_head, &s, &author_ident)) {
Junio C Hamano28886052007-11-18 01:52:55 -08001597 rollback_index_files();
1598 return 1;
1599 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001600
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001601 /* Determine parents */
Christian Couder643cb5f2010-06-12 18:05:12 +02001602 reflog_msg = getenv("GIT_REFLOG_ACTION");
Junio C Hamano06bb6432011-08-19 11:58:18 -07001603 if (!current_head) {
Christian Couder643cb5f2010-06-12 18:05:12 +02001604 if (!reflog_msg)
1605 reflog_msg = "commit (initial)";
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001606 } else if (amend) {
Christian Couder643cb5f2010-06-12 18:05:12 +02001607 if (!reflog_msg)
1608 reflog_msg = "commit (amend)";
René Scharfede9f7fa2016-10-29 14:55:36 +02001609 parents = copy_commit_list(current_head->parents);
Jay Soffian37f7a852011-02-19 23:12:29 -05001610 } else if (whence == FROM_MERGE) {
Brandon Caseyf285a2d2008-10-09 14:12:12 -05001611 struct strbuf m = STRBUF_INIT;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001612 FILE *fp;
Elia Pintoe23fd152014-01-30 07:15:56 -08001613 int allow_fast_forward = 1;
René Scharfede9f7fa2016-10-29 14:55:36 +02001614 struct commit_list **pptr = &parents;
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001615
Christian Couder643cb5f2010-06-12 18:05:12 +02001616 if (!reflog_msg)
1617 reflog_msg = "commit (merge)";
René Scharfede9f7fa2016-10-29 14:55:36 +02001618 pptr = commit_list_append(current_head, pptr);
Stefan Beller102de882018-05-17 15:51:51 -07001619 fp = xfopen(git_path_merge_head(the_repository), "r");
Junio C Hamano8f309ae2016-01-13 15:31:17 -08001620 while (strbuf_getline_lf(&m, fp) != EOF) {
Junio C Hamano5231c632011-11-07 16:21:32 -08001621 struct commit *parent;
1622
1623 parent = get_merge_parent(m.buf);
1624 if (!parent)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001625 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
René Scharfede9f7fa2016-10-29 14:55:36 +02001626 pptr = commit_list_append(parent, pptr);
Linus Torvalds7c3fd252008-01-15 16:12:33 -08001627 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001628 fclose(fp);
1629 strbuf_release(&m);
Stefan Beller102de882018-05-17 15:51:51 -07001630 if (!stat(git_path_merge_mode(the_repository), &statbuf)) {
1631 if (strbuf_read_file(&sb, git_path_merge_mode(the_repository), 0) < 0)
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001632 die_errno(_("could not read MERGE_MODE"));
Miklos Vajnacf10f9f2008-10-03 14:04:47 +02001633 if (!strcmp(sb.buf, "no-ff"))
1634 allow_fast_forward = 0;
1635 }
1636 if (allow_fast_forward)
Martin Ågren4da72642017-11-07 21:39:45 +01001637 reduce_heads_replace(&parents);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001638 } else {
Christian Couder643cb5f2010-06-12 18:05:12 +02001639 if (!reflog_msg)
Phillip Wood8d57f752019-12-06 16:06:10 +00001640 reflog_msg = is_from_cherry_pick(whence)
Jay Soffian37f7a852011-02-19 23:12:29 -05001641 ? "commit (cherry-pick)"
Phillip Wood430b75f2019-12-06 16:06:12 +00001642 : is_from_rebase(whence)
1643 ? "commit (rebase)"
Jay Soffian37f7a852011-02-19 23:12:29 -05001644 : "commit";
René Scharfede9f7fa2016-10-29 14:55:36 +02001645 commit_list_insert(current_head, &parents);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001646 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001647
Paolo Bonziniec84bd02008-02-05 11:01:46 +01001648 /* Finally, get the commit message */
Miklos Vajnacf10f9f2008-10-03 14:04:47 +02001649 strbuf_reset(&sb);
Pranit Bauvae51b0df2016-05-25 00:49:50 +05301650 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
Thomas Rast0721c312009-06-27 17:58:47 +02001651 int saved_errno = errno;
Junio C Hamano740001a2007-12-08 23:23:20 -08001652 rollback_index_files();
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001653 die(_("could not read commit message: %s"), strerror(saved_errno));
Junio C Hamano740001a2007-12-08 23:23:20 -08001654 }
Kristian Høgsberg99a12692007-11-21 21:54:49 -05001655
Denton Liuf29cd862019-04-17 11:23:25 +01001656 cleanup_message(&sb, cleanup_mode, verbose);
Kaartic Sivaraambc17f352017-07-17 21:06:15 +05301657
Phillip Woodd0aaa462017-11-10 11:09:42 +00001658 if (message_is_empty(&sb, cleanup_mode) && !allow_empty_message) {
Junio C Hamano28886052007-11-18 01:52:55 -08001659 rollback_index_files();
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001660 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
Jeff Kingfdc7c812008-07-31 03:36:09 -04001661 exit(1);
Junio C Hamano28886052007-11-18 01:52:55 -08001662 }
Phillip Woodd0aaa462017-11-10 11:09:42 +00001663 if (template_untouched(&sb, template_file, cleanup_mode) && !allow_empty_message) {
Kaartic Sivaraambc17f352017-07-17 21:06:15 +05301664 rollback_index_files();
1665 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1666 exit(1);
1667 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001668
Junio C Hamano0074d182011-12-20 13:20:56 -08001669 if (amend) {
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001670 const char *exclude_gpgsig[3] = { "gpgsig", "gpgsig-sha256", NULL };
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001671 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
Junio C Hamano0074d182011-12-20 13:20:56 -08001672 } else {
1673 struct commit_extra_header **tail = &extra;
1674 append_merge_tag_headers(parents, &tail);
1675 }
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001676
Patryk Obara5078f342018-01-28 01:13:16 +01001677 if (commit_tree_extended(sb.buf, sb.len, &active_cache_tree->oid,
1678 parents, &oid, author_ident.buf, sign_commit,
1679 extra)) {
Junio C Hamano28886052007-11-18 01:52:55 -08001680 rollback_index_files();
Ævar Arnfjörð Bjarmason8a6179b2011-02-22 23:41:44 +00001681 die(_("failed to write commit object"));
Junio C Hamano28886052007-11-18 01:52:55 -08001682 }
Junio C Hamano4c28e4a2010-12-20 17:00:36 -08001683 strbuf_release(&author_ident);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001684 free_commit_extra_headers(extra);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001685
Phillip Wood0505d602017-11-17 11:34:47 +00001686 if (update_head_with_reflog(current_head, &oid, reflog_msg, &sb,
1687 &err)) {
Junio C Hamano28886052007-11-18 01:52:55 -08001688 rollback_index_files();
Ronnie Sahlbergc0fe1ed2014-04-16 15:34:19 -07001689 die("%s", err.buf);
Junio C Hamano28886052007-11-18 01:52:55 -08001690 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001691
Junio C Hamanof496b062019-07-09 15:25:44 -07001692 sequencer_post_commit_cleanup(the_repository, 0);
Stefan Beller102de882018-05-17 15:51:51 -07001693 unlink(git_path_merge_head(the_repository));
1694 unlink(git_path_merge_msg(the_repository));
1695 unlink(git_path_merge_mode(the_repository));
1696 unlink(git_path_squash_msg(the_repository));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001697
Brandon Casey5a9dd392008-01-23 11:21:22 -06001698 if (commit_index_files())
Nguyễn Thái Ngọc Duy1a07e592018-07-21 09:49:19 +02001699 die(_("repository has been updated, but unable to write\n"
1700 "new_index file. Check that disk is not full and quota is\n"
Nguyễn Thái Ngọc Duy80f537f2019-04-25 16:45:58 +07001701 "not exceeded, and then \"git restore --staged :/\" to recover."));
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001702
Derrick Stoleee103f722019-06-12 06:29:37 -07001703 if (git_env_bool(GIT_TEST_COMMIT_GRAPH, 0) &&
Taylor Blau0bd52e22020-02-03 21:51:50 -08001704 write_commit_graph_reachable(the_repository->objects->odb, 0, NULL))
Derrick Stoleee103f722019-06-12 06:29:37 -07001705 return 1;
Derrick Stolee859fdc02018-08-29 05:49:04 -07001706
Nguyễn Thái Ngọc Duy35843b12018-09-21 17:57:32 +02001707 repo_rerere(the_repository, 0);
Ævar Arnfjörð Bjarmason095c7412018-02-28 23:04:25 +00001708 run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
Benoit Pierre15048f82014-03-18 11:00:53 +01001709 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
Thomas Rast6f6bee32010-03-12 18:04:28 +01001710 if (amend && !no_post_rewrite) {
Nguyễn Thái Ngọc Duy1d18d752019-01-12 09:13:23 +07001711 commit_post_rewrite(the_repository, current_head, &oid);
Thomas Rast6f6bee32010-03-12 18:04:28 +01001712 }
Phillip Woode47c6ca2017-11-24 11:07:54 +00001713 if (!quiet) {
1714 unsigned int flags = 0;
1715
1716 if (!current_head)
1717 flags |= SUMMARY_INITIAL_COMMIT;
1718 if (author_date_is_interesting())
1719 flags |= SUMMARY_SHOW_AUTHOR_DATE;
Nguyễn Thái Ngọc Duyf11c9582018-11-10 06:48:56 +01001720 print_commit_summary(the_repository, prefix,
1721 &oid, flags);
Phillip Woode47c6ca2017-11-24 11:07:54 +00001722 }
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001723
Jeff King0e5bba52017-09-08 02:38:41 -04001724 UNLEAK(err);
1725 UNLEAK(sb);
Kristian Høgsbergf5bbc322007-11-08 11:59:00 -05001726 return 0;
1727}