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