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