commit: make it work with status.short
[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"
9#include "cache-tree.h"
6b2f2d98 10#include "color.h"
2888605c 11#include "dir.h"
f5bbc322
KH
12#include "builtin.h"
13#include "diff.h"
14#include "diffcore.h"
15#include "commit.h"
16#include "revision.h"
17#include "wt-status.h"
18#include "run-command.h"
19#include "refs.h"
20#include "log-tree.h"
21#include "strbuf.h"
22#include "utf8.h"
23#include "parse-options.h"
c455c87c 24#include "string-list.h"
5b2fd956 25#include "rerere.h"
fa9dcf80 26#include "unpack-trees.h"
76e2f7ce 27#include "quote.h"
302ad7a9 28#include "submodule.h"
ba3c69a9 29#include "gpg-interface.h"
323d0530 30#include "column.h"
5ed75e2a 31#include "sequencer.h"
f5bbc322
KH
32
33static const char * const builtin_commit_usage[] = {
d32805dc 34 N_("git commit [options] [--] <pathspec>..."),
f5bbc322
KH
35 NULL
36};
37
2f02b25f 38static const char * const builtin_status_usage[] = {
d32805dc 39 N_("git status [options] [--] <pathspec>..."),
2f02b25f
SB
40 NULL
41};
42
49ff9a7a 43static const char implicit_ident_advice[] =
fc88e316 44N_("Your name and email address were configured automatically based\n"
49ff9a7a
JK
45"on your username and hostname. Please check that they are accurate.\n"
46"You can suppress this message by setting them explicitly:\n"
47"\n"
8bb45b25 48" git config --global user.name \"Your Name\"\n"
49ff9a7a
JK
49" git config --global user.email you@example.com\n"
50"\n"
3f142468 51"After doing this, you may fix the identity used for this commit with:\n"
49ff9a7a 52"\n"
fc88e316 53" git commit --amend --reset-author\n");
49ff9a7a 54
f197ed2f 55static const char empty_amend_advice[] =
fc88e316 56N_("You asked to amend the most recent commit, but doing so would make\n"
f197ed2f 57"it empty. You can repeat your command with --allow-empty, or you can\n"
fc88e316 58"remove the commit entirely with \"git reset HEAD^\".\n");
f197ed2f 59
37f7a857 60static const char empty_cherry_pick_advice[] =
6c80cd29 61N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
37f7a857
JS
62"If you wish to commit it anyway, use:\n"
63"\n"
64" git commit --allow-empty\n"
65"\n"
6c80cd29 66"Otherwise, please use 'git reset'\n");
37f7a857 67
37f7a857 68static const char *use_message_buffer;
f5bbc322 69static const char commit_editmsg[] = "COMMIT_EDITMSG";
2888605c
JH
70static struct lock_file index_lock; /* real index */
71static struct lock_file false_lock; /* used only for partial commits */
72static enum {
73 COMMIT_AS_IS = 1,
74 COMMIT_NORMAL,
4b05548f 75 COMMIT_PARTIAL
2888605c 76} commit_style;
f5bbc322 77
dbd0f5c7 78static const char *logfile, *force_author;
984c6e7e 79static const char *template_file;
37f7a857
JS
80/*
81 * The _message variables are commit names from which to take
82 * the commit message and/or authorship.
83 */
84static const char *author_message, *author_message_buffer;
f5bbc322 85static char *edit_message, *use_message;
89ac1223 86static char *fixup_message, *squash_message;
ca1ba201
JH
87static int all, also, interactive, patch_interactive, only, amend, signoff;
88static int edit_flag = -1; /* unspecified */
c51f6cee 89static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
c9b5fde7 90static int no_post_rewrite, allow_empty_message;
46a958b3 91static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
ba3c69a9
JH
92static char *sign_commit;
93
5f065737
AR
94/*
95 * The default commit message cleanup mode will remove the lines
96 * beginning with # (shell comments) and leading and trailing
97 * whitespaces (empty lines or containing only whitespaces)
98 * if editor is used, and only the whitespaces if the message
99 * is specified explicitly.
100 */
101static enum {
102 CLEANUP_SPACE,
103 CLEANUP_NONE,
4b05548f 104 CLEANUP_ALL
5f065737 105} cleanup_mode;
51fb3a3d 106static const char *cleanup_arg;
f5bbc322 107
37f7a857 108static enum commit_whence whence;
06bb643b 109static int use_editor = 1, include_status = 1;
2381e39e 110static int show_ignored_in_status;
3b6aeb3c 111static const char *only_include_assumed;
2c47789d 112static struct strbuf message = STRBUF_INIT;
f9568530 113
7c9f7038 114static enum {
f3f47a1e 115 STATUS_FORMAT_NONE = 0,
7c9f7038
JK
116 STATUS_FORMAT_LONG,
117 STATUS_FORMAT_SHORT,
4b05548f 118 STATUS_FORMAT_PORCELAIN
f3f47a1e 119} status_format;
7c9f7038 120
f9568530
JS
121static int opt_parse_m(const struct option *opt, const char *arg, int unset)
122{
123 struct strbuf *buf = opt->value;
124 if (unset)
125 strbuf_setlen(buf, 0);
126 else {
a24a41ea
BC
127 if (buf->len)
128 strbuf_addch(buf, '\n');
f9568530 129 strbuf_addstr(buf, arg);
a24a41ea 130 strbuf_complete_line(buf);
f9568530
JS
131 }
132 return 0;
133}
f5bbc322 134
37f7a857
JS
135static void determine_whence(struct wt_status *s)
136{
137 if (file_exists(git_path("MERGE_HEAD")))
138 whence = FROM_MERGE;
139 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
140 whence = FROM_CHERRY_PICK;
141 else
142 whence = FROM_COMMIT;
143 if (s)
144 s->whence = whence;
145}
146
2888605c
JH
147static void rollback_index_files(void)
148{
149 switch (commit_style) {
150 case COMMIT_AS_IS:
151 break; /* nothing to do */
152 case COMMIT_NORMAL:
153 rollback_lock_file(&index_lock);
154 break;
155 case COMMIT_PARTIAL:
156 rollback_lock_file(&index_lock);
157 rollback_lock_file(&false_lock);
158 break;
159 }
160}
161
5a9dd399 162static int commit_index_files(void)
2888605c 163{
5a9dd399
BC
164 int err = 0;
165
2888605c
JH
166 switch (commit_style) {
167 case COMMIT_AS_IS:
168 break; /* nothing to do */
169 case COMMIT_NORMAL:
5a9dd399 170 err = commit_lock_file(&index_lock);
2888605c
JH
171 break;
172 case COMMIT_PARTIAL:
5a9dd399 173 err = commit_lock_file(&index_lock);
2888605c
JH
174 rollback_lock_file(&false_lock);
175 break;
176 }
5a9dd399
BC
177
178 return err;
2888605c
JH
179}
180
181/*
182 * Take a union of paths in the index and the named tree (typically, "HEAD"),
183 * and return the paths that match the given pattern in list.
184 */
c455c87c 185static int list_paths(struct string_list *list, const char *with_tree,
2888605c
JH
186 const char *prefix, const char **pattern)
187{
188 int i;
189 char *m;
190
ea2d4ed3
JK
191 if (!pattern)
192 return 0;
193
2888605c
JH
194 for (i = 0; pattern[i]; i++)
195 ;
196 m = xcalloc(1, i);
197
8894d535 198 if (with_tree) {
f950eb95 199 char *max_prefix = common_prefix(pattern);
5879f568
CB
200 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
201 free(max_prefix);
8894d535 202 }
2888605c
JH
203
204 for (i = 0; i < active_nr; i++) {
205 struct cache_entry *ce = active_cache[i];
7fce6e3c
NTND
206 struct string_list_item *item;
207
7a51ed66 208 if (ce->ce_flags & CE_UPDATE)
e87e22d0 209 continue;
0b50922a 210 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
2888605c 211 continue;
78a395d3 212 item = string_list_insert(list, ce->name);
7fce6e3c
NTND
213 if (ce_skip_worktree(ce))
214 item->util = item; /* better a valid pointer than a fake one */
2888605c
JH
215 }
216
0f64bfa9 217 return report_path_error(m, pattern, prefix);
2888605c
JH
218}
219
c455c87c 220static void add_remove_files(struct string_list *list)
2888605c
JH
221{
222 int i;
223 for (i = 0; i < list->nr; i++) {
d177cab0 224 struct stat st;
c455c87c 225 struct string_list_item *p = &(list->items[i]);
d177cab0 226
7fce6e3c
NTND
227 /* p->util is skip-worktree */
228 if (p->util)
b4d1690d 229 continue;
d177cab0 230
c455c87c
JS
231 if (!lstat(p->string, &st)) {
232 if (add_to_cache(p->string, &st, 0))
8a6179bc 233 die(_("updating files failed"));
960b8ad1 234 } else
c455c87c 235 remove_file_from_cache(p->string);
2888605c
JH
236 }
237}
238
06bb643b 239static void create_base_index(const struct commit *current_head)
fa9dcf80
LT
240{
241 struct tree *tree;
242 struct unpack_trees_options opts;
243 struct tree_desc t;
244
06bb643b 245 if (!current_head) {
fa9dcf80
LT
246 discard_cache();
247 return;
248 }
249
250 memset(&opts, 0, sizeof(opts));
251 opts.head_idx = 1;
252 opts.index_only = 1;
253 opts.merge = 1;
34110cd4
LT
254 opts.src_index = &the_index;
255 opts.dst_index = &the_index;
fa9dcf80
LT
256
257 opts.fn = oneway_merge;
06bb643b 258 tree = parse_tree_indirect(current_head->object.sha1);
fa9dcf80 259 if (!tree)
8a6179bc 260 die(_("failed to unpack HEAD tree object"));
fa9dcf80
LT
261 parse_tree(tree);
262 init_tree_desc(&t, tree->buffer, tree->size);
203a2fe1
DB
263 if (unpack_trees(1, &t, &opts))
264 exit(128); /* We've already reported the error, finish dying */
fa9dcf80
LT
265}
266
d38a30df
MM
267static void refresh_cache_or_die(int refresh_flags)
268{
269 /*
270 * refresh_flags contains REFRESH_QUIET, so the only errors
271 * are for unmerged entries.
272 */
273 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
274 die_resolve_conflict("commit");
275}
276
06bb643b
JH
277static char *prepare_index(int argc, const char **argv, const char *prefix,
278 const struct commit *current_head, int is_status)
f5bbc322
KH
279{
280 int fd;
c455c87c 281 struct string_list partial;
2888605c 282 const char **pathspec = NULL;
1020d087 283 char *old_index_env = NULL;
50b7e70f 284 int refresh_flags = REFRESH_QUIET;
f5bbc322 285
50b7e70f
JH
286 if (is_status)
287 refresh_flags |= REFRESH_UNMERGED;
f5bbc322 288
f64fe7b4
JH
289 if (*argv)
290 pathspec = get_pathspec(prefix, argv);
2888605c 291
671c9b7e 292 if (read_cache_preload(pathspec) < 0)
8a6179bc 293 die(_("index file corrupt"));
671c9b7e 294
1020d087
CI
295 if (interactive) {
296 fd = hold_locked_index(&index_lock, 1);
297
298 refresh_cache_or_die(refresh_flags);
299
300 if (write_cache(fd, active_cache, active_nr) ||
301 close_lock_file(&index_lock))
302 die(_("unable to create temporary index"));
303
304 old_index_env = getenv(INDEX_ENVIRONMENT);
305 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
306
b4bd4668 307 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
1020d087
CI
308 die(_("interactive add failed"));
309
310 if (old_index_env && *old_index_env)
311 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
312 else
313 unsetenv(INDEX_ENVIRONMENT);
314
315 discard_cache();
316 read_cache_from(index_lock.filename);
317
318 commit_style = COMMIT_NORMAL;
319 return index_lock.filename;
320 }
321
2888605c
JH
322 /*
323 * Non partial, non as-is commit.
324 *
325 * (1) get the real index;
326 * (2) update the_index as necessary;
327 * (3) write the_index out to the real index (still locked);
328 * (4) return the name of the locked index file.
329 *
330 * The caller should run hooks on the locked real index, and
331 * (A) if all goes well, commit the real index;
332 * (B) on failure, rollback the real index.
333 */
334 if (all || (also && pathspec && *pathspec)) {
1f2362a9 335 fd = hold_locked_index(&index_lock, 1);
7ae02a30 336 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
d38a30df 337 refresh_cache_or_die(refresh_flags);
e859c69b 338 update_main_cache_tree(WRITE_TREE_SILENT);
4ed7cd3a
BC
339 if (write_cache(fd, active_cache, active_nr) ||
340 close_lock_file(&index_lock))
8a6179bc 341 die(_("unable to write new_index file"));
2888605c
JH
342 commit_style = COMMIT_NORMAL;
343 return index_lock.filename;
f5bbc322
KH
344 }
345
2888605c
JH
346 /*
347 * As-is commit.
348 *
349 * (1) return the name of the real index file.
350 *
73276235
MH
351 * The caller should run hooks on the real index,
352 * and create commit from the_index.
2888605c
JH
353 * We still need to refresh the index here.
354 */
ea2d4ed3 355 if (!only && (!pathspec || !*pathspec)) {
2888605c 356 fd = hold_locked_index(&index_lock, 1);
d38a30df 357 refresh_cache_or_die(refresh_flags);
d5f5d0a9 358 if (active_cache_changed) {
e859c69b 359 update_main_cache_tree(WRITE_TREE_SILENT);
d5f5d0a9
JH
360 if (write_cache(fd, active_cache, active_nr) ||
361 commit_locked_index(&index_lock))
8a6179bc 362 die(_("unable to write new_index file"));
d5f5d0a9
JH
363 } else {
364 rollback_lock_file(&index_lock);
365 }
2888605c 366 commit_style = COMMIT_AS_IS;
f5bbc322
KH
367 return get_index_file();
368 }
369
2888605c
JH
370 /*
371 * A partial commit.
372 *
373 * (0) find the set of affected paths;
374 * (1) get lock on the real index file;
375 * (2) update the_index with the given paths;
376 * (3) write the_index out to the real index (still locked);
377 * (4) get lock on the false index file;
378 * (5) reset the_index from HEAD;
379 * (6) update the_index the same way as (2);
380 * (7) write the_index out to the false index file;
381 * (8) return the name of the false index file (still locked);
382 *
383 * The caller should run hooks on the locked false index, and
384 * create commit from it. Then
385 * (A) if all goes well, commit the real index;
386 * (B) on failure, rollback the real index;
387 * In either case, rollback the false index.
388 */
389 commit_style = COMMIT_PARTIAL;
390
b0cea47e
ÆAB
391 if (whence != FROM_COMMIT) {
392 if (whence == FROM_MERGE)
393 die(_("cannot do a partial commit during a merge."));
394 else if (whence == FROM_CHERRY_PICK)
395 die(_("cannot do a partial commit during a cherry-pick."));
396 }
2888605c
JH
397
398 memset(&partial, 0, sizeof(partial));
c455c87c 399 partial.strdup_strings = 1;
06bb643b 400 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
2888605c
JH
401 exit(1);
402
403 discard_cache();
404 if (read_cache() < 0)
8a6179bc 405 die(_("cannot read the index"));
2888605c
JH
406
407 fd = hold_locked_index(&index_lock, 1);
408 add_remove_files(&partial);
ef12b50d 409 refresh_cache(REFRESH_QUIET);
4ed7cd3a
BC
410 if (write_cache(fd, active_cache, active_nr) ||
411 close_lock_file(&index_lock))
8a6179bc 412 die(_("unable to write new_index file"));
f5bbc322 413
2888605c 414 fd = hold_lock_file_for_update(&false_lock,
a157400c
JH
415 git_path("next-index-%"PRIuMAX,
416 (uintmax_t) getpid()),
acd3b9ec 417 LOCK_DIE_ON_ERROR);
fa9dcf80 418
06bb643b 419 create_base_index(current_head);
2888605c 420 add_remove_files(&partial);
d37d3203 421 refresh_cache(REFRESH_QUIET);
f5bbc322 422
4ed7cd3a
BC
423 if (write_cache(fd, active_cache, active_nr) ||
424 close_lock_file(&false_lock))
8a6179bc 425 die(_("unable to write temporary index file"));
959ba670
JK
426
427 discard_cache();
428 read_cache_from(false_lock.filename);
429
2888605c 430 return false_lock.filename;
f5bbc322
KH
431}
432
d249b098
JH
433static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
434 struct wt_status *s)
f5bbc322 435{
76e2f7ce
JH
436 unsigned char sha1[20];
437
d249b098
JH
438 if (s->relative_paths)
439 s->prefix = prefix;
f5bbc322
KH
440
441 if (amend) {
d249b098
JH
442 s->amend = 1;
443 s->reference = "HEAD^1";
f5bbc322 444 }
d249b098
JH
445 s->verbose = verbose;
446 s->index_file = index_file;
447 s->fp = fp;
448 s->nowarn = nowarn;
76e2f7ce 449 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
f5bbc322 450
76e2f7ce 451 wt_status_collect(s);
7c9f7038
JK
452
453 switch (status_format) {
454 case STATUS_FORMAT_SHORT:
d4a6bf1f 455 wt_shortstatus_print(s);
7c9f7038
JK
456 break;
457 case STATUS_FORMAT_PORCELAIN:
3207a3a2 458 wt_porcelain_print(s);
7c9f7038 459 break;
f3f47a1e 460 case STATUS_FORMAT_NONE:
7c9f7038
JK
461 case STATUS_FORMAT_LONG:
462 wt_status_print(s);
463 break;
464 }
f5bbc322 465
d249b098 466 return s->commitable;
f5bbc322
KH
467}
468
06bb643b 469static int is_a_merge(const struct commit *current_head)
ec84bd00 470{
06bb643b 471 return !!(current_head->parents && current_head->parents->next);
ec84bd00
PB
472}
473
7dfe8ad6
JH
474static void export_one(const char *var, const char *s, const char *e, int hack)
475{
476 struct strbuf buf = STRBUF_INIT;
477 if (hack)
478 strbuf_addch(&buf, hack);
479 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
480 setenv(var, buf.buf, 1);
481 strbuf_release(&buf);
482}
483
e27ddb64
JH
484static int sane_ident_split(struct ident_split *person)
485{
486 if (!person->name_begin || !person->name_end ||
487 person->name_begin == person->name_end)
488 return 0; /* no human readable name */
489 if (!person->mail_begin || !person->mail_end ||
490 person->mail_begin == person->mail_end)
491 return 0; /* no usable mail */
492 if (!person->date_begin || !person->date_end ||
493 !person->tz_begin || !person->tz_end)
494 return 0;
495 return 1;
496}
497
4c28e4ad 498static void determine_author_info(struct strbuf *author_ident)
a45d46ba
SB
499{
500 char *name, *email, *date;
7dfe8ad6 501 struct ident_split author;
a45d46ba
SB
502
503 name = getenv("GIT_AUTHOR_NAME");
504 email = getenv("GIT_AUTHOR_EMAIL");
505 date = getenv("GIT_AUTHOR_DATE");
506
37f7a857 507 if (author_message) {
a45d46ba 508 const char *a, *lb, *rb, *eol;
2c733fb2 509 size_t len;
a45d46ba 510
37f7a857 511 a = strstr(author_message_buffer, "\nauthor ");
a45d46ba 512 if (!a)
6c80cd29 513 die(_("invalid commit: %s"), author_message);
a45d46ba 514
fb7749e4
JN
515 lb = strchrnul(a + strlen("\nauthor "), '<');
516 rb = strchrnul(lb, '>');
517 eol = strchrnul(rb, '\n');
518 if (!*lb || !*rb || !*eol)
6c80cd29 519 die(_("invalid commit: %s"), author_message);
a45d46ba 520
fb7749e4
JN
521 if (lb == a + strlen("\nauthor "))
522 /* \nauthor <foo@example.com> */
523 name = xcalloc(1, 1);
524 else
525 name = xmemdupz(a + strlen("\nauthor "),
526 (lb - strlen(" ") -
527 (a + strlen("\nauthor "))));
528 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
529 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
2c733fb2
JH
530 len = eol - (rb + strlen("> "));
531 date = xmalloc(len + 2);
532 *date = '@';
533 memcpy(date + 1, rb + strlen("> "), len);
534 date[len + 1] = '\0';
a45d46ba
SB
535 }
536
537 if (force_author) {
538 const char *lb = strstr(force_author, " <");
539 const char *rb = strchr(force_author, '>');
540
541 if (!lb || !rb)
8a6179bc 542 die(_("malformed --author parameter"));
a45d46ba
SB
543 name = xstrndup(force_author, lb - force_author);
544 email = xstrndup(lb + 2, rb - (lb + 2));
545 }
546
02b47cd7
MV
547 if (force_date)
548 date = force_date;
f9bc573f 549 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
e27ddb64
JH
550 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
551 sane_ident_split(&author)) {
7dfe8ad6
JH
552 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
553 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
554 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
555 }
a45d46ba
SB
556}
557
4c28e4ad
JH
558static char *cut_ident_timestamp_part(char *string)
559{
560 char *ket = strrchr(string, '>');
561 if (!ket || ket[1] != ' ')
8a6179bc 562 die(_("Malformed ident string: '%s'"), string);
4c28e4ad
JH
563 *++ket = '\0';
564 return ket;
565}
566
d249b098 567static int prepare_to_commit(const char *index_file, const char *prefix,
06bb643b 568 struct commit *current_head,
4c28e4ad
JH
569 struct wt_status *s,
570 struct strbuf *author_ident)
f5bbc322
KH
571{
572 struct stat statbuf;
4c28e4ad 573 struct strbuf committer_ident = STRBUF_INIT;
bc5d248a 574 int commitable, saved_color_setting;
f285a2d7 575 struct strbuf sb = STRBUF_INIT;
f5bbc322 576 char *buffer;
8089c85b
PB
577 const char *hook_arg1 = NULL;
578 const char *hook_arg2 = NULL;
bb1ae3f6 579 int ident_shown = 0;
8b1ae678 580 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
f5bbc322 581
7dfe8ad6
JH
582 /* This checks and barfs if author is badly specified */
583 determine_author_info(author_ident);
584
ec84bd00
PB
585 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
586 return 0;
f5bbc322 587
89ac1223
PN
588 if (squash_message) {
589 /*
590 * Insert the proper subject line before other commit
591 * message options add their content.
592 */
593 if (use_message && !strcmp(use_message, squash_message))
594 strbuf_addstr(&sb, "squash! ");
595 else {
596 struct pretty_print_context ctx = {0};
597 struct commit *c;
598 c = lookup_commit_reference_by_name(squash_message);
599 if (!c)
8a6179bc 600 die(_("could not lookup commit %s"), squash_message);
89ac1223
PN
601 ctx.output_encoding = get_commit_output_encoding();
602 format_commit_message(c, "squash! %s\n\n", &sb,
603 &ctx);
604 }
605 }
606
f9568530
JS
607 if (message.len) {
608 strbuf_addbuf(&sb, &message);
8089c85b 609 hook_arg1 = "message";
f5bbc322
KH
610 } else if (logfile && !strcmp(logfile, "-")) {
611 if (isatty(0))
8a6179bc 612 fprintf(stderr, _("(reading log message from standard input)\n"));
f5bbc322 613 if (strbuf_read(&sb, 0, 0) < 0)
8a6179bc 614 die_errno(_("could not read log from standard input"));
8089c85b 615 hook_arg1 = "message";
f5bbc322
KH
616 } else if (logfile) {
617 if (strbuf_read_file(&sb, logfile, 0) < 0)
8a6179bc 618 die_errno(_("could not read log file '%s'"),
d824cbba 619 logfile);
8089c85b 620 hook_arg1 = "message";
f5bbc322
KH
621 } else if (use_message) {
622 buffer = strstr(use_message_buffer, "\n\n");
d9a93575 623 if (!use_editor && (!buffer || buffer[2] == '\0'))
8a6179bc 624 die(_("commit has empty message"));
f5bbc322 625 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
8089c85b
PB
626 hook_arg1 = "commit";
627 hook_arg2 = use_message;
d71b8ba7
PN
628 } else if (fixup_message) {
629 struct pretty_print_context ctx = {0};
630 struct commit *commit;
631 commit = lookup_commit_reference_by_name(fixup_message);
632 if (!commit)
8a6179bc 633 die(_("could not lookup commit %s"), fixup_message);
d71b8ba7
PN
634 ctx.output_encoding = get_commit_output_encoding();
635 format_commit_message(commit, "fixup! %s\n\n",
636 &sb, &ctx);
637 hook_arg1 = "message";
f5bbc322
KH
638 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
639 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
8a6179bc 640 die_errno(_("could not read MERGE_MSG"));
8089c85b 641 hook_arg1 = "merge";
f5bbc322
KH
642 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
643 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
8a6179bc 644 die_errno(_("could not read SQUASH_MSG"));
8089c85b 645 hook_arg1 = "squash";
2140b140 646 } else if (template_file) {
f5bbc322 647 if (strbuf_read_file(&sb, template_file, 0) < 0)
8a6179bc 648 die_errno(_("could not read '%s'"), template_file);
8089c85b 649 hook_arg1 = "template";
8b1ae678 650 clean_message_contents = 0;
f5bbc322
KH
651 }
652
8089c85b 653 /*
37f7a857
JS
654 * The remaining cases don't modify the template message, but
655 * just set the argument(s) to the prepare-commit-msg hook.
8089c85b 656 */
37f7a857 657 else if (whence == FROM_MERGE)
8089c85b 658 hook_arg1 = "merge";
37f7a857
JS
659 else if (whence == FROM_CHERRY_PICK) {
660 hook_arg1 = "commit";
661 hook_arg2 = "CHERRY_PICK_HEAD";
662 }
8089c85b 663
89ac1223
PN
664 if (squash_message) {
665 /*
666 * If squash_commit was used for the commit subject,
667 * then we're possibly hijacking other commit log options.
668 * Reset the hook args to tell the real story.
669 */
670 hook_arg1 = "message";
671 hook_arg2 = "";
672 }
673
37f3012f
JN
674 s->fp = fopen(git_path(commit_editmsg), "w");
675 if (s->fp == NULL)
8a6179bc 676 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
f5bbc322 677
8b1ae678 678 if (clean_message_contents)
5f065737 679 stripspace(&sb, 0);
f5bbc322
KH
680
681 if (signoff) {
5ed75e2a
MV
682 /*
683 * See if we have a Conflicts: block at the end. If yes, count
684 * its size, so we can ignore it.
685 */
686 int ignore_footer = 0;
687 int i, eol, previous = 0;
688 const char *nl;
689
690 for (i = 0; i < sb.len; i++) {
691 nl = memchr(sb.buf + i, '\n', sb.len - i);
692 if (nl)
693 eol = nl - sb.buf;
694 else
695 eol = sb.len;
696 if (!prefixcmp(sb.buf + previous, "\nConflicts:\n")) {
697 ignore_footer = sb.len - previous;
698 break;
699 }
700 while (i < eol)
701 i++;
702 previous = eol;
2150554b 703 }
5ed75e2a 704
bab4d109 705 append_signoff(&sb, ignore_footer, 0);
f5bbc322
KH
706 }
707
37f3012f 708 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
8a6179bc 709 die_errno(_("could not write commit template"));
13208572 710
f5bbc322
KH
711 strbuf_release(&sb);
712
bb1ae3f6 713 /* This checks if committer ident is explicitly given */
f20f3878 714 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
bed575e4 715 if (use_editor && include_status) {
4c28e4ad 716 char *ai_tmp, *ci_tmp;
37f7a857 717 if (whence != FROM_COMMIT)
b926c0d1 718 status_printf_ln(s, GIT_COLOR_NORMAL,
b0cea47e
ÆAB
719 whence == FROM_MERGE
720 ? _("\n"
721 "It looks like you may be committing a merge.\n"
722 "If this is not correct, please remove the file\n"
723 " %s\n"
724 "and try again.\n")
725 : _("\n"
726 "It looks like you may be committing a cherry-pick.\n"
727 "If this is not correct, please remove the file\n"
728 " %s\n"
729 "and try again.\n"),
37f7a857
JS
730 git_path(whence == FROM_MERGE
731 ? "MERGE_HEAD"
732 : "CHERRY_PICK_HEAD"));
ec84bd00 733
b926c0d1 734 fprintf(s->fp, "\n");
ec84bd00 735 if (cleanup_mode == CLEANUP_ALL)
4064e665
ÆAB
736 status_printf(s, GIT_COLOR_NORMAL,
737 _("Please enter the commit message for your changes."
eff80a9f
JH
738 " Lines starting\nwith '%c' will be ignored, and an empty"
739 " message aborts the commit.\n"), comment_line_char);
ec84bd00 740 else /* CLEANUP_SPACE, that is. */
4064e665
ÆAB
741 status_printf(s, GIT_COLOR_NORMAL,
742 _("Please enter the commit message for your changes."
eff80a9f
JH
743 " Lines starting\n"
744 "with '%c' will be kept; you may remove them"
745 " yourself if you want to.\n"
746 "An empty message aborts the commit.\n"), comment_line_char);
ec84bd00 747 if (only_include_assumed)
b926c0d1
JN
748 status_printf_ln(s, GIT_COLOR_NORMAL,
749 "%s", only_include_assumed);
ec84bd00 750
4c28e4ad
JH
751 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
752 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
753 if (strcmp(author_ident->buf, committer_ident.buf))
b926c0d1 754 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd
ÆAB
755 _("%s"
756 "Author: %s"),
b926c0d1 757 ident_shown++ ? "" : "\n",
4c28e4ad 758 author_ident->buf);
e83dbe80 759
d6991cee 760 if (!committer_ident_sufficiently_given())
b926c0d1 761 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd
ÆAB
762 _("%s"
763 "Committer: %s"),
b926c0d1 764 ident_shown++ ? "" : "\n",
4c28e4ad 765 committer_ident.buf);
bb1ae3f6
SB
766
767 if (ident_shown)
b926c0d1 768 status_printf_ln(s, GIT_COLOR_NORMAL, "");
bb1ae3f6 769
d249b098
JH
770 saved_color_setting = s->use_color;
771 s->use_color = 0;
37f3012f 772 commitable = run_status(s->fp, index_file, prefix, 1, s);
d249b098 773 s->use_color = saved_color_setting;
4c28e4ad
JH
774
775 *ai_tmp = ' ';
776 *ci_tmp = ' ';
ec84bd00 777 } else {
d616a239 778 unsigned char sha1[20];
fbcf1184 779 const char *parent = "HEAD";
7168624c 780
7168624c 781 if (!active_nr && read_cache() < 0)
8a6179bc 782 die(_("Cannot read index"));
7168624c 783
fbcf1184
JH
784 if (amend)
785 parent = "HEAD^1";
786
d616a239 787 if (get_sha1(parent, sha1))
ec84bd00 788 commitable = !!active_nr;
75f3ff2e
SB
789 else
790 commitable = index_differs_from(parent, 0);
ec84bd00 791 }
4c28e4ad 792 strbuf_release(&committer_ident);
d616a239 793
37f3012f 794 fclose(s->fp);
7168624c 795
37f7a857
JS
796 /*
797 * Reject an attempt to record a non-merge empty commit without
798 * explicit --allow-empty. In the cherry-pick case, it may be
799 * empty due to conflict resolution, which the user should okay.
800 */
801 if (!commitable && whence != FROM_MERGE && !allow_empty &&
06bb643b 802 !(amend && is_a_merge(current_head))) {
d249b098 803 run_status(stdout, index_file, prefix, 0, s);
f197ed2f 804 if (amend)
fc88e316 805 fputs(_(empty_amend_advice), stderr);
37f7a857 806 else if (whence == FROM_CHERRY_PICK)
6c80cd29 807 fputs(_(empty_cherry_pick_advice), stderr);
ec84bd00 808 return 0;
7168624c
AR
809 }
810
ec84bd00
PB
811 /*
812 * Re-read the index as pre-commit hook could have updated it,
813 * and write it out as a tree. We must do this before we invoke
814 * the editor and after we invoke run_status above.
815 */
816 discard_cache();
817 read_cache_from(index_file);
996277c5 818 if (update_main_cache_tree(0)) {
8a6179bc 819 error(_("Error building trees"));
ec84bd00 820 return 0;
7168624c 821 }
f5bbc322 822
8089c85b
PB
823 if (run_hook(index_file, "prepare-commit-msg",
824 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
825 return 0;
f5bbc322 826
ec84bd00
PB
827 if (use_editor) {
828 char index[PATH_MAX];
66dbfd55
GV
829 const char *env[2] = { NULL };
830 env[0] = index;
ec84bd00 831 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
7198203a
SB
832 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
833 fprintf(stderr,
8a6179bc 834 _("Please supply the message using either -m or -F option.\n"));
7198203a
SB
835 exit(1);
836 }
ec84bd00 837 }
f5bbc322 838
ec84bd00
PB
839 if (!no_verify &&
840 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
841 return 0;
842 }
f5bbc322 843
ec84bd00 844 return 1;
f5bbc322
KH
845}
846
b2eda9bd 847static int rest_is_empty(struct strbuf *sb, int start)
f5bbc322 848{
b2eda9bd 849 int i, eol;
f5bbc322 850 const char *nl;
f5bbc322
KH
851
852 /* Check if the rest is just whitespace and Signed-of-by's. */
853 for (i = start; i < sb->len; i++) {
854 nl = memchr(sb->buf + i, '\n', sb->len - i);
855 if (nl)
856 eol = nl - sb->buf;
857 else
858 eol = sb->len;
859
860 if (strlen(sign_off_header) <= eol - i &&
861 !prefixcmp(sb->buf + i, sign_off_header)) {
862 i = eol;
863 continue;
864 }
865 while (i < eol)
866 if (!isspace(sb->buf[i++]))
867 return 0;
868 }
869
870 return 1;
871}
872
b2eda9bd
JH
873/*
874 * Find out if the message in the strbuf contains only whitespace and
875 * Signed-off-by lines.
876 */
877static int message_is_empty(struct strbuf *sb)
878{
879 if (cleanup_mode == CLEANUP_NONE && sb->len)
880 return 0;
881 return rest_is_empty(sb, 0);
882}
883
884/*
885 * See if the user edited the message in the editor or left what
886 * was in the template intact
887 */
888static int template_untouched(struct strbuf *sb)
889{
890 struct strbuf tmpl = STRBUF_INIT;
891 char *start;
892
893 if (cleanup_mode == CLEANUP_NONE && sb->len)
894 return 0;
895
896 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
897 return 0;
898
899 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
900 start = (char *)skip_prefix(sb->buf, tmpl.buf);
901 if (!start)
902 start = sb->buf;
903 strbuf_release(&tmpl);
904 return rest_is_empty(sb, start - sb->buf);
905}
906
146ea068
JH
907static const char *find_author_by_nickname(const char *name)
908{
909 struct rev_info revs;
910 struct commit *commit;
911 struct strbuf buf = STRBUF_INIT;
912 const char *av[20];
913 int ac = 0;
914
915 init_revisions(&revs, NULL);
916 strbuf_addf(&buf, "--author=%s", name);
917 av[++ac] = "--all";
918 av[++ac] = "-i";
919 av[++ac] = buf.buf;
920 av[++ac] = NULL;
921 setup_revisions(ac, av, &revs, NULL);
922 prepare_revision_walk(&revs);
923 commit = get_revision(&revs);
924 if (commit) {
dd2e794a
TR
925 struct pretty_print_context ctx = {0};
926 ctx.date_mode = DATE_NORMAL;
146ea068 927 strbuf_release(&buf);
dd2e794a 928 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
146ea068
JH
929 return strbuf_detach(&buf, NULL);
930 }
8a6179bc 931 die(_("No existing author found with '%s'"), name);
146ea068
JH
932}
933
76e2f7ce
JH
934
935static void handle_untracked_files_arg(struct wt_status *s)
936{
937 if (!untracked_files_arg)
938 ; /* default already initialized */
939 else if (!strcmp(untracked_files_arg, "no"))
940 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
941 else if (!strcmp(untracked_files_arg, "normal"))
942 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
943 else if (!strcmp(untracked_files_arg, "all"))
944 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
945 else
8a6179bc 946 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
76e2f7ce
JH
947}
948
37f7a857
JS
949static const char *read_commit_message(const char *name)
950{
dd0d388c 951 const char *out_enc;
37f7a857
JS
952 struct commit *commit;
953
954 commit = lookup_commit_reference_by_name(name);
955 if (!commit)
6c80cd29 956 die(_("could not lookup commit %s"), name);
37f7a857 957 out_enc = get_commit_output_encoding();
5a10d236 958 return logmsg_reencode(commit, NULL, out_enc);
37f7a857
JS
959}
960
2f02b25f 961static int parse_and_validate_options(int argc, const char *argv[],
036dbbfb 962 const struct option *options,
dbd0f5c7 963 const char * const usage[],
d249b098 964 const char *prefix,
06bb643b 965 struct commit *current_head,
d249b098 966 struct wt_status *s)
f5bbc322
KH
967{
968 int f = 0;
969
036dbbfb 970 argc = parse_options(argc, argv, prefix, options, usage, 0);
f5bbc322 971
146ea068
JH
972 if (force_author && !strchr(force_author, '>'))
973 force_author = find_author_by_nickname(force_author);
974
c51f6cee 975 if (force_author && renew_authorship)
8a6179bc 976 die(_("Using both --reset-author and --author does not make sense"));
c51f6cee 977
d71b8ba7 978 if (logfile || message.len || use_message || fixup_message)
4803466f 979 use_editor = 0;
ca1ba201
JH
980 if (0 <= edit_flag)
981 use_editor = edit_flag;
406400ce
PB
982 if (!use_editor)
983 setenv("GIT_EDITOR", ":", 1);
f5bbc322 984
f5bbc322 985 /* Sanity check options */
06bb643b 986 if (amend && !current_head)
8a6179bc 987 die(_("You have nothing to amend."));
b0cea47e
ÆAB
988 if (amend && whence != FROM_COMMIT) {
989 if (whence == FROM_MERGE)
990 die(_("You are in the middle of a merge -- cannot amend."));
991 else if (whence == FROM_CHERRY_PICK)
992 die(_("You are in the middle of a cherry-pick -- cannot amend."));
993 }
89ac1223 994 if (fixup_message && squash_message)
9c227655 995 die(_("Options --squash and --fixup cannot be used together"));
f5bbc322
KH
996 if (use_message)
997 f++;
998 if (edit_message)
999 f++;
d71b8ba7
PN
1000 if (fixup_message)
1001 f++;
f5bbc322
KH
1002 if (logfile)
1003 f++;
1004 if (f > 1)
8a6179bc 1005 die(_("Only one of -c/-C/-F/--fixup can be used."));
f9568530 1006 if (message.len && f > 0)
8a6179bc 1007 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
010c7dbc
JH
1008 if (f || message.len)
1009 template_file = NULL;
f5bbc322
KH
1010 if (edit_message)
1011 use_message = edit_message;
d71b8ba7 1012 if (amend && !use_message && !fixup_message)
f5bbc322 1013 use_message = "HEAD";
37f7a857 1014 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
8a6179bc 1015 die(_("--reset-author can be used only with -C, -c or --amend."));
f5bbc322 1016 if (use_message) {
37f7a857
JS
1017 use_message_buffer = read_commit_message(use_message);
1018 if (!renew_authorship) {
1019 author_message = use_message;
1020 author_message_buffer = use_message_buffer;
1021 }
1022 }
1023 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1024 author_message = "CHERRY_PICK_HEAD";
1025 author_message_buffer = read_commit_message(author_message);
f5bbc322
KH
1026 }
1027
b4bd4668
CI
1028 if (patch_interactive)
1029 interactive = 1;
1030
f5bbc322 1031 if (!!also + !!only + !!all + !!interactive > 1)
b4bd4668 1032 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
f5bbc322 1033 if (argc == 0 && (also || (only && !amend)))
8a6179bc 1034 die(_("No paths with --include/--only does not make sense."));
f5bbc322 1035 if (argc == 0 && only && amend)
8a6179bc 1036 only_include_assumed = _("Clever... amending the last one with dirty index.");
3c5283f8 1037 if (argc > 0 && !also && !only)
8a6179bc 1038 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
5f065737
AR
1039 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1040 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1041 else if (!strcmp(cleanup_arg, "verbatim"))
1042 cleanup_mode = CLEANUP_NONE;
1043 else if (!strcmp(cleanup_arg, "whitespace"))
1044 cleanup_mode = CLEANUP_SPACE;
1045 else if (!strcmp(cleanup_arg, "strip"))
1046 cleanup_mode = CLEANUP_ALL;
1047 else
8a6179bc 1048 die(_("Invalid cleanup mode %s"), cleanup_arg);
f5bbc322 1049
76e2f7ce 1050 handle_untracked_files_arg(s);
4bfee30a 1051
f5bbc322 1052 if (all && argc > 0)
8a6179bc 1053 die(_("Paths with -a does not make sense."));
f5bbc322 1054
f3f47a1e
JK
1055 if (s->null_termination) {
1056 if (status_format == STATUS_FORMAT_NONE)
1057 status_format = STATUS_FORMAT_PORCELAIN;
1058 else if (status_format == STATUS_FORMAT_LONG)
1059 die(_("--long and -z are incompatible"));
1060 }
1061 if (status_format != STATUS_FORMAT_NONE)
7c9f7038
JK
1062 dry_run = 1;
1063
f5bbc322
KH
1064 return argc;
1065}
1066
d249b098 1067static int dry_run_commit(int argc, const char **argv, const char *prefix,
06bb643b 1068 const struct commit *current_head, struct wt_status *s)
f5bbc322 1069{
f5bbc322 1070 int commitable;
3a5d13a3 1071 const char *index_file;
f5bbc322 1072
06bb643b 1073 index_file = prepare_index(argc, argv, prefix, current_head, 1);
d249b098 1074 commitable = run_status(stdout, index_file, prefix, 0, s);
3a5d13a3 1075 rollback_index_files();
f5bbc322 1076
3a5d13a3
JH
1077 return commitable ? 0 : 1;
1078}
1079
f766b367
JH
1080static int parse_status_slot(const char *var, int offset)
1081{
1082 if (!strcasecmp(var+offset, "header"))
1083 return WT_STATUS_HEADER;
1d282327
AA
1084 if (!strcasecmp(var+offset, "branch"))
1085 return WT_STATUS_ONBRANCH;
f766b367
JH
1086 if (!strcasecmp(var+offset, "updated")
1087 || !strcasecmp(var+offset, "added"))
1088 return WT_STATUS_UPDATED;
1089 if (!strcasecmp(var+offset, "changed"))
1090 return WT_STATUS_CHANGED;
1091 if (!strcasecmp(var+offset, "untracked"))
1092 return WT_STATUS_UNTRACKED;
1093 if (!strcasecmp(var+offset, "nobranch"))
1094 return WT_STATUS_NOBRANCH;
1095 if (!strcasecmp(var+offset, "unmerged"))
1096 return WT_STATUS_UNMERGED;
8b8e8624 1097 return -1;
f766b367
JH
1098}
1099
1100static int git_status_config(const char *k, const char *v, void *cb)
1101{
1102 struct wt_status *s = cb;
1103
323d0530 1104 if (!prefixcmp(k, "column."))
4d2292e9 1105 return git_column_config(k, v, "status", &s->colopts);
f766b367
JH
1106 if (!strcmp(k, "status.submodulesummary")) {
1107 int is_bool;
1108 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1109 if (is_bool && s->submodule_summary)
1110 s->submodule_summary = -1;
1111 return 0;
1112 }
4fb5166a
JJGG
1113 if (!strcmp(k, "status.short")) {
1114 if (git_config_bool(k, v))
1115 status_format = STATUS_FORMAT_SHORT;
1116 else
1117 status_format = STATUS_FORMAT_NONE;
1118 return 0;
1119 }
ec85d070
JJGG
1120 if (!strcmp(k, "status.branch")) {
1121 s->show_branch = git_config_bool(k, v);
1122 return 0;
1123 }
f766b367 1124 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
e269eb79 1125 s->use_color = git_config_colorbool(k, v);
f766b367
JH
1126 return 0;
1127 }
1128 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1129 int slot = parse_status_slot(k, 13);
8b8e8624
JK
1130 if (slot < 0)
1131 return 0;
f766b367
JH
1132 if (!v)
1133 return config_error_nonbool(k);
1134 color_parse(v, k, s->color_palette[slot]);
1135 return 0;
1136 }
1137 if (!strcmp(k, "status.relativepaths")) {
1138 s->relative_paths = git_config_bool(k, v);
1139 return 0;
1140 }
1141 if (!strcmp(k, "status.showuntrackedfiles")) {
1142 if (!v)
1143 return config_error_nonbool(k);
1144 else if (!strcmp(v, "no"))
1145 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1146 else if (!strcmp(v, "normal"))
1147 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1148 else if (!strcmp(v, "all"))
1149 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1150 else
8a6179bc 1151 return error(_("Invalid untracked files mode '%s'"), v);
f766b367
JH
1152 return 0;
1153 }
1154 return git_diff_ui_config(k, v, NULL);
1155}
1156
3a5d13a3
JH
1157int cmd_status(int argc, const char **argv, const char *prefix)
1158{
036dbbfb 1159 static struct wt_status s;
4bb6644d 1160 int fd;
76e2f7ce 1161 unsigned char sha1[20];
9e4b7ab6 1162 static struct option builtin_status_options[] = {
f2276316 1163 OPT__VERBOSE(&verbose, N_("be verbose")),
dd2be243 1164 OPT_SET_INT('s', "short", &status_format,
f2276316 1165 N_("show status concisely"), STATUS_FORMAT_SHORT),
d4a6bf1f 1166 OPT_BOOLEAN('b', "branch", &s.show_branch,
f2276316 1167 N_("show branch information")),
6f157871 1168 OPT_SET_INT(0, "porcelain", &status_format,
f2276316 1169 N_("machine-readable output"),
6f157871 1170 STATUS_FORMAT_PORCELAIN),
f3f47a1e
JK
1171 OPT_SET_INT(0, "long", &status_format,
1172 N_("show status in long format (default)"),
1173 STATUS_FORMAT_LONG),
3207a3a2 1174 OPT_BOOLEAN('z', "null", &s.null_termination,
f2276316 1175 N_("terminate entries with NUL")),
76e2f7ce 1176 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
f2276316
NTND
1177 N_("mode"),
1178 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
76e2f7ce 1179 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
2381e39e 1180 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
f2276316
NTND
1181 N_("show ignored files")),
1182 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1183 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
46a958b3 1184 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
9c23f4c5 1185 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
76e2f7ce
JH
1186 OPT_END(),
1187 };
1188
5d3dd915
NTND
1189 if (argc == 2 && !strcmp(argv[1], "-h"))
1190 usage_with_options(builtin_status_usage, builtin_status_options);
1191
d249b098 1192 wt_status_prepare(&s);
302ad7a9 1193 gitmodules_config();
d249b098 1194 git_config(git_status_config, &s);
37f7a857 1195 determine_whence(&s);
76e2f7ce 1196 argc = parse_options(argc, argv, prefix,
9e4b7ab6
JH
1197 builtin_status_options,
1198 builtin_status_usage, 0);
4d2292e9 1199 finalize_colopts(&s.colopts, -1);
000f97bd 1200
f3f47a1e
JK
1201 if (s.null_termination) {
1202 if (status_format == STATUS_FORMAT_NONE)
1203 status_format = STATUS_FORMAT_PORCELAIN;
1204 else if (status_format == STATUS_FORMAT_LONG)
1205 die(_("--long and -z are incompatible"));
1206 }
000f97bd 1207
76e2f7ce 1208 handle_untracked_files_arg(&s);
2381e39e
JH
1209 if (show_ignored_in_status)
1210 s.show_ignored_files = 1;
76e2f7ce
JH
1211 if (*argv)
1212 s.pathspec = get_pathspec(prefix, argv);
1213
149794dd 1214 read_cache_preload(s.pathspec);
688cd6d2 1215 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
4bb6644d
MH
1216
1217 fd = hold_locked_index(&index_lock, 0);
ccdc4ec3
JH
1218 if (0 <= fd)
1219 update_index_if_able(&the_index, &index_lock);
4bb6644d 1220
76e2f7ce 1221 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
46a958b3 1222 s.ignore_submodule_arg = ignore_submodule_arg;
76e2f7ce
JH
1223 wt_status_collect(&s);
1224
8661768f
JK
1225 if (s.relative_paths)
1226 s.prefix = prefix;
38920dd6 1227
dd2be243
JK
1228 switch (status_format) {
1229 case STATUS_FORMAT_SHORT:
d4a6bf1f 1230 wt_shortstatus_print(&s);
dd2be243 1231 break;
6f157871 1232 case STATUS_FORMAT_PORCELAIN:
3207a3a2 1233 wt_porcelain_print(&s);
6f157871 1234 break;
f3f47a1e 1235 case STATUS_FORMAT_NONE:
dd2be243 1236 case STATUS_FORMAT_LONG:
173e6c88 1237 s.verbose = verbose;
46a958b3 1238 s.ignore_submodule_arg = ignore_submodule_arg;
173e6c88 1239 wt_status_print(&s);
dd2be243 1240 break;
173e6c88 1241 }
76e2f7ce 1242 return 0;
f5bbc322
KH
1243}
1244
06bb643b
JH
1245static void print_summary(const char *prefix, const unsigned char *sha1,
1246 int initial_commit)
f5bbc322
KH
1247{
1248 struct rev_info rev;
1249 struct commit *commit;
49ff9a7a 1250 struct strbuf format = STRBUF_INIT;
c85db254 1251 unsigned char junk_sha1[20];
d5a35c11 1252 const char *head;
49ff9a7a
JK
1253 struct pretty_print_context pctx = {0};
1254 struct strbuf author_ident = STRBUF_INIT;
1255 struct strbuf committer_ident = STRBUF_INIT;
f5bbc322
KH
1256
1257 commit = lookup_commit(sha1);
1258 if (!commit)
8a6179bc 1259 die(_("couldn't look up newly created commit"));
f5bbc322 1260 if (!commit || parse_commit(commit))
8a6179bc 1261 die(_("could not parse newly created commit"));
f5bbc322 1262
49ff9a7a
JK
1263 strbuf_addstr(&format, "format:%h] %s");
1264
1265 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1266 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1267 if (strbuf_cmp(&author_ident, &committer_ident)) {
1268 strbuf_addstr(&format, "\n Author: ");
1269 strbuf_addbuf_percentquote(&format, &author_ident);
1270 }
d6991cee 1271 if (!committer_ident_sufficiently_given()) {
49ff9a7a
JK
1272 strbuf_addstr(&format, "\n Committer: ");
1273 strbuf_addbuf_percentquote(&format, &committer_ident);
b706fcfe
JK
1274 if (advice_implicit_identity) {
1275 strbuf_addch(&format, '\n');
fc88e316 1276 strbuf_addstr(&format, _(implicit_ident_advice));
b706fcfe 1277 }
49ff9a7a
JK
1278 }
1279 strbuf_release(&author_ident);
1280 strbuf_release(&committer_ident);
1281
f5bbc322
KH
1282 init_revisions(&rev, prefix);
1283 setup_revisions(0, NULL, &rev, NULL);
1284
f5bbc322
KH
1285 rev.diff = 1;
1286 rev.diffopt.output_format =
1287 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1288
1289 rev.verbose_header = 1;
1290 rev.show_root_diff = 1;
49ff9a7a 1291 get_commit_format(format.buf, &rev);
bf82a150 1292 rev.always_show_header = 0;
3eb2a15e 1293 rev.diffopt.detect_rename = 1;
3eb2a15e 1294 rev.diffopt.break_opt = 0;
15964563 1295 diff_setup_done(&rev.diffopt);
f5bbc322 1296
8cad4744 1297 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
c5ee71fd 1298 printf("[%s%s ",
c85db254
JK
1299 !prefixcmp(head, "refs/heads/") ?
1300 head + 11 :
1301 !strcmp(head, "HEAD") ?
7f5673d7 1302 _("detached HEAD") :
c85db254 1303 head,
7f5673d7 1304 initial_commit ? _(" (root-commit)") : "");
f5bbc322 1305
bf82a150 1306 if (!log_tree_commit(&rev, commit)) {
a45e1a87
TRC
1307 rev.always_show_header = 1;
1308 rev.use_terminator = 1;
1309 log_tree_commit(&rev, commit);
bf82a150 1310 }
a45e1a87 1311
fc6f19fe 1312 strbuf_release(&format);
f5bbc322
KH
1313}
1314
186458b1 1315static int git_commit_config(const char *k, const char *v, void *cb)
f5bbc322 1316{
d249b098 1317 struct wt_status *s = cb;
ba3c69a9 1318 int status;
d249b098 1319
984c6e7e 1320 if (!strcmp(k, "commit.template"))
395de250 1321 return git_config_pathname(&template_file, k, v);
bed575e4
JHI
1322 if (!strcmp(k, "commit.status")) {
1323 include_status = git_config_bool(k, v);
1324 return 0;
1325 }
51fb3a3d
RT
1326 if (!strcmp(k, "commit.cleanup"))
1327 return git_config_string(&cleanup_arg, k, v);
f5bbc322 1328
ba3c69a9
JH
1329 status = git_gpg_config(k, v, NULL);
1330 if (status)
1331 return status;
d249b098 1332 return git_status_config(k, v, s);
f5bbc322
KH
1333}
1334
6f6bee3b
TR
1335static int run_rewrite_hook(const unsigned char *oldsha1,
1336 const unsigned char *newsha1)
1337{
1338 /* oldsha1 SP newsha1 LF NUL */
1339 static char buf[2*40 + 3];
1340 struct child_process proc;
1341 const char *argv[3];
1342 int code;
1343 size_t n;
1344
5a7da2dc
AS
1345 argv[0] = find_hook("post-rewrite");
1346 if (!argv[0])
6f6bee3b
TR
1347 return 0;
1348
6f6bee3b
TR
1349 argv[1] = "amend";
1350 argv[2] = NULL;
1351
1352 memset(&proc, 0, sizeof(proc));
1353 proc.argv = argv;
1354 proc.in = -1;
1355 proc.stdout_to_stderr = 1;
1356
1357 code = start_command(&proc);
1358 if (code)
1359 return code;
1360 n = snprintf(buf, sizeof(buf), "%s %s\n",
1361 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1362 write_in_full(proc.in, buf, n);
1363 close(proc.in);
1364 return finish_command(&proc);
1365}
1366
f5bbc322
KH
1367int cmd_commit(int argc, const char **argv, const char *prefix)
1368{
036dbbfb
JK
1369 static struct wt_status s;
1370 static struct option builtin_commit_options[] = {
9c23f4c5
NTND
1371 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1372 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1373
1374 OPT_GROUP(N_("Commit message options")),
1375 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1376 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1377 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1378 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1379 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1380 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1381 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1382 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1383 OPT_BOOLEAN(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1384 OPT_BOOLEAN('s', "signoff", &signoff, N_("add Signed-off-by:")),
1385 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1386 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1387 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1388 OPT_BOOLEAN(0, "status", &include_status, N_("include status in commit message template")),
1389 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1390 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
036dbbfb
JK
1391 /* end commit message options */
1392
9c23f4c5
NTND
1393 OPT_GROUP(N_("Commit contents options")),
1394 OPT_BOOLEAN('a', "all", &all, N_("commit all changed files")),
1395 OPT_BOOLEAN('i', "include", &also, N_("add specified files to index for commit")),
1396 OPT_BOOLEAN(0, "interactive", &interactive, N_("interactively add files")),
1397 OPT_BOOLEAN('p', "patch", &patch_interactive, N_("interactively add changes")),
1398 OPT_BOOLEAN('o', "only", &only, N_("commit only specified files")),
1399 OPT_BOOLEAN('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1400 OPT_BOOLEAN(0, "dry-run", &dry_run, N_("show what would be committed")),
1401 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
036dbbfb 1402 STATUS_FORMAT_SHORT),
9c23f4c5 1403 OPT_BOOLEAN(0, "branch", &s.show_branch, N_("show branch information")),
036dbbfb 1404 OPT_SET_INT(0, "porcelain", &status_format,
9c23f4c5 1405 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
f3f47a1e
JK
1406 OPT_SET_INT(0, "long", &status_format,
1407 N_("show status in long format (default)"),
1408 STATUS_FORMAT_LONG),
3207a3a2 1409 OPT_BOOLEAN('z', "null", &s.null_termination,
9c23f4c5
NTND
1410 N_("terminate entries with NUL")),
1411 OPT_BOOLEAN(0, "amend", &amend, N_("amend previous commit")),
1412 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1413 { 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
1414 /* end commit contents options */
1415
1416 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
9c23f4c5 1417 N_("ok to record an empty change"),
036dbbfb
JK
1418 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1419 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
9c23f4c5 1420 N_("ok to record a change with an empty message"),
036dbbfb
JK
1421 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1422
1423 OPT_END()
1424 };
1425
f285a2d7 1426 struct strbuf sb = STRBUF_INIT;
4c28e4ad 1427 struct strbuf author_ident = STRBUF_INIT;
f5bbc322 1428 const char *index_file, *reflog_msg;
99a12694 1429 char *nl, *p;
06bb643b 1430 unsigned char sha1[20];
f5bbc322 1431 struct ref_lock *ref_lock;
6bb6b034 1432 struct commit_list *parents = NULL, **pptr = &parents;
cf10f9fd
MV
1433 struct stat statbuf;
1434 int allow_fast_forward = 1;
06bb643b 1435 struct commit *current_head = NULL;
ed7a42a0 1436 struct commit_extra_header *extra = NULL;
f5bbc322 1437
5d3dd915
NTND
1438 if (argc == 2 && !strcmp(argv[1], "-h"))
1439 usage_with_options(builtin_commit_usage, builtin_commit_options);
1440
d249b098 1441 wt_status_prepare(&s);
8f6811ef 1442 gitmodules_config();
d249b098 1443 git_config(git_commit_config, &s);
f0915cba 1444 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
37f7a857 1445 determine_whence(&s);
4d2292e9 1446 s.colopts = 0;
f5bbc322 1447
06bb643b
JH
1448 if (get_sha1("HEAD", sha1))
1449 current_head = NULL;
1450 else {
baf18fc2 1451 current_head = lookup_commit_or_die(sha1, "HEAD");
06bb643b
JH
1452 if (!current_head || parse_commit(current_head))
1453 die(_("could not parse HEAD commit"));
1454 }
036dbbfb
JK
1455 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1456 builtin_commit_usage,
06bb643b 1457 prefix, current_head, &s);
c9bfb953 1458 if (dry_run)
06bb643b 1459 return dry_run_commit(argc, argv, prefix, current_head, &s);
06bb643b 1460 index_file = prepare_index(argc, argv, prefix, current_head, 0);
f5bbc322 1461
ec84bd00
PB
1462 /* Set up everything for writing the commit object. This includes
1463 running hooks, writing the trees, and interacting with the user. */
06bb643b
JH
1464 if (!prepare_to_commit(index_file, prefix,
1465 current_head, &s, &author_ident)) {
2888605c 1466 rollback_index_files();
f5bbc322
KH
1467 return 1;
1468 }
1469
f5bbc322 1470 /* Determine parents */
643cb5f7 1471 reflog_msg = getenv("GIT_REFLOG_ACTION");
06bb643b 1472 if (!current_head) {
643cb5f7
CC
1473 if (!reflog_msg)
1474 reflog_msg = "commit (initial)";
f5bbc322
KH
1475 } else if (amend) {
1476 struct commit_list *c;
f5bbc322 1477
643cb5f7
CC
1478 if (!reflog_msg)
1479 reflog_msg = "commit (amend)";
06bb643b 1480 for (c = current_head->parents; c; c = c->next)
6bb6b034 1481 pptr = &commit_list_insert(c->item, pptr)->next;
37f7a857 1482 } else if (whence == FROM_MERGE) {
f285a2d7 1483 struct strbuf m = STRBUF_INIT;
f5bbc322
KH
1484 FILE *fp;
1485
643cb5f7
CC
1486 if (!reflog_msg)
1487 reflog_msg = "commit (merge)";
06bb643b 1488 pptr = &commit_list_insert(current_head, pptr)->next;
f5bbc322
KH
1489 fp = fopen(git_path("MERGE_HEAD"), "r");
1490 if (fp == NULL)
8a6179bc 1491 die_errno(_("could not open '%s' for reading"),
d824cbba 1492 git_path("MERGE_HEAD"));
7c3fd25d 1493 while (strbuf_getline(&m, fp, '\n') != EOF) {
5231c633
JH
1494 struct commit *parent;
1495
1496 parent = get_merge_parent(m.buf);
1497 if (!parent)
8a6179bc 1498 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
5231c633 1499 pptr = &commit_list_insert(parent, pptr)->next;
7c3fd25d 1500 }
f5bbc322
KH
1501 fclose(fp);
1502 strbuf_release(&m);
cf10f9fd
MV
1503 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1504 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
8a6179bc 1505 die_errno(_("could not read MERGE_MODE"));
cf10f9fd
MV
1506 if (!strcmp(sb.buf, "no-ff"))
1507 allow_fast_forward = 0;
1508 }
1509 if (allow_fast_forward)
1510 parents = reduce_heads(parents);
f5bbc322 1511 } else {
643cb5f7 1512 if (!reflog_msg)
37f7a857
JS
1513 reflog_msg = (whence == FROM_CHERRY_PICK)
1514 ? "commit (cherry-pick)"
1515 : "commit";
06bb643b 1516 pptr = &commit_list_insert(current_head, pptr)->next;
f5bbc322 1517 }
f5bbc322 1518
ec84bd00 1519 /* Finally, get the commit message */
cf10f9fd 1520 strbuf_reset(&sb);
740001a5 1521 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
0721c314 1522 int saved_errno = errno;
740001a5 1523 rollback_index_files();
8a6179bc 1524 die(_("could not read commit message: %s"), strerror(saved_errno));
740001a5 1525 }
99a12694
KH
1526
1527 /* Truncate the message just before the diff, if any. */
0b38227f
JK
1528 if (verbose) {
1529 p = strstr(sb.buf, "\ndiff --git ");
1530 if (p != NULL)
1531 strbuf_setlen(&sb, p - sb.buf + 1);
1532 }
99a12694 1533
5f065737
AR
1534 if (cleanup_mode != CLEANUP_NONE)
1535 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
b2eda9bd
JH
1536 if (template_untouched(&sb) && !allow_empty_message) {
1537 rollback_index_files();
1538 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1539 exit(1);
1540 }
c9b5fde7 1541 if (message_is_empty(&sb) && !allow_empty_message) {
2888605c 1542 rollback_index_files();
8a6179bc 1543 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
fdc7c811 1544 exit(1);
2888605c 1545 }
f5bbc322 1546
0074d18d 1547 if (amend) {
c871a1d1
JH
1548 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1549 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
0074d18d
JH
1550 } else {
1551 struct commit_extra_header **tail = &extra;
1552 append_merge_tag_headers(parents, &tail);
1553 }
ed7a42a0 1554
f35ccd9b 1555 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
ba3c69a9 1556 author_ident.buf, sign_commit, extra)) {
2888605c 1557 rollback_index_files();
8a6179bc 1558 die(_("failed to write commit object"));
2888605c 1559 }
4c28e4ad 1560 strbuf_release(&author_ident);
ed7a42a0 1561 free_commit_extra_headers(extra);
f5bbc322
KH
1562
1563 ref_lock = lock_any_ref_for_update("HEAD",
06bb643b
JH
1564 !current_head
1565 ? NULL
1566 : current_head->object.sha1,
f5bbc322
KH
1567 0);
1568
6bb6b034 1569 nl = strchr(sb.buf, '\n');
741707b1
JS
1570 if (nl)
1571 strbuf_setlen(&sb, nl + 1 - sb.buf);
1572 else
1573 strbuf_addch(&sb, '\n');
741707b1
JS
1574 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1575 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
f5bbc322 1576
2888605c
JH
1577 if (!ref_lock) {
1578 rollback_index_files();
8a6179bc 1579 die(_("cannot lock HEAD ref"));
2888605c 1580 }
06bb643b 1581 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
2888605c 1582 rollback_index_files();
8a6179bc 1583 die(_("cannot update HEAD ref"));
2888605c 1584 }
f5bbc322 1585
d7e5c0cb 1586 unlink(git_path("CHERRY_PICK_HEAD"));
82433cdf 1587 unlink(git_path("REVERT_HEAD"));
f5bbc322
KH
1588 unlink(git_path("MERGE_HEAD"));
1589 unlink(git_path("MERGE_MSG"));
cf10f9fd 1590 unlink(git_path("MERGE_MODE"));
5a95b855 1591 unlink(git_path("SQUASH_MSG"));
f5bbc322 1592
5a9dd399 1593 if (commit_index_files())
8a6179bc 1594 die (_("Repository has been updated, but unable to write\n"
5a9dd399 1595 "new_index file. Check that disk is not full or quota is\n"
8a6179bc 1596 "not exceeded, and then \"git reset HEAD\" to recover."));
f5bbc322 1597
cb6020bb 1598 rerere(0);
2888605c 1599 run_hook(get_index_file(), "post-commit", NULL);
6f6bee3b 1600 if (amend && !no_post_rewrite) {
6360d343
TR
1601 struct notes_rewrite_cfg *cfg;
1602 cfg = init_copy_notes_for_rewrite("amend");
1603 if (cfg) {
06bb643b
JH
1604 /* we are amending, so current_head is not NULL */
1605 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
6360d343
TR
1606 finish_copy_notes_for_rewrite(cfg);
1607 }
06bb643b 1608 run_rewrite_hook(current_head->object.sha1, sha1);
6f6bee3b 1609 }
f5bbc322 1610 if (!quiet)
06bb643b 1611 print_summary(prefix, sha1, !current_head);
f5bbc322
KH
1612
1613 return 0;
1614}