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