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