builtin/commit: fix memory leak in `prepare_index()`
[git/git.git] / builtin / commit.c
CommitLineData
f5bbc322
KH
1/*
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
8#include "cache.h"
b2141fc1 9#include "config.h"
697cc8ef 10#include "lockfile.h"
f5bbc322 11#include "cache-tree.h"
6b2f2d98 12#include "color.h"
2888605c 13#include "dir.h"
f5bbc322
KH
14#include "builtin.h"
15#include "diff.h"
16#include "diffcore.h"
17#include "commit.h"
18#include "revision.h"
19#include "wt-status.h"
20#include "run-command.h"
21#include "refs.h"
22#include "log-tree.h"
23#include "strbuf.h"
24#include "utf8.h"
25#include "parse-options.h"
c455c87c 26#include "string-list.h"
5b2fd956 27#include "rerere.h"
fa9dcf80 28#include "unpack-trees.h"
76e2f7ce 29#include "quote.h"
302ad7a9 30#include "submodule.h"
ba3c69a9 31#include "gpg-interface.h"
323d0530 32#include "column.h"
5ed75e2a 33#include "sequencer.h"
49c24704 34#include "notes-utils.h"
ea16794e 35#include "mailmap.h"
af65f68c 36#include "sigchain.h"
f5bbc322
KH
37
38static const char * const builtin_commit_usage[] = {
9c9b4f2f 39 N_("git commit [<options>] [--] <pathspec>..."),
f5bbc322
KH
40 NULL
41};
42
2f02b25f 43static const char * const builtin_status_usage[] = {
9c9b4f2f 44 N_("git status [<options>] [--] <pathspec>..."),
2f02b25f
SB
45 NULL
46};
47
8b27ff7e
MM
48static const char implicit_ident_advice_noconfig[] =
49N_("Your name and email address were configured automatically based\n"
50"on your username and hostname. Please check that they are accurate.\n"
51"You can suppress this message by setting them explicitly. Run the\n"
52"following command and follow the instructions in your editor to edit\n"
53"your configuration file:\n"
54"\n"
55" git config --global --edit\n"
56"\n"
57"After doing this, you may fix the identity used for this commit with:\n"
58"\n"
59" git commit --amend --reset-author\n");
60
61static const char implicit_ident_advice_config[] =
fc88e316 62N_("Your name and email address were configured automatically based\n"
49ff9a7a
JK
63"on your username and hostname. Please check that they are accurate.\n"
64"You can suppress this message by setting them explicitly:\n"
65"\n"
8bb45b25 66" git config --global user.name \"Your Name\"\n"
49ff9a7a
JK
67" git config --global user.email you@example.com\n"
68"\n"
3f142468 69"After doing this, you may fix the identity used for this commit with:\n"
49ff9a7a 70"\n"
fc88e316 71" git commit --amend --reset-author\n");
49ff9a7a 72
f197ed2f 73static const char empty_amend_advice[] =
fc88e316 74N_("You asked to amend the most recent commit, but doing so would make\n"
f197ed2f 75"it empty. You can repeat your command with --allow-empty, or you can\n"
fc88e316 76"remove the commit entirely with \"git reset HEAD^\".\n");
f197ed2f 77
37f7a857 78static const char empty_cherry_pick_advice[] =
6c80cd29 79N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
37f7a857
JS
80"If you wish to commit it anyway, use:\n"
81"\n"
82" git commit --allow-empty\n"
c17592a7
JK
83"\n");
84
85static const char empty_cherry_pick_advice_single[] =
86N_("Otherwise, please use 'git reset'\n");
87
88static const char empty_cherry_pick_advice_multi[] =
89N_("If you wish to skip this commit, use:\n"
37f7a857 90"\n"
c17592a7
JK
91" git reset\n"
92"\n"
93"Then \"git cherry-pick --continue\" will resume cherry-picking\n"
94"the remaining commits.\n");
37f7a857 95
e51b0dfc
PB
96static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
97
37f7a857 98static const char *use_message_buffer;
2888605c
JH
99static struct lock_file index_lock; /* real index */
100static struct lock_file false_lock; /* used only for partial commits */
101static enum {
102 COMMIT_AS_IS = 1,
103 COMMIT_NORMAL,
4b05548f 104 COMMIT_PARTIAL
2888605c 105} commit_style;
f5bbc322 106
dbd0f5c7 107static const char *logfile, *force_author;
984c6e7e 108static const char *template_file;
37f7a857
JS
109/*
110 * The _message variables are commit names from which to take
111 * the commit message and/or authorship.
112 */
113static const char *author_message, *author_message_buffer;
f5bbc322 114static char *edit_message, *use_message;
89ac1223 115static char *fixup_message, *squash_message;
ca1ba201
JH
116static int all, also, interactive, patch_interactive, only, amend, signoff;
117static int edit_flag = -1; /* unspecified */
c51f6cee 118static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
aaab8420 119static int config_commit_verbose = -1; /* unspecified */
c9b5fde7 120static int no_post_rewrite, allow_empty_message;
46a958b3 121static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
ba3c69a9
JH
122static char *sign_commit;
123
5f065737
AR
124/*
125 * The default commit message cleanup mode will remove the lines
126 * beginning with # (shell comments) and leading and trailing
127 * whitespaces (empty lines or containing only whitespaces)
128 * if editor is used, and only the whitespaces if the message
129 * is specified explicitly.
130 */
131static enum {
132 CLEANUP_SPACE,
133 CLEANUP_NONE,
75df1f43 134 CLEANUP_SCISSORS,
4b05548f 135 CLEANUP_ALL
5f065737 136} cleanup_mode;
51fb3a3d 137static const char *cleanup_arg;
f5bbc322 138
37f7a857 139static enum commit_whence whence;
c17592a7 140static int sequencer_in_use;
06bb643b 141static int use_editor = 1, include_status = 1;
25206778 142static int show_ignored_in_status, have_option_m;
2c47789d 143static struct strbuf message = STRBUF_INIT;
f9568530 144
be7e795e 145static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
84b4202d 146
c4f596b9
JH
147static int opt_parse_porcelain(const struct option *opt, const char *arg, int unset)
148{
149 enum wt_status_format *value = (enum wt_status_format *)opt->value;
150 if (unset)
151 *value = STATUS_FORMAT_NONE;
152 else if (!arg)
153 *value = STATUS_FORMAT_PORCELAIN;
154 else if (!strcmp(arg, "v1") || !strcmp(arg, "1"))
155 *value = STATUS_FORMAT_PORCELAIN;
1ecdecce
JH
156 else if (!strcmp(arg, "v2") || !strcmp(arg, "2"))
157 *value = STATUS_FORMAT_PORCELAIN_V2;
c4f596b9
JH
158 else
159 die("unsupported porcelain version '%s'", arg);
160
161 return 0;
162}
7c9f7038 163
f9568530
JS
164static int opt_parse_m(const struct option *opt, const char *arg, int unset)
165{
166 struct strbuf *buf = opt->value;
25206778
RS
167 if (unset) {
168 have_option_m = 0;
f9568530 169 strbuf_setlen(buf, 0);
25206778
RS
170 } else {
171 have_option_m = 1;
a24a41ea
BC
172 if (buf->len)
173 strbuf_addch(buf, '\n');
f9568530 174 strbuf_addstr(buf, arg);
a24a41ea 175 strbuf_complete_line(buf);
f9568530
JS
176 }
177 return 0;
178}
f5bbc322 179
37f7a857
JS
180static void determine_whence(struct wt_status *s)
181{
f932729c 182 if (file_exists(git_path_merge_head()))
37f7a857 183 whence = FROM_MERGE;
f932729c 184 else if (file_exists(git_path_cherry_pick_head())) {
37f7a857 185 whence = FROM_CHERRY_PICK;
8a2a0f53 186 if (file_exists(git_path_seq_dir()))
c17592a7
JK
187 sequencer_in_use = 1;
188 }
37f7a857
JS
189 else
190 whence = FROM_COMMIT;
191 if (s)
192 s->whence = whence;
193}
194
5c25dfaa
MM
195static void status_init_config(struct wt_status *s, config_fn_t fn)
196{
197 wt_status_prepare(s);
198 gitmodules_config();
199 git_config(fn, s);
200 determine_whence(s);
5404c116 201 init_diff_ui_defaults();
6a964f57 202 s->hints = advice_status_hints; /* must come after git_config() */
5c25dfaa
MM
203}
204
2888605c
JH
205static void rollback_index_files(void)
206{
207 switch (commit_style) {
208 case COMMIT_AS_IS:
209 break; /* nothing to do */
210 case COMMIT_NORMAL:
211 rollback_lock_file(&index_lock);
212 break;
213 case COMMIT_PARTIAL:
214 rollback_lock_file(&index_lock);
215 rollback_lock_file(&false_lock);
216 break;
217 }
218}
219
5a9dd399 220static int commit_index_files(void)
2888605c 221{
5a9dd399
BC
222 int err = 0;
223
2888605c
JH
224 switch (commit_style) {
225 case COMMIT_AS_IS:
226 break; /* nothing to do */
227 case COMMIT_NORMAL:
5a9dd399 228 err = commit_lock_file(&index_lock);
2888605c
JH
229 break;
230 case COMMIT_PARTIAL:
5a9dd399 231 err = commit_lock_file(&index_lock);
2888605c
JH
232 rollback_lock_file(&false_lock);
233 break;
234 }
5a9dd399
BC
235
236 return err;
2888605c
JH
237}
238
239/*
240 * Take a union of paths in the index and the named tree (typically, "HEAD"),
241 * and return the paths that match the given pattern in list.
242 */
c455c87c 243static int list_paths(struct string_list *list, const char *with_tree,
17ddc66e 244 const char *prefix, const struct pathspec *pattern)
2888605c 245{
5d0b9bf8 246 int i, ret;
2888605c
JH
247 char *m;
248
17ddc66e 249 if (!pattern->nr)
ea2d4ed3
JK
250 return 0;
251
17ddc66e 252 m = xcalloc(1, pattern->nr);
2888605c 253
8894d535 254 if (with_tree) {
f950eb95 255 char *max_prefix = common_prefix(pattern);
312c984a
BW
256 overlay_tree_on_index(&the_index, with_tree,
257 max_prefix ? max_prefix : prefix);
5879f568 258 free(max_prefix);
8894d535 259 }
2888605c
JH
260
261 for (i = 0; i < active_nr; i++) {
9c5e6c80 262 const struct cache_entry *ce = active_cache[i];
7fce6e3c
NTND
263 struct string_list_item *item;
264
7a51ed66 265 if (ce->ce_flags & CE_UPDATE)
e87e22d0 266 continue;
429bb40a 267 if (!ce_path_match(ce, pattern, m))
2888605c 268 continue;
78a395d3 269 item = string_list_insert(list, ce->name);
7fce6e3c
NTND
270 if (ce_skip_worktree(ce))
271 item->util = item; /* better a valid pointer than a fake one */
2888605c
JH
272 }
273
5d0b9bf8
SB
274 ret = report_path_error(m, pattern, prefix);
275 free(m);
276 return ret;
2888605c
JH
277}
278
c455c87c 279static void add_remove_files(struct string_list *list)
2888605c
JH
280{
281 int i;
282 for (i = 0; i < list->nr; i++) {
d177cab0 283 struct stat st;
c455c87c 284 struct string_list_item *p = &(list->items[i]);
d177cab0 285
7fce6e3c
NTND
286 /* p->util is skip-worktree */
287 if (p->util)
b4d1690d 288 continue;
d177cab0 289
c455c87c
JS
290 if (!lstat(p->string, &st)) {
291 if (add_to_cache(p->string, &st, 0))
8a6179bc 292 die(_("updating files failed"));
960b8ad1 293 } else
c455c87c 294 remove_file_from_cache(p->string);
2888605c
JH
295 }
296}
297
06bb643b 298static void create_base_index(const struct commit *current_head)
fa9dcf80
LT
299{
300 struct tree *tree;
301 struct unpack_trees_options opts;
302 struct tree_desc t;
303
06bb643b 304 if (!current_head) {
fa9dcf80
LT
305 discard_cache();
306 return;
307 }
308
309 memset(&opts, 0, sizeof(opts));
310 opts.head_idx = 1;
311 opts.index_only = 1;
312 opts.merge = 1;
34110cd4
LT
313 opts.src_index = &the_index;
314 opts.dst_index = &the_index;
fa9dcf80
LT
315
316 opts.fn = oneway_merge;
a9dbc179 317 tree = parse_tree_indirect(&current_head->object.oid);
fa9dcf80 318 if (!tree)
8a6179bc 319 die(_("failed to unpack HEAD tree object"));
fa9dcf80
LT
320 parse_tree(tree);
321 init_tree_desc(&t, tree->buffer, tree->size);
203a2fe1
DB
322 if (unpack_trees(1, &t, &opts))
323 exit(128); /* We've already reported the error, finish dying */
fa9dcf80
LT
324}
325
d38a30df
MM
326static void refresh_cache_or_die(int refresh_flags)
327{
328 /*
329 * refresh_flags contains REFRESH_QUIET, so the only errors
330 * are for unmerged entries.
331 */
332 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
333 die_resolve_conflict("commit");
334}
335
35ff08be
MH
336static const char *prepare_index(int argc, const char **argv, const char *prefix,
337 const struct commit *current_head, int is_status)
f5bbc322 338{
dd1055ed 339 struct string_list partial = STRING_LIST_INIT_DUP;
6654c889 340 struct pathspec pathspec;
50b7e70f 341 int refresh_flags = REFRESH_QUIET;
b4fb09e4 342 const char *ret;
f5bbc322 343
50b7e70f
JH
344 if (is_status)
345 refresh_flags |= REFRESH_UNMERGED;
6654c889
NTND
346 parse_pathspec(&pathspec, 0,
347 PATHSPEC_PREFER_FULL,
348 prefix, argv);
f5bbc322 349
5ab2a2da 350 if (read_cache_preload(&pathspec) < 0)
8a6179bc 351 die(_("index file corrupt"));
671c9b7e 352
1020d087 353 if (interactive) {
e23fd15a 354 char *old_index_env = NULL;
b3e83cc7 355 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
1020d087
CI
356
357 refresh_cache_or_die(refresh_flags);
358
03b86647 359 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
1020d087
CI
360 die(_("unable to create temporary index"));
361
362 old_index_env = getenv(INDEX_ENVIRONMENT);
b4fb09e4 363 setenv(INDEX_ENVIRONMENT, get_lock_file_path(&index_lock), 1);
1020d087 364
b4bd4668 365 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
1020d087
CI
366 die(_("interactive add failed"));
367
368 if (old_index_env && *old_index_env)
369 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
370 else
371 unsetenv(INDEX_ENVIRONMENT);
372
373 discard_cache();
b4fb09e4 374 read_cache_from(get_lock_file_path(&index_lock));
9c4d6c02 375 if (update_main_cache_tree(WRITE_TREE_SILENT) == 0) {
3fd13cbc 376 if (reopen_lock_file(&index_lock) < 0)
9c4d6c02 377 die(_("unable to write index file"));
3fd13cbc
JH
378 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
379 die(_("unable to update temporary index"));
9c4d6c02
DT
380 } else
381 warning(_("Failed to update main cache tree"));
1020d087
CI
382
383 commit_style = COMMIT_NORMAL;
dd1055ed
384 ret = get_lock_file_path(&index_lock);
385 goto out;
1020d087
CI
386 }
387
2888605c
JH
388 /*
389 * Non partial, non as-is commit.
390 *
391 * (1) get the real index;
392 * (2) update the_index as necessary;
393 * (3) write the_index out to the real index (still locked);
394 * (4) return the name of the locked index file.
395 *
396 * The caller should run hooks on the locked real index, and
397 * (A) if all goes well, commit the real index;
398 * (B) on failure, rollback the real index.
399 */
6654c889 400 if (all || (also && pathspec.nr)) {
b3e83cc7 401 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
610d55af 402 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
d38a30df 403 refresh_cache_or_die(refresh_flags);
e859c69b 404 update_main_cache_tree(WRITE_TREE_SILENT);
03b86647 405 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
8a6179bc 406 die(_("unable to write new_index file"));
2888605c 407 commit_style = COMMIT_NORMAL;
dd1055ed
408 ret = get_lock_file_path(&index_lock);
409 goto out;
f5bbc322
KH
410 }
411
2888605c
JH
412 /*
413 * As-is commit.
414 *
415 * (1) return the name of the real index file.
416 *
73276235
MH
417 * The caller should run hooks on the real index,
418 * and create commit from the_index.
2888605c
JH
419 * We still need to refresh the index here.
420 */
6654c889 421 if (!only && !pathspec.nr) {
b3e83cc7 422 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
d38a30df 423 refresh_cache_or_die(refresh_flags);
9c4d6c02 424 if (active_cache_changed
475a3445 425 || !cache_tree_fully_valid(active_cache_tree))
e859c69b 426 update_main_cache_tree(WRITE_TREE_SILENT);
9c4d6c02 427 if (active_cache_changed) {
03b86647
NTND
428 if (write_locked_index(&the_index, &index_lock,
429 COMMIT_LOCK))
8a6179bc 430 die(_("unable to write new_index file"));
d5f5d0a9
JH
431 } else {
432 rollback_lock_file(&index_lock);
433 }
2888605c 434 commit_style = COMMIT_AS_IS;
dd1055ed
435 ret = get_index_file();
436 goto out;
f5bbc322
KH
437 }
438
2888605c
JH
439 /*
440 * A partial commit.
441 *
442 * (0) find the set of affected paths;
443 * (1) get lock on the real index file;
444 * (2) update the_index with the given paths;
445 * (3) write the_index out to the real index (still locked);
446 * (4) get lock on the false index file;
447 * (5) reset the_index from HEAD;
448 * (6) update the_index the same way as (2);
449 * (7) write the_index out to the false index file;
450 * (8) return the name of the false index file (still locked);
451 *
452 * The caller should run hooks on the locked false index, and
453 * create commit from it. Then
454 * (A) if all goes well, commit the real index;
455 * (B) on failure, rollback the real index;
456 * In either case, rollback the false index.
457 */
458 commit_style = COMMIT_PARTIAL;
459
b0cea47e
ÆAB
460 if (whence != FROM_COMMIT) {
461 if (whence == FROM_MERGE)
462 die(_("cannot do a partial commit during a merge."));
463 else if (whence == FROM_CHERRY_PICK)
464 die(_("cannot do a partial commit during a cherry-pick."));
465 }
2888605c 466
17ddc66e 467 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
2888605c
JH
468 exit(1);
469
470 discard_cache();
471 if (read_cache() < 0)
8a6179bc 472 die(_("cannot read the index"));
2888605c 473
b3e83cc7 474 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR);
2888605c 475 add_remove_files(&partial);
ef12b50d 476 refresh_cache(REFRESH_QUIET);
9c4d6c02 477 update_main_cache_tree(WRITE_TREE_SILENT);
03b86647 478 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))
8a6179bc 479 die(_("unable to write new_index file"));
f5bbc322 480
03b86647
NTND
481 hold_lock_file_for_update(&false_lock,
482 git_path("next-index-%"PRIuMAX,
483 (uintmax_t) getpid()),
484 LOCK_DIE_ON_ERROR);
fa9dcf80 485
06bb643b 486 create_base_index(current_head);
2888605c 487 add_remove_files(&partial);
d37d3203 488 refresh_cache(REFRESH_QUIET);
f5bbc322 489
03b86647 490 if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))
8a6179bc 491 die(_("unable to write temporary index file"));
959ba670
JK
492
493 discard_cache();
b4fb09e4
MH
494 ret = get_lock_file_path(&false_lock);
495 read_cache_from(ret);
dd1055ed
496out:
497 string_list_clear(&partial, 0);
498 clear_pathspec(&pathspec);
b4fb09e4 499 return ret;
f5bbc322
KH
500}
501
d249b098
JH
502static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
503 struct wt_status *s)
f5bbc322 504{
8066df41 505 struct object_id oid;
76e2f7ce 506
d249b098
JH
507 if (s->relative_paths)
508 s->prefix = prefix;
f5bbc322
KH
509
510 if (amend) {
d249b098
JH
511 s->amend = 1;
512 s->reference = "HEAD^1";
f5bbc322 513 }
d249b098
JH
514 s->verbose = verbose;
515 s->index_file = index_file;
516 s->fp = fp;
517 s->nowarn = nowarn;
8066df41 518 s->is_initial = get_sha1(s->reference, oid.hash) ? 1 : 0;
d9fc746c 519 if (!s->is_initial)
8066df41 520 hashcpy(s->sha1_commit, oid.hash);
be7e795e
JH
521 s->status_format = status_format;
522 s->ignore_submodule_arg = ignore_submodule_arg;
f5bbc322 523
76e2f7ce 524 wt_status_collect(s);
be7e795e 525 wt_status_print(s);
f5bbc322 526
d249b098 527 return s->commitable;
f5bbc322
KH
528}
529
06bb643b 530static int is_a_merge(const struct commit *current_head)
ec84bd00 531{
06bb643b 532 return !!(current_head->parents && current_head->parents->next);
ec84bd00
PB
533}
534
fac90838
JK
535static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
536{
c83a5099 537 if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)
fac90838
JK
538 die("BUG: unable to parse our own ident: %s", buf->buf);
539}
540
7dfe8ad6
JH
541static void export_one(const char *var, const char *s, const char *e, int hack)
542{
543 struct strbuf buf = STRBUF_INIT;
544 if (hack)
545 strbuf_addch(&buf, hack);
546 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
547 setenv(var, buf.buf, 1);
548 strbuf_release(&buf);
549}
550
c33ddc2e 551static int parse_force_date(const char *in, struct strbuf *out)
14ac2864 552{
c33ddc2e 553 strbuf_addch(out, '@');
14ac2864 554
c33ddc2e 555 if (parse_date(in, out) < 0) {
14ac2864
JK
556 int errors = 0;
557 unsigned long t = approxidate_careful(in, &errors);
558 if (errors)
559 return -1;
c33ddc2e 560 strbuf_addf(out, "%lu", t);
14ac2864
JK
561 }
562
563 return 0;
564}
565
f4ef5173
JK
566static void set_ident_var(char **buf, char *val)
567{
568 free(*buf);
569 *buf = val;
570}
571
4c28e4ad 572static void determine_author_info(struct strbuf *author_ident)
a45d46ba
SB
573{
574 char *name, *email, *date;
7dfe8ad6 575 struct ident_split author;
a45d46ba 576
eaa541eb
JK
577 name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
578 email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
579 date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
a45d46ba 580
37f7a857 581 if (author_message) {
f0f9662a 582 struct ident_split ident;
2c733fb2 583 size_t len;
f0f9662a 584 const char *a;
a45d46ba 585
f0f9662a 586 a = find_commit_header(author_message_buffer, "author", &len);
a45d46ba 587 if (!a)
f0f9662a
JK
588 die(_("commit '%s' lacks author header"), author_message);
589 if (split_ident_line(&ident, a, len) < 0)
590 die(_("commit '%s' has malformed author line"), author_message);
591
f4ef5173
JK
592 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
593 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
594
f0f9662a 595 if (ident.date_begin) {
f4ef5173 596 struct strbuf date_buf = STRBUF_INIT;
f0f9662a
JK
597 strbuf_addch(&date_buf, '@');
598 strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);
599 strbuf_addch(&date_buf, ' ');
600 strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);
f4ef5173 601 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
f0f9662a 602 }
a45d46ba
SB
603 }
604
605 if (force_author) {
f0f9662a 606 struct ident_split ident;
a45d46ba 607
f0f9662a 608 if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)
8a6179bc 609 die(_("malformed --author parameter"));
f4ef5173
JK
610 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
611 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
a45d46ba
SB
612 }
613
14ac2864 614 if (force_date) {
f4ef5173 615 struct strbuf date_buf = STRBUF_INIT;
c33ddc2e 616 if (parse_force_date(force_date, &date_buf))
14ac2864 617 die(_("invalid date format: %s"), force_date);
f4ef5173 618 set_ident_var(&date, strbuf_detach(&date_buf, NULL));
14ac2864
JK
619 }
620
f9bc573f 621 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
c83a5099
JK
622 assert_split_ident(&author, author_ident);
623 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
624 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
625 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
f4ef5173
JK
626 free(name);
627 free(email);
628 free(date);
a45d46ba
SB
629}
630
b7242b8c
JK
631static int author_date_is_interesting(void)
632{
633 return author_message || force_date;
4c28e4ad
JH
634}
635
84c9dc2c
NTND
636static void adjust_comment_line_char(const struct strbuf *sb)
637{
638 char candidates[] = "#;@!$%^&|:";
639 char *candidate;
640 const char *p;
641
642 comment_line_char = candidates[0];
643 if (!memchr(sb->buf, comment_line_char, sb->len))
644 return;
645
646 p = sb->buf;
647 candidate = strchr(candidates, *p);
648 if (candidate)
649 *candidate = ' ';
650 for (p = sb->buf; *p; p++) {
651 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
652 candidate = strchr(candidates, p[1]);
653 if (candidate)
654 *candidate = ' ';
655 }
656 }
657
658 for (p = candidates; *p == ' '; p++)
659 ;
660 if (!*p)
661 die(_("unable to select a comment character that is not used\n"
662 "in the current commit message"));
663 comment_line_char = *p;
664}
665
d249b098 666static int prepare_to_commit(const char *index_file, const char *prefix,
06bb643b 667 struct commit *current_head,
4c28e4ad
JH
668 struct wt_status *s,
669 struct strbuf *author_ident)
f5bbc322
KH
670{
671 struct stat statbuf;
4c28e4ad 672 struct strbuf committer_ident = STRBUF_INIT;
e23fd15a 673 int commitable;
f285a2d7 674 struct strbuf sb = STRBUF_INIT;
8089c85b
PB
675 const char *hook_arg1 = NULL;
676 const char *hook_arg2 = NULL;
8b1ae678 677 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
2556b996 678 int old_display_comment_prefix;
f5bbc322 679
7dfe8ad6
JH
680 /* This checks and barfs if author is badly specified */
681 determine_author_info(author_ident);
682
15048f8a 683 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
ec84bd00 684 return 0;
f5bbc322 685
89ac1223
PN
686 if (squash_message) {
687 /*
688 * Insert the proper subject line before other commit
689 * message options add their content.
690 */
691 if (use_message && !strcmp(use_message, squash_message))
692 strbuf_addstr(&sb, "squash! ");
693 else {
694 struct pretty_print_context ctx = {0};
695 struct commit *c;
696 c = lookup_commit_reference_by_name(squash_message);
697 if (!c)
8a6179bc 698 die(_("could not lookup commit %s"), squash_message);
89ac1223
PN
699 ctx.output_encoding = get_commit_output_encoding();
700 format_commit_message(c, "squash! %s\n\n", &sb,
701 &ctx);
702 }
703 }
704
27014cbc 705 if (have_option_m) {
f9568530 706 strbuf_addbuf(&sb, &message);
8089c85b 707 hook_arg1 = "message";
f5bbc322
KH
708 } else if (logfile && !strcmp(logfile, "-")) {
709 if (isatty(0))
8a6179bc 710 fprintf(stderr, _("(reading log message from standard input)\n"));
f5bbc322 711 if (strbuf_read(&sb, 0, 0) < 0)
8a6179bc 712 die_errno(_("could not read log from standard input"));
8089c85b 713 hook_arg1 = "message";
f5bbc322
KH
714 } else if (logfile) {
715 if (strbuf_read_file(&sb, logfile, 0) < 0)
8a6179bc 716 die_errno(_("could not read log file '%s'"),
d824cbba 717 logfile);
8089c85b 718 hook_arg1 = "message";
f5bbc322 719 } else if (use_message) {
e23fd15a 720 char *buffer;
f5bbc322 721 buffer = strstr(use_message_buffer, "\n\n");
076cbd63 722 if (buffer)
84e213a3 723 strbuf_addstr(&sb, skip_blank_lines(buffer + 2));
8089c85b
PB
724 hook_arg1 = "commit";
725 hook_arg2 = use_message;
d71b8ba7
PN
726 } else if (fixup_message) {
727 struct pretty_print_context ctx = {0};
728 struct commit *commit;
729 commit = lookup_commit_reference_by_name(fixup_message);
730 if (!commit)
8a6179bc 731 die(_("could not lookup commit %s"), fixup_message);
d71b8ba7
PN
732 ctx.output_encoding = get_commit_output_encoding();
733 format_commit_message(commit, "fixup! %s\n\n",
734 &sb, &ctx);
735 hook_arg1 = "message";
f932729c 736 } else if (!stat(git_path_merge_msg(), &statbuf)) {
b64c1e07
SS
737 /*
738 * prepend SQUASH_MSG here if it exists and a
739 * "merge --squash" was originally performed
740 */
741 if (!stat(git_path_squash_msg(), &statbuf)) {
742 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
743 die_errno(_("could not read SQUASH_MSG"));
744 hook_arg1 = "squash";
745 } else
746 hook_arg1 = "merge";
f932729c 747 if (strbuf_read_file(&sb, git_path_merge_msg(), 0) < 0)
8a6179bc 748 die_errno(_("could not read MERGE_MSG"));
f932729c
JK
749 } else if (!stat(git_path_squash_msg(), &statbuf)) {
750 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
8a6179bc 751 die_errno(_("could not read SQUASH_MSG"));
8089c85b 752 hook_arg1 = "squash";
2140b140 753 } else if (template_file) {
f5bbc322 754 if (strbuf_read_file(&sb, template_file, 0) < 0)
8a6179bc 755 die_errno(_("could not read '%s'"), template_file);
8089c85b 756 hook_arg1 = "template";
8b1ae678 757 clean_message_contents = 0;
f5bbc322
KH
758 }
759
8089c85b 760 /*
37f7a857
JS
761 * The remaining cases don't modify the template message, but
762 * just set the argument(s) to the prepare-commit-msg hook.
8089c85b 763 */
37f7a857 764 else if (whence == FROM_MERGE)
8089c85b 765 hook_arg1 = "merge";
37f7a857
JS
766 else if (whence == FROM_CHERRY_PICK) {
767 hook_arg1 = "commit";
768 hook_arg2 = "CHERRY_PICK_HEAD";
769 }
8089c85b 770
89ac1223
PN
771 if (squash_message) {
772 /*
773 * If squash_commit was used for the commit subject,
774 * then we're possibly hijacking other commit log options.
775 * Reset the hook args to tell the real story.
776 */
777 hook_arg1 = "message";
778 hook_arg2 = "";
779 }
780
e51b0dfc 781 s->fp = fopen_for_writing(git_path_commit_editmsg());
37f3012f 782 if (s->fp == NULL)
e51b0dfc 783 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
f5bbc322 784
2556b996
MM
785 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
786 old_display_comment_prefix = s->display_comment_prefix;
787 s->display_comment_prefix = 1;
788
ea9882bf
MM
789 /*
790 * Most hints are counter-productive when the commit has
791 * already started.
792 */
793 s->hints = 0;
794
8b1ae678 795 if (clean_message_contents)
63af4a84 796 strbuf_stripspace(&sb, 0);
f5bbc322 797
073bd75e 798 if (signoff)
710714aa 799 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
f5bbc322 800
37f3012f 801 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
8a6179bc 802 die_errno(_("could not write commit template"));
13208572 803
84c9dc2c
NTND
804 if (auto_comment_line_char)
805 adjust_comment_line_char(&sb);
f5bbc322
KH
806 strbuf_release(&sb);
807
bb1ae3f6 808 /* This checks if committer ident is explicitly given */
f20f3878 809 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
bed575e4 810 if (use_editor && include_status) {
e23fd15a
EP
811 int ident_shown = 0;
812 int saved_color_setting;
47010263
JK
813 struct ident_split ci, ai;
814
75df1f43
NTND
815 if (whence != FROM_COMMIT) {
816 if (cleanup_mode == CLEANUP_SCISSORS)
817 wt_status_add_cut_line(s->fp);
b926c0d1 818 status_printf_ln(s, GIT_COLOR_NORMAL,
b0cea47e
ÆAB
819 whence == FROM_MERGE
820 ? _("\n"
821 "It looks like you may be committing a merge.\n"
822 "If this is not correct, please remove the file\n"
823 " %s\n"
824 "and try again.\n")
825 : _("\n"
826 "It looks like you may be committing a cherry-pick.\n"
827 "If this is not correct, please remove the file\n"
828 " %s\n"
829 "and try again.\n"),
ca03e067
JK
830 whence == FROM_MERGE ?
831 git_path_merge_head() :
832 git_path_cherry_pick_head());
75df1f43 833 }
ec84bd00 834
b926c0d1 835 fprintf(s->fp, "\n");
ec84bd00 836 if (cleanup_mode == CLEANUP_ALL)
4064e665
ÆAB
837 status_printf(s, GIT_COLOR_NORMAL,
838 _("Please enter the commit message for your changes."
eff80a9f
JH
839 " Lines starting\nwith '%c' will be ignored, and an empty"
840 " message aborts the commit.\n"), comment_line_char);
75df1f43
NTND
841 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
842 wt_status_add_cut_line(s->fp);
ec84bd00 843 else /* CLEANUP_SPACE, that is. */
4064e665
ÆAB
844 status_printf(s, GIT_COLOR_NORMAL,
845 _("Please enter the commit message for your changes."
eff80a9f
JH
846 " Lines starting\n"
847 "with '%c' will be kept; you may remove them"
848 " yourself if you want to.\n"
849 "An empty message aborts the commit.\n"), comment_line_char);
ec84bd00 850
fac90838
JK
851 /*
852 * These should never fail because they come from our own
853 * fmt_ident. They may fail the sane_ident test, but we know
854 * that the name and mail pointers will at least be valid,
855 * which is enough for our tests and printing here.
856 */
857 assert_split_ident(&ai, author_ident);
858 assert_split_ident(&ci, &committer_ident);
47010263
JK
859
860 if (ident_cmp(&ai, &ci))
b926c0d1 861 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd 862 _("%s"
47010263 863 "Author: %.*s <%.*s>"),
b926c0d1 864 ident_shown++ ? "" : "\n",
47010263
JK
865 (int)(ai.name_end - ai.name_begin), ai.name_begin,
866 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
e83dbe80 867
b7242b8c
JK
868 if (author_date_is_interesting())
869 status_printf_ln(s, GIT_COLOR_NORMAL,
870 _("%s"
871 "Date: %s"),
872 ident_shown++ ? "" : "\n",
a5481a6c 873 show_ident_date(&ai, DATE_MODE(NORMAL)));
e83dbe80 874
d6991cee 875 if (!committer_ident_sufficiently_given())
b926c0d1 876 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd 877 _("%s"
47010263 878 "Committer: %.*s <%.*s>"),
b926c0d1 879 ident_shown++ ? "" : "\n",
47010263
JK
880 (int)(ci.name_end - ci.name_begin), ci.name_begin,
881 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
bb1ae3f6 882
b3cf1b77 883 status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); /* Add new line for clarity */
bb1ae3f6 884
d249b098
JH
885 saved_color_setting = s->use_color;
886 s->use_color = 0;
37f3012f 887 commitable = run_status(s->fp, index_file, prefix, 1, s);
d249b098 888 s->use_color = saved_color_setting;
ec84bd00 889 } else {
8066df41 890 struct object_id oid;
fbcf1184 891 const char *parent = "HEAD";
7168624c 892
7168624c 893 if (!active_nr && read_cache() < 0)
8a6179bc 894 die(_("Cannot read index"));
7168624c 895
fbcf1184
JH
896 if (amend)
897 parent = "HEAD^1";
898
8066df41 899 if (get_sha1(parent, oid.hash)) {
2c49f7ff
NTND
900 int i, ita_nr = 0;
901
902 for (i = 0; i < active_nr; i++)
903 if (ce_intent_to_add(active_cache[i]))
904 ita_nr++;
905 commitable = active_nr - ita_nr > 0;
906 } else {
c215d3d2
JL
907 /*
908 * Unless the user did explicitly request a submodule
909 * ignore mode by passing a command line option we do
910 * not ignore any changed submodule SHA-1s when
911 * comparing index and parent, no matter what is
912 * configured. Otherwise we won't commit any
913 * submodules which were manually staged, which would
914 * be really confusing.
915 */
916 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;
917 if (ignore_submodule_arg &&
918 !strcmp(ignore_submodule_arg, "all"))
919 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;
018ec3c8 920 commitable = index_differs_from(parent, diff_flags, 1);
c215d3d2 921 }
ec84bd00 922 }
4c28e4ad 923 strbuf_release(&committer_ident);
d616a239 924
37f3012f 925 fclose(s->fp);
7168624c 926
37f7a857
JS
927 /*
928 * Reject an attempt to record a non-merge empty commit without
929 * explicit --allow-empty. In the cherry-pick case, it may be
930 * empty due to conflict resolution, which the user should okay.
931 */
932 if (!commitable && whence != FROM_MERGE && !allow_empty &&
06bb643b 933 !(amend && is_a_merge(current_head))) {
2556b996 934 s->display_comment_prefix = old_display_comment_prefix;
d249b098 935 run_status(stdout, index_file, prefix, 0, s);
f197ed2f 936 if (amend)
fc88e316 937 fputs(_(empty_amend_advice), stderr);
c17592a7 938 else if (whence == FROM_CHERRY_PICK) {
6c80cd29 939 fputs(_(empty_cherry_pick_advice), stderr);
c17592a7
JK
940 if (!sequencer_in_use)
941 fputs(_(empty_cherry_pick_advice_single), stderr);
942 else
943 fputs(_(empty_cherry_pick_advice_multi), stderr);
944 }
ec84bd00 945 return 0;
7168624c
AR
946 }
947
ec84bd00
PB
948 /*
949 * Re-read the index as pre-commit hook could have updated it,
950 * and write it out as a tree. We must do this before we invoke
951 * the editor and after we invoke run_status above.
952 */
953 discard_cache();
954 read_cache_from(index_file);
996277c5 955 if (update_main_cache_tree(0)) {
8a6179bc 956 error(_("Error building trees"));
ec84bd00 957 return 0;
7168624c 958 }
f5bbc322 959
15048f8a 960 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
e51b0dfc 961 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL))
8089c85b 962 return 0;
f5bbc322 963
ec84bd00 964 if (use_editor) {
8d7aa4ba
EP
965 struct argv_array env = ARGV_ARRAY_INIT;
966
967 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
968 if (launch_editor(git_path_commit_editmsg(), NULL, env.argv)) {
7198203a 969 fprintf(stderr,
8a6179bc 970 _("Please supply the message using either -m or -F option.\n"));
7198203a
SB
971 exit(1);
972 }
8d7aa4ba 973 argv_array_clear(&env);
ec84bd00 974 }
f5bbc322 975
ec84bd00 976 if (!no_verify &&
e51b0dfc 977 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL)) {
ec84bd00
PB
978 return 0;
979 }
f5bbc322 980
ec84bd00 981 return 1;
f5bbc322
KH
982}
983
b2eda9bd 984static int rest_is_empty(struct strbuf *sb, int start)
f5bbc322 985{
b2eda9bd 986 int i, eol;
f5bbc322 987 const char *nl;
f5bbc322 988
669638fe 989 /* Check if the rest is just whitespace and Signed-off-by's. */
f5bbc322
KH
990 for (i = start; i < sb->len; i++) {
991 nl = memchr(sb->buf + i, '\n', sb->len - i);
992 if (nl)
993 eol = nl - sb->buf;
994 else
995 eol = sb->len;
996
997 if (strlen(sign_off_header) <= eol - i &&
59556548 998 starts_with(sb->buf + i, sign_off_header)) {
f5bbc322
KH
999 i = eol;
1000 continue;
1001 }
1002 while (i < eol)
1003 if (!isspace(sb->buf[i++]))
1004 return 0;
1005 }
1006
1007 return 1;
1008}
1009
b2eda9bd
JH
1010/*
1011 * Find out if the message in the strbuf contains only whitespace and
1012 * Signed-off-by lines.
1013 */
1014static int message_is_empty(struct strbuf *sb)
1015{
1016 if (cleanup_mode == CLEANUP_NONE && sb->len)
1017 return 0;
1018 return rest_is_empty(sb, 0);
1019}
1020
1021/*
1022 * See if the user edited the message in the editor or left what
1023 * was in the template intact
1024 */
1025static int template_untouched(struct strbuf *sb)
1026{
1027 struct strbuf tmpl = STRBUF_INIT;
cf4fff57 1028 const char *start;
b2eda9bd
JH
1029
1030 if (cleanup_mode == CLEANUP_NONE && sb->len)
1031 return 0;
1032
1033 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1034 return 0;
1035
63af4a84 1036 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
cf4fff57 1037 if (!skip_prefix(sb->buf, tmpl.buf, &start))
b2eda9bd
JH
1038 start = sb->buf;
1039 strbuf_release(&tmpl);
1040 return rest_is_empty(sb, start - sb->buf);
1041}
1042
146ea068
JH
1043static const char *find_author_by_nickname(const char *name)
1044{
1045 struct rev_info revs;
1046 struct commit *commit;
1047 struct strbuf buf = STRBUF_INIT;
ea16794e 1048 struct string_list mailmap = STRING_LIST_INIT_NODUP;
146ea068
JH
1049 const char *av[20];
1050 int ac = 0;
1051
1052 init_revisions(&revs, NULL);
1053 strbuf_addf(&buf, "--author=%s", name);
1054 av[++ac] = "--all";
1055 av[++ac] = "-i";
1056 av[++ac] = buf.buf;
1057 av[++ac] = NULL;
1058 setup_revisions(ac, av, &revs, NULL);
ea16794e
AP
1059 revs.mailmap = &mailmap;
1060 read_mailmap(revs.mailmap, NULL);
1061
81c3ce3c
SB
1062 if (prepare_revision_walk(&revs))
1063 die(_("revision walk setup failed"));
146ea068
JH
1064 commit = get_revision(&revs);
1065 if (commit) {
dd2e794a 1066 struct pretty_print_context ctx = {0};
a5481a6c 1067 ctx.date_mode.type = DATE_NORMAL;
146ea068 1068 strbuf_release(&buf);
ea16794e
AP
1069 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1070 clear_mailmap(&mailmap);
146ea068
JH
1071 return strbuf_detach(&buf, NULL);
1072 }
1044b1f6 1073 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
146ea068
JH
1074}
1075
76e2f7ce
JH
1076
1077static void handle_untracked_files_arg(struct wt_status *s)
1078{
1079 if (!untracked_files_arg)
1080 ; /* default already initialized */
1081 else if (!strcmp(untracked_files_arg, "no"))
1082 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1083 else if (!strcmp(untracked_files_arg, "normal"))
1084 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1085 else if (!strcmp(untracked_files_arg, "all"))
1086 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1087 else
8a6179bc 1088 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
76e2f7ce
JH
1089}
1090
37f7a857
JS
1091static const char *read_commit_message(const char *name)
1092{
dd0d388c 1093 const char *out_enc;
37f7a857
JS
1094 struct commit *commit;
1095
1096 commit = lookup_commit_reference_by_name(name);
1097 if (!commit)
6c80cd29 1098 die(_("could not lookup commit %s"), name);
37f7a857 1099 out_enc = get_commit_output_encoding();
5a10d236 1100 return logmsg_reencode(commit, NULL, out_enc);
37f7a857
JS
1101}
1102
84b4202d
JH
1103/*
1104 * Enumerate what needs to be propagated when --porcelain
1105 * is not in effect here.
1106 */
1107static struct status_deferred_config {
be7e795e 1108 enum wt_status_format status_format;
84b4202d
JH
1109 int show_branch;
1110} status_deferred_config = {
1111 STATUS_FORMAT_UNSPECIFIED,
1112 -1 /* unspecified */
1113};
1114
1115static void finalize_deferred_config(struct wt_status *s)
1116{
1117 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1ecdecce 1118 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
84b4202d
JH
1119 !s->null_termination);
1120
1121 if (s->null_termination) {
1122 if (status_format == STATUS_FORMAT_NONE ||
1123 status_format == STATUS_FORMAT_UNSPECIFIED)
1124 status_format = STATUS_FORMAT_PORCELAIN;
1125 else if (status_format == STATUS_FORMAT_LONG)
1126 die(_("--long and -z are incompatible"));
1127 }
1128
1129 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1130 status_format = status_deferred_config.status_format;
1131 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1132 status_format = STATUS_FORMAT_NONE;
1133
1134 if (use_deferred_config && s->show_branch < 0)
1135 s->show_branch = status_deferred_config.show_branch;
1136 if (s->show_branch < 0)
1137 s->show_branch = 0;
1138}
1139
2f02b25f 1140static int parse_and_validate_options(int argc, const char *argv[],
036dbbfb 1141 const struct option *options,
dbd0f5c7 1142 const char * const usage[],
d249b098 1143 const char *prefix,
06bb643b 1144 struct commit *current_head,
d249b098 1145 struct wt_status *s)
f5bbc322
KH
1146{
1147 int f = 0;
1148
036dbbfb 1149 argc = parse_options(argc, argv, prefix, options, usage, 0);
84b4202d 1150 finalize_deferred_config(s);
f5bbc322 1151
146ea068
JH
1152 if (force_author && !strchr(force_author, '>'))
1153 force_author = find_author_by_nickname(force_author);
1154
c51f6cee 1155 if (force_author && renew_authorship)
8a6179bc 1156 die(_("Using both --reset-author and --author does not make sense"));
c51f6cee 1157
25206778 1158 if (logfile || have_option_m || use_message || fixup_message)
4803466f 1159 use_editor = 0;
ca1ba201
JH
1160 if (0 <= edit_flag)
1161 use_editor = edit_flag;
f5bbc322 1162
f5bbc322 1163 /* Sanity check options */
06bb643b 1164 if (amend && !current_head)
8a6179bc 1165 die(_("You have nothing to amend."));
b0cea47e
ÆAB
1166 if (amend && whence != FROM_COMMIT) {
1167 if (whence == FROM_MERGE)
1168 die(_("You are in the middle of a merge -- cannot amend."));
1169 else if (whence == FROM_CHERRY_PICK)
1170 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1171 }
89ac1223 1172 if (fixup_message && squash_message)
9c227655 1173 die(_("Options --squash and --fixup cannot be used together"));
f5bbc322
KH
1174 if (use_message)
1175 f++;
1176 if (edit_message)
1177 f++;
d71b8ba7
PN
1178 if (fixup_message)
1179 f++;
f5bbc322
KH
1180 if (logfile)
1181 f++;
1182 if (f > 1)
8a6179bc 1183 die(_("Only one of -c/-C/-F/--fixup can be used."));
27014cbc 1184 if (have_option_m && f > 0)
8a6179bc 1185 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
27014cbc 1186 if (f || have_option_m)
010c7dbc 1187 template_file = NULL;
f5bbc322
KH
1188 if (edit_message)
1189 use_message = edit_message;
d71b8ba7 1190 if (amend && !use_message && !fixup_message)
f5bbc322 1191 use_message = "HEAD";
37f7a857 1192 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
8a6179bc 1193 die(_("--reset-author can be used only with -C, -c or --amend."));
f5bbc322 1194 if (use_message) {
37f7a857
JS
1195 use_message_buffer = read_commit_message(use_message);
1196 if (!renew_authorship) {
1197 author_message = use_message;
1198 author_message_buffer = use_message_buffer;
1199 }
1200 }
1201 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1202 author_message = "CHERRY_PICK_HEAD";
1203 author_message_buffer = read_commit_message(author_message);
f5bbc322
KH
1204 }
1205
b4bd4668
CI
1206 if (patch_interactive)
1207 interactive = 1;
1208
05efb7b7 1209 if (also + only + all + interactive > 1)
b4bd4668 1210 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
319d8352 1211 if (argc == 0 && (also || (only && !amend && !allow_empty)))
8a6179bc 1212 die(_("No paths with --include/--only does not make sense."));
5f065737
AR
1213 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1214 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1215 else if (!strcmp(cleanup_arg, "verbatim"))
1216 cleanup_mode = CLEANUP_NONE;
1217 else if (!strcmp(cleanup_arg, "whitespace"))
1218 cleanup_mode = CLEANUP_SPACE;
1219 else if (!strcmp(cleanup_arg, "strip"))
1220 cleanup_mode = CLEANUP_ALL;
75df1f43
NTND
1221 else if (!strcmp(cleanup_arg, "scissors"))
1222 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
5f065737 1223 else
8a6179bc 1224 die(_("Invalid cleanup mode %s"), cleanup_arg);
f5bbc322 1225
76e2f7ce 1226 handle_untracked_files_arg(s);
4bfee30a 1227
f5bbc322 1228 if (all && argc > 0)
8a6179bc 1229 die(_("Paths with -a does not make sense."));
f5bbc322 1230
f3f47a1e 1231 if (status_format != STATUS_FORMAT_NONE)
7c9f7038
JK
1232 dry_run = 1;
1233
f5bbc322
KH
1234 return argc;
1235}
1236
d249b098 1237static int dry_run_commit(int argc, const char **argv, const char *prefix,
06bb643b 1238 const struct commit *current_head, struct wt_status *s)
f5bbc322 1239{
f5bbc322 1240 int commitable;
3a5d13a3 1241 const char *index_file;
f5bbc322 1242
06bb643b 1243 index_file = prepare_index(argc, argv, prefix, current_head, 1);
d249b098 1244 commitable = run_status(stdout, index_file, prefix, 0, s);
3a5d13a3 1245 rollback_index_files();
f5bbc322 1246
3a5d13a3
JH
1247 return commitable ? 0 : 1;
1248}
1249
8852117a 1250static int parse_status_slot(const char *slot)
f766b367 1251{
8852117a 1252 if (!strcasecmp(slot, "header"))
f766b367 1253 return WT_STATUS_HEADER;
8852117a 1254 if (!strcasecmp(slot, "branch"))
1d282327 1255 return WT_STATUS_ONBRANCH;
8852117a 1256 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
f766b367 1257 return WT_STATUS_UPDATED;
8852117a 1258 if (!strcasecmp(slot, "changed"))
f766b367 1259 return WT_STATUS_CHANGED;
8852117a 1260 if (!strcasecmp(slot, "untracked"))
f766b367 1261 return WT_STATUS_UNTRACKED;
8852117a 1262 if (!strcasecmp(slot, "nobranch"))
f766b367 1263 return WT_STATUS_NOBRANCH;
8852117a 1264 if (!strcasecmp(slot, "unmerged"))
f766b367 1265 return WT_STATUS_UNMERGED;
93fdf301
SK
1266 if (!strcasecmp(slot, "localBranch"))
1267 return WT_STATUS_LOCAL_BRANCH;
1268 if (!strcasecmp(slot, "remoteBranch"))
1269 return WT_STATUS_REMOTE_BRANCH;
8b8e8624 1270 return -1;
f766b367
JH
1271}
1272
1273static int git_status_config(const char *k, const char *v, void *cb)
1274{
1275 struct wt_status *s = cb;
e3f1da98 1276 const char *slot_name;
f766b367 1277
59556548 1278 if (starts_with(k, "column."))
4d2292e9 1279 return git_column_config(k, v, "status", &s->colopts);
f766b367
JH
1280 if (!strcmp(k, "status.submodulesummary")) {
1281 int is_bool;
1282 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1283 if (is_bool && s->submodule_summary)
1284 s->submodule_summary = -1;
1285 return 0;
1286 }
4fb5166a
JJGG
1287 if (!strcmp(k, "status.short")) {
1288 if (git_config_bool(k, v))
84b4202d 1289 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
4fb5166a 1290 else
84b4202d 1291 status_deferred_config.status_format = STATUS_FORMAT_NONE;
4fb5166a
JJGG
1292 return 0;
1293 }
ec85d070 1294 if (!strcmp(k, "status.branch")) {
84b4202d 1295 status_deferred_config.show_branch = git_config_bool(k, v);
ec85d070
JJGG
1296 return 0;
1297 }
c1b5d019
LB
1298 if (!strcmp(k, "status.showstash")) {
1299 s->show_stash = git_config_bool(k, v);
1300 return 0;
1301 }
f766b367 1302 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
e269eb79 1303 s->use_color = git_config_colorbool(k, v);
f766b367
JH
1304 return 0;
1305 }
2556b996
MM
1306 if (!strcmp(k, "status.displaycommentprefix")) {
1307 s->display_comment_prefix = git_config_bool(k, v);
1308 return 0;
1309 }
e3f1da98
RS
1310 if (skip_prefix(k, "status.color.", &slot_name) ||
1311 skip_prefix(k, "color.status.", &slot_name)) {
b9465768 1312 int slot = parse_status_slot(slot_name);
8b8e8624
JK
1313 if (slot < 0)
1314 return 0;
f766b367
JH
1315 if (!v)
1316 return config_error_nonbool(k);
f6c5a296 1317 return color_parse(v, s->color_palette[slot]);
f766b367
JH
1318 }
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
8a6179bc 1333 return error(_("Invalid untracked files mode '%s'"), v);
f766b367
JH
1334 return 0;
1335 }
1336 return git_diff_ui_config(k, v, NULL);
1337}
1338
3a5d13a3
JH
1339int cmd_status(int argc, const char **argv, const char *prefix)
1340{
036dbbfb 1341 static struct wt_status s;
4bb6644d 1342 int fd;
8066df41 1343 struct object_id oid;
9e4b7ab6 1344 static struct option builtin_status_options[] = {
f2276316 1345 OPT__VERBOSE(&verbose, N_("be verbose")),
dd2be243 1346 OPT_SET_INT('s', "short", &status_format,
f2276316 1347 N_("show status concisely"), STATUS_FORMAT_SHORT),
84b4202d
JH
1348 OPT_BOOL('b', "branch", &s.show_branch,
1349 N_("show branch information")),
c1b5d019
LB
1350 OPT_BOOL(0, "show-stash", &s.show_stash,
1351 N_("show stash information")),
c4f596b9
JH
1352 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1353 N_("version"), N_("machine-readable output"),
1354 PARSE_OPT_OPTARG, opt_parse_porcelain },
f3f47a1e
JK
1355 OPT_SET_INT(0, "long", &status_format,
1356 N_("show status in long format (default)"),
1357 STATUS_FORMAT_LONG),
d5d09d47
SB
1358 OPT_BOOL('z', "null", &s.null_termination,
1359 N_("terminate entries with NUL")),
76e2f7ce 1360 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
f2276316
NTND
1361 N_("mode"),
1362 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
76e2f7ce 1363 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
d5d09d47
SB
1364 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1365 N_("show ignored files")),
f2276316
NTND
1366 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1367 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
46a958b3 1368 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
9c23f4c5 1369 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
76e2f7ce
JH
1370 OPT_END(),
1371 };
1372
5d3dd915
NTND
1373 if (argc == 2 && !strcmp(argv[1], "-h"))
1374 usage_with_options(builtin_status_usage, builtin_status_options);
1375
5c25dfaa 1376 status_init_config(&s, git_status_config);
76e2f7ce 1377 argc = parse_options(argc, argv, prefix,
9e4b7ab6
JH
1378 builtin_status_options,
1379 builtin_status_usage, 0);
4d2292e9 1380 finalize_colopts(&s.colopts, -1);
84b4202d 1381 finalize_deferred_config(&s);
000f97bd 1382
76e2f7ce 1383 handle_untracked_files_arg(&s);
2381e39e
JH
1384 if (show_ignored_in_status)
1385 s.show_ignored_files = 1;
15b55ae0
NTND
1386 parse_pathspec(&s.pathspec, 0,
1387 PATHSPEC_PREFER_FULL,
1388 prefix, argv);
76e2f7ce 1389
5ab2a2da 1390 read_cache_preload(&s.pathspec);
9b2d6149 1391 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
4bb6644d
MH
1392
1393 fd = hold_locked_index(&index_lock, 0);
4bb6644d 1394
8066df41 1395 s.is_initial = get_sha1(s.reference, oid.hash) ? 1 : 0;
d9fc746c 1396 if (!s.is_initial)
8066df41 1397 hashcpy(s.sha1_commit, oid.hash);
d9fc746c 1398
46a958b3 1399 s.ignore_submodule_arg = ignore_submodule_arg;
be7e795e
JH
1400 s.status_format = status_format;
1401 s.verbose = verbose;
1402
76e2f7ce
JH
1403 wt_status_collect(&s);
1404
226c051a
NTND
1405 if (0 <= fd)
1406 update_index_if_able(&the_index, &index_lock);
1407
8661768f
JK
1408 if (s.relative_paths)
1409 s.prefix = prefix;
38920dd6 1410
be7e795e 1411 wt_status_print(&s);
76e2f7ce 1412 return 0;
f5bbc322
KH
1413}
1414
8b27ff7e
MM
1415static const char *implicit_ident_advice(void)
1416{
4aad2f16 1417 char *user_config = expand_user_path("~/.gitconfig", 0);
e682c9db
PT
1418 char *xdg_config = xdg_config_home("config");
1419 int config_exists = file_exists(user_config) || file_exists(xdg_config);
8b27ff7e 1420
8b27ff7e
MM
1421 free(user_config);
1422 free(xdg_config);
1423
1424 if (config_exists)
1425 return _(implicit_ident_advice_config);
1426 else
1427 return _(implicit_ident_advice_noconfig);
1428
1429}
1430
8066df41 1431static void print_summary(const char *prefix, const struct object_id *oid,
06bb643b 1432 int initial_commit)
f5bbc322
KH
1433{
1434 struct rev_info rev;
1435 struct commit *commit;
49ff9a7a 1436 struct strbuf format = STRBUF_INIT;
8066df41 1437 struct object_id junk_oid;
d5a35c11 1438 const char *head;
49ff9a7a
JK
1439 struct pretty_print_context pctx = {0};
1440 struct strbuf author_ident = STRBUF_INIT;
1441 struct strbuf committer_ident = STRBUF_INIT;
f5bbc322 1442
bc83266a 1443 commit = lookup_commit(oid);
f5bbc322 1444 if (!commit)
8a6179bc 1445 die(_("couldn't look up newly created commit"));
5e7d4d3e 1446 if (parse_commit(commit))
8a6179bc 1447 die(_("could not parse newly created commit"));
f5bbc322 1448
49ff9a7a
JK
1449 strbuf_addstr(&format, "format:%h] %s");
1450
1451 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1452 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1453 if (strbuf_cmp(&author_ident, &committer_ident)) {
1454 strbuf_addstr(&format, "\n Author: ");
1455 strbuf_addbuf_percentquote(&format, &author_ident);
1456 }
b7242b8c
JK
1457 if (author_date_is_interesting()) {
1458 struct strbuf date = STRBUF_INIT;
1459 format_commit_message(commit, "%ad", &date, &pctx);
1460 strbuf_addstr(&format, "\n Date: ");
1461 strbuf_addbuf_percentquote(&format, &date);
1462 strbuf_release(&date);
1463 }
d6991cee 1464 if (!committer_ident_sufficiently_given()) {
49ff9a7a
JK
1465 strbuf_addstr(&format, "\n Committer: ");
1466 strbuf_addbuf_percentquote(&format, &committer_ident);
b706fcfe
JK
1467 if (advice_implicit_identity) {
1468 strbuf_addch(&format, '\n');
8b27ff7e 1469 strbuf_addstr(&format, implicit_ident_advice());
b706fcfe 1470 }
49ff9a7a
JK
1471 }
1472 strbuf_release(&author_ident);
1473 strbuf_release(&committer_ident);
1474
f5bbc322
KH
1475 init_revisions(&rev, prefix);
1476 setup_revisions(0, NULL, &rev, NULL);
1477
f5bbc322
KH
1478 rev.diff = 1;
1479 rev.diffopt.output_format =
1480 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1481
1482 rev.verbose_header = 1;
1483 rev.show_root_diff = 1;
49ff9a7a 1484 get_commit_format(format.buf, &rev);
bf82a150 1485 rev.always_show_header = 0;
3eb2a15e 1486 rev.diffopt.detect_rename = 1;
3eb2a15e 1487 rev.diffopt.break_opt = 0;
15964563 1488 diff_setup_done(&rev.diffopt);
f5bbc322 1489
8066df41 1490 head = resolve_ref_unsafe("HEAD", 0, junk_oid.hash, NULL);
e3f1da98
RS
1491 if (!strcmp(head, "HEAD"))
1492 head = _("detached HEAD");
1493 else
1494 skip_prefix(head, "refs/heads/", &head);
1495 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
f5bbc322 1496
bf82a150 1497 if (!log_tree_commit(&rev, commit)) {
a45e1a87
TRC
1498 rev.always_show_header = 1;
1499 rev.use_terminator = 1;
1500 log_tree_commit(&rev, commit);
bf82a150 1501 }
a45e1a87 1502
fc6f19fe 1503 strbuf_release(&format);
f5bbc322
KH
1504}
1505
186458b1 1506static int git_commit_config(const char *k, const char *v, void *cb)
f5bbc322 1507{
d249b098 1508 struct wt_status *s = cb;
ba3c69a9 1509 int status;
d249b098 1510
984c6e7e 1511 if (!strcmp(k, "commit.template"))
395de250 1512 return git_config_pathname(&template_file, k, v);
bed575e4
JHI
1513 if (!strcmp(k, "commit.status")) {
1514 include_status = git_config_bool(k, v);
1515 return 0;
1516 }
51fb3a3d
RT
1517 if (!strcmp(k, "commit.cleanup"))
1518 return git_config_string(&cleanup_arg, k, v);
d95bfb12
NV
1519 if (!strcmp(k, "commit.gpgsign")) {
1520 sign_commit = git_config_bool(k, v) ? "" : NULL;
1521 return 0;
1522 }
aaab8420
PB
1523 if (!strcmp(k, "commit.verbose")) {
1524 int is_bool;
1525 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1526 return 0;
1527 }
f5bbc322 1528
ba3c69a9
JH
1529 status = git_gpg_config(k, v, NULL);
1530 if (status)
1531 return status;
d249b098 1532 return git_status_config(k, v, s);
f5bbc322
KH
1533}
1534
8066df41 1535static int run_rewrite_hook(const struct object_id *oldoid,
1536 const struct object_id *newoid)
6f6bee3b 1537{
d3180279 1538 struct child_process proc = CHILD_PROCESS_INIT;
6f6bee3b
TR
1539 const char *argv[3];
1540 int code;
4a528191 1541 struct strbuf sb = STRBUF_INIT;
6f6bee3b 1542
5a7da2dc
AS
1543 argv[0] = find_hook("post-rewrite");
1544 if (!argv[0])
6f6bee3b
TR
1545 return 0;
1546
6f6bee3b
TR
1547 argv[1] = "amend";
1548 argv[2] = NULL;
1549
6f6bee3b
TR
1550 proc.argv = argv;
1551 proc.in = -1;
1552 proc.stdout_to_stderr = 1;
1553
1554 code = start_command(&proc);
1555 if (code)
1556 return code;
8066df41 1557 strbuf_addf(&sb, "%s %s\n", oid_to_hex(oldoid), oid_to_hex(newoid));
af65f68c 1558 sigchain_push(SIGPIPE, SIG_IGN);
4a528191 1559 write_in_full(proc.in, sb.buf, sb.len);
6f6bee3b 1560 close(proc.in);
4a528191 1561 strbuf_release(&sb);
af65f68c 1562 sigchain_pop(SIGPIPE);
6f6bee3b
TR
1563 return finish_command(&proc);
1564}
1565
15048f8a
BP
1566int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1567{
8d7aa4ba 1568 struct argv_array hook_env = ARGV_ARRAY_INIT;
15048f8a
BP
1569 va_list args;
1570 int ret;
1571
8d7aa4ba 1572 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
15048f8a
BP
1573
1574 /*
1575 * Let the hook know that no editor will be launched.
1576 */
1577 if (!editor_is_used)
8d7aa4ba 1578 argv_array_push(&hook_env, "GIT_EDITOR=:");
15048f8a
BP
1579
1580 va_start(args, name);
8d7aa4ba 1581 ret = run_hook_ve(hook_env.argv,name, args);
15048f8a 1582 va_end(args);
8d7aa4ba 1583 argv_array_clear(&hook_env);
15048f8a
BP
1584
1585 return ret;
1586}
1587
f5bbc322
KH
1588int cmd_commit(int argc, const char **argv, const char *prefix)
1589{
036dbbfb
JK
1590 static struct wt_status s;
1591 static struct option builtin_commit_options[] = {
9c23f4c5
NTND
1592 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1593 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1594
1595 OPT_GROUP(N_("Commit message options")),
1596 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1597 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1598 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1599 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1600 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1601 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1602 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1603 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
d5d09d47
SB
1604 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1605 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
9c23f4c5
NTND
1606 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1607 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1608 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
d5d09d47 1609 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
e703d711 1610 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
9c23f4c5 1611 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
036dbbfb
JK
1612 /* end commit message options */
1613
9c23f4c5 1614 OPT_GROUP(N_("Commit contents options")),
d5d09d47
SB
1615 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1616 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1617 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1618 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1619 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
def480fe 1620 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
d5d09d47 1621 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
9c23f4c5 1622 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
036dbbfb 1623 STATUS_FORMAT_SHORT),
84b4202d 1624 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
036dbbfb 1625 OPT_SET_INT(0, "porcelain", &status_format,
9c23f4c5 1626 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
f3f47a1e
JK
1627 OPT_SET_INT(0, "long", &status_format,
1628 N_("show status in long format (default)"),
1629 STATUS_FORMAT_LONG),
d5d09d47
SB
1630 OPT_BOOL('z', "null", &s.null_termination,
1631 N_("terminate entries with NUL")),
1632 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1633 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
9c23f4c5 1634 { 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" },
036dbbfb
JK
1635 /* end commit contents options */
1636
4741edd5
SB
1637 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1638 N_("ok to record an empty change")),
1639 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1640 N_("ok to record a change with an empty message")),
036dbbfb
JK
1641
1642 OPT_END()
1643 };
1644
f285a2d7 1645 struct strbuf sb = STRBUF_INIT;
4c28e4ad 1646 struct strbuf author_ident = STRBUF_INIT;
f5bbc322 1647 const char *index_file, *reflog_msg;
1a72cfd7 1648 char *nl;
8066df41 1649 struct object_id oid;
de9f7fa3 1650 struct commit_list *parents = NULL;
cf10f9fd 1651 struct stat statbuf;
06bb643b 1652 struct commit *current_head = NULL;
ed7a42a0 1653 struct commit_extra_header *extra = NULL;
c0fe1ed0
RS
1654 struct ref_transaction *transaction;
1655 struct strbuf err = STRBUF_INIT;
f5bbc322 1656
5d3dd915
NTND
1657 if (argc == 2 && !strcmp(argv[1], "-h"))
1658 usage_with_options(builtin_commit_usage, builtin_commit_options);
1659
5c25dfaa 1660 status_init_config(&s, git_commit_config);
4ddb1354 1661 s.commit_template = 1;
f0915cba 1662 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
4d2292e9 1663 s.colopts = 0;
f5bbc322 1664
8066df41 1665 if (get_sha1("HEAD", oid.hash))
06bb643b
JH
1666 current_head = NULL;
1667 else {
bc83266a 1668 current_head = lookup_commit_or_die(&oid, "HEAD");
5e7d4d3e 1669 if (parse_commit(current_head))
06bb643b
JH
1670 die(_("could not parse HEAD commit"));
1671 }
aaab8420 1672 verbose = -1; /* unspecified */
036dbbfb
JK
1673 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1674 builtin_commit_usage,
06bb643b 1675 prefix, current_head, &s);
aaab8420
PB
1676 if (verbose == -1)
1677 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1678
c9bfb953 1679 if (dry_run)
06bb643b 1680 return dry_run_commit(argc, argv, prefix, current_head, &s);
06bb643b 1681 index_file = prepare_index(argc, argv, prefix, current_head, 0);
f5bbc322 1682
ec84bd00
PB
1683 /* Set up everything for writing the commit object. This includes
1684 running hooks, writing the trees, and interacting with the user. */
06bb643b
JH
1685 if (!prepare_to_commit(index_file, prefix,
1686 current_head, &s, &author_ident)) {
2888605c 1687 rollback_index_files();
f5bbc322
KH
1688 return 1;
1689 }
1690
f5bbc322 1691 /* Determine parents */
643cb5f7 1692 reflog_msg = getenv("GIT_REFLOG_ACTION");
06bb643b 1693 if (!current_head) {
643cb5f7
CC
1694 if (!reflog_msg)
1695 reflog_msg = "commit (initial)";
f5bbc322 1696 } else if (amend) {
643cb5f7
CC
1697 if (!reflog_msg)
1698 reflog_msg = "commit (amend)";
de9f7fa3 1699 parents = copy_commit_list(current_head->parents);
37f7a857 1700 } else if (whence == FROM_MERGE) {
f285a2d7 1701 struct strbuf m = STRBUF_INIT;
f5bbc322 1702 FILE *fp;
e23fd15a 1703 int allow_fast_forward = 1;
de9f7fa3 1704 struct commit_list **pptr = &parents;
f5bbc322 1705
643cb5f7
CC
1706 if (!reflog_msg)
1707 reflog_msg = "commit (merge)";
de9f7fa3 1708 pptr = commit_list_append(current_head, pptr);
23a9e071 1709 fp = xfopen(git_path_merge_head(), "r");
8f309aeb 1710 while (strbuf_getline_lf(&m, fp) != EOF) {
5231c633
JH
1711 struct commit *parent;
1712
1713 parent = get_merge_parent(m.buf);
1714 if (!parent)
8a6179bc 1715 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
de9f7fa3 1716 pptr = commit_list_append(parent, pptr);
7c3fd25d 1717 }
f5bbc322
KH
1718 fclose(fp);
1719 strbuf_release(&m);
f932729c
JK
1720 if (!stat(git_path_merge_mode(), &statbuf)) {
1721 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
8a6179bc 1722 die_errno(_("could not read MERGE_MODE"));
cf10f9fd
MV
1723 if (!strcmp(sb.buf, "no-ff"))
1724 allow_fast_forward = 0;
1725 }
1726 if (allow_fast_forward)
1727 parents = reduce_heads(parents);
f5bbc322 1728 } else {
643cb5f7 1729 if (!reflog_msg)
37f7a857
JS
1730 reflog_msg = (whence == FROM_CHERRY_PICK)
1731 ? "commit (cherry-pick)"
1732 : "commit";
de9f7fa3 1733 commit_list_insert(current_head, &parents);
f5bbc322 1734 }
f5bbc322 1735
ec84bd00 1736 /* Finally, get the commit message */
cf10f9fd 1737 strbuf_reset(&sb);
e51b0dfc 1738 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
0721c314 1739 int saved_errno = errno;
740001a5 1740 rollback_index_files();
8a6179bc 1741 die(_("could not read commit message: %s"), strerror(saved_errno));
740001a5 1742 }
99a12694 1743
75df1f43
NTND
1744 if (verbose || /* Truncate the message just before the diff, if any. */
1745 cleanup_mode == CLEANUP_SCISSORS)
d76650b8 1746 strbuf_setlen(&sb, wt_status_locate_end(sb.buf, sb.len));
5f065737 1747 if (cleanup_mode != CLEANUP_NONE)
63af4a84 1748 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
bc17f35f
KS
1749
1750 if (message_is_empty(&sb) && !allow_empty_message) {
b2eda9bd 1751 rollback_index_files();
bc17f35f 1752 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
b2eda9bd
JH
1753 exit(1);
1754 }
bc17f35f 1755 if (template_untouched(&sb) && !allow_empty_message) {
2888605c 1756 rollback_index_files();
bc17f35f 1757 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
fdc7c811 1758 exit(1);
2888605c 1759 }
f5bbc322 1760
0074d18d 1761 if (amend) {
c871a1d1
JH
1762 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1763 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
0074d18d
JH
1764 } else {
1765 struct commit_extra_header **tail = &extra;
1766 append_merge_tag_headers(parents, &tail);
1767 }
ed7a42a0 1768
e0a92804 1769 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->oid.hash,
8066df41 1770 parents, oid.hash, author_ident.buf, sign_commit, extra)) {
2888605c 1771 rollback_index_files();
8a6179bc 1772 die(_("failed to write commit object"));
2888605c 1773 }
4c28e4ad 1774 strbuf_release(&author_ident);
ed7a42a0 1775 free_commit_extra_headers(extra);
f5bbc322 1776
6bb6b034 1777 nl = strchr(sb.buf, '\n');
741707b1
JS
1778 if (nl)
1779 strbuf_setlen(&sb, nl + 1 - sb.buf);
1780 else
1781 strbuf_addch(&sb, '\n');
741707b1
JS
1782 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1783 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
f5bbc322 1784
c0fe1ed0
RS
1785 transaction = ref_transaction_begin(&err);
1786 if (!transaction ||
8066df41 1787 ref_transaction_update(transaction, "HEAD", oid.hash,
c0fe1ed0 1788 current_head
ed1c9977 1789 ? current_head->object.oid.hash : null_sha1,
1d147bdf 1790 0, sb.buf, &err) ||
db7516ab 1791 ref_transaction_commit(transaction, &err)) {
2888605c 1792 rollback_index_files();
c0fe1ed0 1793 die("%s", err.buf);
2888605c 1794 }
c0fe1ed0 1795 ref_transaction_free(transaction);
f5bbc322 1796
f932729c
JK
1797 unlink(git_path_cherry_pick_head());
1798 unlink(git_path_revert_head());
1799 unlink(git_path_merge_head());
1800 unlink(git_path_merge_msg());
1801 unlink(git_path_merge_mode());
1802 unlink(git_path_squash_msg());
f5bbc322 1803
5a9dd399 1804 if (commit_index_files())
8a6179bc 1805 die (_("Repository has been updated, but unable to write\n"
ad5fe377 1806 "new_index file. Check that disk is not full and quota is\n"
8a6179bc 1807 "not exceeded, and then \"git reset HEAD\" to recover."));
f5bbc322 1808
cb6020bb 1809 rerere(0);
15048f8a 1810 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
6f6bee3b 1811 if (amend && !no_post_rewrite) {
6360d343
TR
1812 struct notes_rewrite_cfg *cfg;
1813 cfg = init_copy_notes_for_rewrite("amend");
1814 if (cfg) {
06bb643b 1815 /* we are amending, so current_head is not NULL */
bb7e4739 1816 copy_note_for_rewrite(cfg, &current_head->object.oid, &oid);
80a14665 1817 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
6360d343 1818 }
8066df41 1819 run_rewrite_hook(&current_head->object.oid, &oid);
6f6bee3b 1820 }
f5bbc322 1821 if (!quiet)
8066df41 1822 print_summary(prefix, &oid, !current_head);
f5bbc322 1823
c0fe1ed0 1824 strbuf_release(&err);
f5bbc322
KH
1825 return 0;
1826}