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