Document date formats accepted by parse_date()
[git/git.git] / builtin-commit.c
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"
10 #include "color.h"
11 #include "dir.h"
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"
24 #include "string-list.h"
25 #include "rerere.h"
26 #include "unpack-trees.h"
27
28 static const char * const builtin_commit_usage[] = {
29 "git commit [options] [--] <filepattern>...",
30 NULL
31 };
32
33 static const char * const builtin_status_usage[] = {
34 "git status [options] [--] <filepattern>...",
35 NULL
36 };
37
38 static unsigned char head_sha1[20], merge_head_sha1[20];
39 static char *use_message_buffer;
40 static const char commit_editmsg[] = "COMMIT_EDITMSG";
41 static struct lock_file index_lock; /* real index */
42 static struct lock_file false_lock; /* used only for partial commits */
43 static enum {
44 COMMIT_AS_IS = 1,
45 COMMIT_NORMAL,
46 COMMIT_PARTIAL,
47 } commit_style;
48
49 static const char *logfile, *force_author;
50 static const char *template_file;
51 static char *edit_message, *use_message;
52 static char *author_name, *author_email, *author_date;
53 static int all, edit_flag, also, interactive, only, amend, signoff;
54 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
55 static char *untracked_files_arg, *force_date;
56 /*
57 * The default commit message cleanup mode will remove the lines
58 * beginning with # (shell comments) and leading and trailing
59 * whitespaces (empty lines or containing only whitespaces)
60 * if editor is used, and only the whitespaces if the message
61 * is specified explicitly.
62 */
63 static enum {
64 CLEANUP_SPACE,
65 CLEANUP_NONE,
66 CLEANUP_ALL,
67 } cleanup_mode;
68 static char *cleanup_arg;
69
70 static int use_editor = 1, initial_commit, in_merge;
71 static const char *only_include_assumed;
72 static struct strbuf message;
73
74 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
75 {
76 struct strbuf *buf = opt->value;
77 if (unset)
78 strbuf_setlen(buf, 0);
79 else {
80 strbuf_addstr(buf, arg);
81 strbuf_addstr(buf, "\n\n");
82 }
83 return 0;
84 }
85
86 static struct option builtin_commit_options[] = {
87 OPT__QUIET(&quiet),
88 OPT__VERBOSE(&verbose),
89 OPT_GROUP("Commit message options"),
90
91 OPT_FILENAME('F', "file", &logfile, "read log from file"),
92 OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
93 OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
94 OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
95 OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
96 OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
97 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
98 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
99 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
100 OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
101
102 OPT_GROUP("Commit contents options"),
103 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
104 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
105 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
106 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
107 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
108 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
109 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
110 { 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" },
111 OPT_BOOLEAN(0, "allow-empty", &allow_empty, "ok to record an empty change"),
112 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
113
114 OPT_END()
115 };
116
117 static void rollback_index_files(void)
118 {
119 switch (commit_style) {
120 case COMMIT_AS_IS:
121 break; /* nothing to do */
122 case COMMIT_NORMAL:
123 rollback_lock_file(&index_lock);
124 break;
125 case COMMIT_PARTIAL:
126 rollback_lock_file(&index_lock);
127 rollback_lock_file(&false_lock);
128 break;
129 }
130 }
131
132 static int commit_index_files(void)
133 {
134 int err = 0;
135
136 switch (commit_style) {
137 case COMMIT_AS_IS:
138 break; /* nothing to do */
139 case COMMIT_NORMAL:
140 err = commit_lock_file(&index_lock);
141 break;
142 case COMMIT_PARTIAL:
143 err = commit_lock_file(&index_lock);
144 rollback_lock_file(&false_lock);
145 break;
146 }
147
148 return err;
149 }
150
151 /*
152 * Take a union of paths in the index and the named tree (typically, "HEAD"),
153 * and return the paths that match the given pattern in list.
154 */
155 static int list_paths(struct string_list *list, const char *with_tree,
156 const char *prefix, const char **pattern)
157 {
158 int i;
159 char *m;
160
161 for (i = 0; pattern[i]; i++)
162 ;
163 m = xcalloc(1, i);
164
165 if (with_tree)
166 overlay_tree_on_cache(with_tree, prefix);
167
168 for (i = 0; i < active_nr; i++) {
169 struct cache_entry *ce = active_cache[i];
170 if (ce->ce_flags & CE_UPDATE)
171 continue;
172 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
173 continue;
174 string_list_insert(ce->name, list);
175 }
176
177 return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
178 }
179
180 static void add_remove_files(struct string_list *list)
181 {
182 int i;
183 for (i = 0; i < list->nr; i++) {
184 struct stat st;
185 struct string_list_item *p = &(list->items[i]);
186
187 if (!lstat(p->string, &st)) {
188 if (add_to_cache(p->string, &st, 0))
189 die("updating files failed");
190 } else
191 remove_file_from_cache(p->string);
192 }
193 }
194
195 static void create_base_index(void)
196 {
197 struct tree *tree;
198 struct unpack_trees_options opts;
199 struct tree_desc t;
200
201 if (initial_commit) {
202 discard_cache();
203 return;
204 }
205
206 memset(&opts, 0, sizeof(opts));
207 opts.head_idx = 1;
208 opts.index_only = 1;
209 opts.merge = 1;
210 opts.src_index = &the_index;
211 opts.dst_index = &the_index;
212
213 opts.fn = oneway_merge;
214 tree = parse_tree_indirect(head_sha1);
215 if (!tree)
216 die("failed to unpack HEAD tree object");
217 parse_tree(tree);
218 init_tree_desc(&t, tree->buffer, tree->size);
219 if (unpack_trees(1, &t, &opts))
220 exit(128); /* We've already reported the error, finish dying */
221 }
222
223 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
224 {
225 int fd;
226 struct string_list partial;
227 const char **pathspec = NULL;
228 int refresh_flags = REFRESH_QUIET;
229
230 if (is_status)
231 refresh_flags |= REFRESH_UNMERGED;
232 if (interactive) {
233 if (interactive_add(argc, argv, prefix) != 0)
234 die("interactive add failed");
235 if (read_cache_preload(NULL) < 0)
236 die("index file corrupt");
237 commit_style = COMMIT_AS_IS;
238 return get_index_file();
239 }
240
241 if (*argv)
242 pathspec = get_pathspec(prefix, argv);
243
244 if (read_cache_preload(pathspec) < 0)
245 die("index file corrupt");
246
247 /*
248 * Non partial, non as-is commit.
249 *
250 * (1) get the real index;
251 * (2) update the_index as necessary;
252 * (3) write the_index out to the real index (still locked);
253 * (4) return the name of the locked index file.
254 *
255 * The caller should run hooks on the locked real index, and
256 * (A) if all goes well, commit the real index;
257 * (B) on failure, rollback the real index.
258 */
259 if (all || (also && pathspec && *pathspec)) {
260 int fd = hold_locked_index(&index_lock, 1);
261 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
262 refresh_cache(refresh_flags);
263 if (write_cache(fd, active_cache, active_nr) ||
264 close_lock_file(&index_lock))
265 die("unable to write new_index file");
266 commit_style = COMMIT_NORMAL;
267 return index_lock.filename;
268 }
269
270 /*
271 * As-is commit.
272 *
273 * (1) return the name of the real index file.
274 *
275 * The caller should run hooks on the real index, and run
276 * hooks on the real index, and create commit from the_index.
277 * We still need to refresh the index here.
278 */
279 if (!pathspec || !*pathspec) {
280 fd = hold_locked_index(&index_lock, 1);
281 refresh_cache(refresh_flags);
282 if (write_cache(fd, active_cache, active_nr) ||
283 commit_locked_index(&index_lock))
284 die("unable to write new_index file");
285 commit_style = COMMIT_AS_IS;
286 return get_index_file();
287 }
288
289 /*
290 * A partial commit.
291 *
292 * (0) find the set of affected paths;
293 * (1) get lock on the real index file;
294 * (2) update the_index with the given paths;
295 * (3) write the_index out to the real index (still locked);
296 * (4) get lock on the false index file;
297 * (5) reset the_index from HEAD;
298 * (6) update the_index the same way as (2);
299 * (7) write the_index out to the false index file;
300 * (8) return the name of the false index file (still locked);
301 *
302 * The caller should run hooks on the locked false index, and
303 * create commit from it. Then
304 * (A) if all goes well, commit the real index;
305 * (B) on failure, rollback the real index;
306 * In either case, rollback the false index.
307 */
308 commit_style = COMMIT_PARTIAL;
309
310 if (file_exists(git_path("MERGE_HEAD")))
311 die("cannot do a partial commit during a merge.");
312
313 memset(&partial, 0, sizeof(partial));
314 partial.strdup_strings = 1;
315 if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
316 exit(1);
317
318 discard_cache();
319 if (read_cache() < 0)
320 die("cannot read the index");
321
322 fd = hold_locked_index(&index_lock, 1);
323 add_remove_files(&partial);
324 refresh_cache(REFRESH_QUIET);
325 if (write_cache(fd, active_cache, active_nr) ||
326 close_lock_file(&index_lock))
327 die("unable to write new_index file");
328
329 fd = hold_lock_file_for_update(&false_lock,
330 git_path("next-index-%"PRIuMAX,
331 (uintmax_t) getpid()),
332 LOCK_DIE_ON_ERROR);
333
334 create_base_index();
335 add_remove_files(&partial);
336 refresh_cache(REFRESH_QUIET);
337
338 if (write_cache(fd, active_cache, active_nr) ||
339 close_lock_file(&false_lock))
340 die("unable to write temporary index file");
341
342 discard_cache();
343 read_cache_from(false_lock.filename);
344
345 return false_lock.filename;
346 }
347
348 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
349 struct wt_status *s)
350 {
351 if (s->relative_paths)
352 s->prefix = prefix;
353
354 if (amend) {
355 s->amend = 1;
356 s->reference = "HEAD^1";
357 }
358 s->verbose = verbose;
359 s->index_file = index_file;
360 s->fp = fp;
361 s->nowarn = nowarn;
362
363 wt_status_print(s);
364
365 return s->commitable;
366 }
367
368 static int is_a_merge(const unsigned char *sha1)
369 {
370 struct commit *commit = lookup_commit(sha1);
371 if (!commit || parse_commit(commit))
372 die("could not parse HEAD commit");
373 return !!(commit->parents && commit->parents->next);
374 }
375
376 static const char sign_off_header[] = "Signed-off-by: ";
377
378 static void determine_author_info(void)
379 {
380 char *name, *email, *date;
381
382 name = getenv("GIT_AUTHOR_NAME");
383 email = getenv("GIT_AUTHOR_EMAIL");
384 date = getenv("GIT_AUTHOR_DATE");
385
386 if (use_message && !renew_authorship) {
387 const char *a, *lb, *rb, *eol;
388
389 a = strstr(use_message_buffer, "\nauthor ");
390 if (!a)
391 die("invalid commit: %s", use_message);
392
393 lb = strstr(a + 8, " <");
394 rb = strstr(a + 8, "> ");
395 eol = strchr(a + 8, '\n');
396 if (!lb || !rb || !eol)
397 die("invalid commit: %s", use_message);
398
399 name = xstrndup(a + 8, lb - (a + 8));
400 email = xstrndup(lb + 2, rb - (lb + 2));
401 date = xstrndup(rb + 2, eol - (rb + 2));
402 }
403
404 if (force_author) {
405 const char *lb = strstr(force_author, " <");
406 const char *rb = strchr(force_author, '>');
407
408 if (!lb || !rb)
409 die("malformed --author parameter");
410 name = xstrndup(force_author, lb - force_author);
411 email = xstrndup(lb + 2, rb - (lb + 2));
412 }
413
414 if (force_date)
415 date = force_date;
416
417 author_name = name;
418 author_email = email;
419 author_date = date;
420 }
421
422 static int ends_rfc2822_footer(struct strbuf *sb)
423 {
424 int ch;
425 int hit = 0;
426 int i, j, k;
427 int len = sb->len;
428 int first = 1;
429 const char *buf = sb->buf;
430
431 for (i = len - 1; i > 0; i--) {
432 if (hit && buf[i] == '\n')
433 break;
434 hit = (buf[i] == '\n');
435 }
436
437 while (i < len - 1 && buf[i] == '\n')
438 i++;
439
440 for (; i < len; i = k) {
441 for (k = i; k < len && buf[k] != '\n'; k++)
442 ; /* do nothing */
443 k++;
444
445 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
446 continue;
447
448 first = 0;
449
450 for (j = 0; i + j < len; j++) {
451 ch = buf[i + j];
452 if (ch == ':')
453 break;
454 if (isalnum(ch) ||
455 (ch == '-'))
456 continue;
457 return 0;
458 }
459 }
460 return 1;
461 }
462
463 static int prepare_to_commit(const char *index_file, const char *prefix,
464 struct wt_status *s)
465 {
466 struct stat statbuf;
467 int commitable, saved_color_setting;
468 struct strbuf sb = STRBUF_INIT;
469 char *buffer;
470 FILE *fp;
471 const char *hook_arg1 = NULL;
472 const char *hook_arg2 = NULL;
473 int ident_shown = 0;
474
475 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
476 return 0;
477
478 if (message.len) {
479 strbuf_addbuf(&sb, &message);
480 hook_arg1 = "message";
481 } else if (logfile && !strcmp(logfile, "-")) {
482 if (isatty(0))
483 fprintf(stderr, "(reading log message from standard input)\n");
484 if (strbuf_read(&sb, 0, 0) < 0)
485 die_errno("could not read log from standard input");
486 hook_arg1 = "message";
487 } else if (logfile) {
488 if (strbuf_read_file(&sb, logfile, 0) < 0)
489 die_errno("could not read log file '%s'",
490 logfile);
491 hook_arg1 = "message";
492 } else if (use_message) {
493 buffer = strstr(use_message_buffer, "\n\n");
494 if (!buffer || buffer[2] == '\0')
495 die("commit has empty message");
496 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
497 hook_arg1 = "commit";
498 hook_arg2 = use_message;
499 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
500 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
501 die_errno("could not read MERGE_MSG");
502 hook_arg1 = "merge";
503 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
504 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
505 die_errno("could not read SQUASH_MSG");
506 hook_arg1 = "squash";
507 } else if (template_file && !stat(template_file, &statbuf)) {
508 if (strbuf_read_file(&sb, template_file, 0) < 0)
509 die_errno("could not read '%s'", template_file);
510 hook_arg1 = "template";
511 }
512
513 /*
514 * This final case does not modify the template message,
515 * it just sets the argument to the prepare-commit-msg hook.
516 */
517 else if (in_merge)
518 hook_arg1 = "merge";
519
520 fp = fopen(git_path(commit_editmsg), "w");
521 if (fp == NULL)
522 die_errno("could not open '%s'", git_path(commit_editmsg));
523
524 if (cleanup_mode != CLEANUP_NONE)
525 stripspace(&sb, 0);
526
527 if (signoff) {
528 struct strbuf sob = STRBUF_INIT;
529 int i;
530
531 strbuf_addstr(&sob, sign_off_header);
532 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
533 getenv("GIT_COMMITTER_EMAIL")));
534 strbuf_addch(&sob, '\n');
535 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
536 ; /* do nothing */
537 if (prefixcmp(sb.buf + i, sob.buf)) {
538 if (!i || !ends_rfc2822_footer(&sb))
539 strbuf_addch(&sb, '\n');
540 strbuf_addbuf(&sb, &sob);
541 }
542 strbuf_release(&sob);
543 }
544
545 if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
546 die_errno("could not write commit template");
547
548 strbuf_release(&sb);
549
550 determine_author_info();
551
552 /* This checks if committer ident is explicitly given */
553 git_committer_info(0);
554 if (use_editor) {
555 char *author_ident;
556 const char *committer_ident;
557
558 if (in_merge)
559 fprintf(fp,
560 "#\n"
561 "# It looks like you may be committing a MERGE.\n"
562 "# If this is not correct, please remove the file\n"
563 "# %s\n"
564 "# and try again.\n"
565 "#\n",
566 git_path("MERGE_HEAD"));
567
568 fprintf(fp,
569 "\n"
570 "# Please enter the commit message for your changes.");
571 if (cleanup_mode == CLEANUP_ALL)
572 fprintf(fp,
573 " Lines starting\n"
574 "# with '#' will be ignored, and an empty"
575 " message aborts the commit.\n");
576 else /* CLEANUP_SPACE, that is. */
577 fprintf(fp,
578 " Lines starting\n"
579 "# with '#' will be kept; you may remove them"
580 " yourself if you want to.\n"
581 "# An empty message aborts the commit.\n");
582 if (only_include_assumed)
583 fprintf(fp, "# %s\n", only_include_assumed);
584
585 author_ident = xstrdup(fmt_name(author_name, author_email));
586 committer_ident = fmt_name(getenv("GIT_COMMITTER_NAME"),
587 getenv("GIT_COMMITTER_EMAIL"));
588 if (strcmp(author_ident, committer_ident))
589 fprintf(fp,
590 "%s"
591 "# Author: %s\n",
592 ident_shown++ ? "" : "#\n",
593 author_ident);
594 free(author_ident);
595
596 if (!user_ident_explicitly_given)
597 fprintf(fp,
598 "%s"
599 "# Committer: %s\n",
600 ident_shown++ ? "" : "#\n",
601 committer_ident);
602
603 if (ident_shown)
604 fprintf(fp, "#\n");
605
606 saved_color_setting = s->use_color;
607 s->use_color = 0;
608 commitable = run_status(fp, index_file, prefix, 1, s);
609 s->use_color = saved_color_setting;
610 } else {
611 unsigned char sha1[20];
612 const char *parent = "HEAD";
613
614 if (!active_nr && read_cache() < 0)
615 die("Cannot read index");
616
617 if (amend)
618 parent = "HEAD^1";
619
620 if (get_sha1(parent, sha1))
621 commitable = !!active_nr;
622 else
623 commitable = index_differs_from(parent, 0);
624 }
625
626 fclose(fp);
627
628 if (!commitable && !in_merge && !allow_empty &&
629 !(amend && is_a_merge(head_sha1))) {
630 run_status(stdout, index_file, prefix, 0, s);
631 return 0;
632 }
633
634 /*
635 * Re-read the index as pre-commit hook could have updated it,
636 * and write it out as a tree. We must do this before we invoke
637 * the editor and after we invoke run_status above.
638 */
639 discard_cache();
640 read_cache_from(index_file);
641 if (!active_cache_tree)
642 active_cache_tree = cache_tree();
643 if (cache_tree_update(active_cache_tree,
644 active_cache, active_nr, 0, 0) < 0) {
645 error("Error building trees");
646 return 0;
647 }
648
649 if (run_hook(index_file, "prepare-commit-msg",
650 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
651 return 0;
652
653 if (use_editor) {
654 char index[PATH_MAX];
655 const char *env[2] = { index, NULL };
656 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
657 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
658 fprintf(stderr,
659 "Please supply the message using either -m or -F option.\n");
660 exit(1);
661 }
662 }
663
664 if (!no_verify &&
665 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
666 return 0;
667 }
668
669 return 1;
670 }
671
672 /*
673 * Find out if the message in the strbuf contains only whitespace and
674 * Signed-off-by lines.
675 */
676 static int message_is_empty(struct strbuf *sb)
677 {
678 struct strbuf tmpl = STRBUF_INIT;
679 const char *nl;
680 int eol, i, start = 0;
681
682 if (cleanup_mode == CLEANUP_NONE && sb->len)
683 return 0;
684
685 /* See if the template is just a prefix of the message. */
686 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
687 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
688 if (start + tmpl.len <= sb->len &&
689 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
690 start += tmpl.len;
691 }
692 strbuf_release(&tmpl);
693
694 /* Check if the rest is just whitespace and Signed-of-by's. */
695 for (i = start; i < sb->len; i++) {
696 nl = memchr(sb->buf + i, '\n', sb->len - i);
697 if (nl)
698 eol = nl - sb->buf;
699 else
700 eol = sb->len;
701
702 if (strlen(sign_off_header) <= eol - i &&
703 !prefixcmp(sb->buf + i, sign_off_header)) {
704 i = eol;
705 continue;
706 }
707 while (i < eol)
708 if (!isspace(sb->buf[i++]))
709 return 0;
710 }
711
712 return 1;
713 }
714
715 static const char *find_author_by_nickname(const char *name)
716 {
717 struct rev_info revs;
718 struct commit *commit;
719 struct strbuf buf = STRBUF_INIT;
720 const char *av[20];
721 int ac = 0;
722
723 init_revisions(&revs, NULL);
724 strbuf_addf(&buf, "--author=%s", name);
725 av[++ac] = "--all";
726 av[++ac] = "-i";
727 av[++ac] = buf.buf;
728 av[++ac] = NULL;
729 setup_revisions(ac, av, &revs, NULL);
730 prepare_revision_walk(&revs);
731 commit = get_revision(&revs);
732 if (commit) {
733 struct pretty_print_context ctx = {0};
734 ctx.date_mode = DATE_NORMAL;
735 strbuf_release(&buf);
736 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
737 return strbuf_detach(&buf, NULL);
738 }
739 die("No existing author found with '%s'", name);
740 }
741
742 static int parse_and_validate_options(int argc, const char *argv[],
743 const char * const usage[],
744 const char *prefix,
745 struct wt_status *s)
746 {
747 int f = 0;
748
749 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
750 0);
751
752 if (force_author && !strchr(force_author, '>'))
753 force_author = find_author_by_nickname(force_author);
754
755 if (force_author && renew_authorship)
756 die("Using both --reset-author and --author does not make sense");
757
758 if (logfile || message.len || use_message)
759 use_editor = 0;
760 if (edit_flag)
761 use_editor = 1;
762 if (!use_editor)
763 setenv("GIT_EDITOR", ":", 1);
764
765 if (get_sha1("HEAD", head_sha1))
766 initial_commit = 1;
767
768 if (!get_sha1("MERGE_HEAD", merge_head_sha1))
769 in_merge = 1;
770
771 /* Sanity check options */
772 if (amend && initial_commit)
773 die("You have nothing to amend.");
774 if (amend && in_merge)
775 die("You are in the middle of a merge -- cannot amend.");
776
777 if (use_message)
778 f++;
779 if (edit_message)
780 f++;
781 if (logfile)
782 f++;
783 if (f > 1)
784 die("Only one of -c/-C/-F can be used.");
785 if (message.len && f > 0)
786 die("Option -m cannot be combined with -c/-C/-F.");
787 if (edit_message)
788 use_message = edit_message;
789 if (amend && !use_message)
790 use_message = "HEAD";
791 if (!use_message && renew_authorship)
792 die("--reset-author can be used only with -C, -c or --amend.");
793 if (use_message) {
794 unsigned char sha1[20];
795 static char utf8[] = "UTF-8";
796 const char *out_enc;
797 char *enc, *end;
798 struct commit *commit;
799
800 if (get_sha1(use_message, sha1))
801 die("could not lookup commit %s", use_message);
802 commit = lookup_commit_reference(sha1);
803 if (!commit || parse_commit(commit))
804 die("could not parse commit %s", use_message);
805
806 enc = strstr(commit->buffer, "\nencoding");
807 if (enc) {
808 end = strchr(enc + 10, '\n');
809 enc = xstrndup(enc + 10, end - (enc + 10));
810 } else {
811 enc = utf8;
812 }
813 out_enc = git_commit_encoding ? git_commit_encoding : utf8;
814
815 if (strcmp(out_enc, enc))
816 use_message_buffer =
817 reencode_string(commit->buffer, out_enc, enc);
818
819 /*
820 * If we failed to reencode the buffer, just copy it
821 * byte for byte so the user can try to fix it up.
822 * This also handles the case where input and output
823 * encodings are identical.
824 */
825 if (use_message_buffer == NULL)
826 use_message_buffer = xstrdup(commit->buffer);
827 if (enc != utf8)
828 free(enc);
829 }
830
831 if (!!also + !!only + !!all + !!interactive > 1)
832 die("Only one of --include/--only/--all/--interactive can be used.");
833 if (argc == 0 && (also || (only && !amend)))
834 die("No paths with --include/--only does not make sense.");
835 if (argc == 0 && only && amend)
836 only_include_assumed = "Clever... amending the last one with dirty index.";
837 if (argc > 0 && !also && !only)
838 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
839 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
840 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
841 else if (!strcmp(cleanup_arg, "verbatim"))
842 cleanup_mode = CLEANUP_NONE;
843 else if (!strcmp(cleanup_arg, "whitespace"))
844 cleanup_mode = CLEANUP_SPACE;
845 else if (!strcmp(cleanup_arg, "strip"))
846 cleanup_mode = CLEANUP_ALL;
847 else
848 die("Invalid cleanup mode %s", cleanup_arg);
849
850 if (!untracked_files_arg)
851 ; /* default already initialized */
852 else if (!strcmp(untracked_files_arg, "no"))
853 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
854 else if (!strcmp(untracked_files_arg, "normal"))
855 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
856 else if (!strcmp(untracked_files_arg, "all"))
857 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
858 else
859 die("Invalid untracked files mode '%s'", untracked_files_arg);
860
861 if (all && argc > 0)
862 die("Paths with -a does not make sense.");
863 else if (interactive && argc > 0)
864 die("Paths with --interactive does not make sense.");
865
866 return argc;
867 }
868
869 static int dry_run_commit(int argc, const char **argv, const char *prefix,
870 struct wt_status *s)
871 {
872 int commitable;
873 const char *index_file;
874
875 index_file = prepare_index(argc, argv, prefix, 1);
876 commitable = run_status(stdout, index_file, prefix, 0, s);
877 rollback_index_files();
878
879 return commitable ? 0 : 1;
880 }
881
882 static int parse_status_slot(const char *var, int offset)
883 {
884 if (!strcasecmp(var+offset, "header"))
885 return WT_STATUS_HEADER;
886 if (!strcasecmp(var+offset, "updated")
887 || !strcasecmp(var+offset, "added"))
888 return WT_STATUS_UPDATED;
889 if (!strcasecmp(var+offset, "changed"))
890 return WT_STATUS_CHANGED;
891 if (!strcasecmp(var+offset, "untracked"))
892 return WT_STATUS_UNTRACKED;
893 if (!strcasecmp(var+offset, "nobranch"))
894 return WT_STATUS_NOBRANCH;
895 if (!strcasecmp(var+offset, "unmerged"))
896 return WT_STATUS_UNMERGED;
897 die("bad config variable '%s'", var);
898 }
899
900 static int git_status_config(const char *k, const char *v, void *cb)
901 {
902 struct wt_status *s = cb;
903
904 if (!strcmp(k, "status.submodulesummary")) {
905 int is_bool;
906 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
907 if (is_bool && s->submodule_summary)
908 s->submodule_summary = -1;
909 return 0;
910 }
911 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
912 s->use_color = git_config_colorbool(k, v, -1);
913 return 0;
914 }
915 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
916 int slot = parse_status_slot(k, 13);
917 if (!v)
918 return config_error_nonbool(k);
919 color_parse(v, k, s->color_palette[slot]);
920 return 0;
921 }
922 if (!strcmp(k, "status.relativepaths")) {
923 s->relative_paths = git_config_bool(k, v);
924 return 0;
925 }
926 if (!strcmp(k, "status.showuntrackedfiles")) {
927 if (!v)
928 return config_error_nonbool(k);
929 else if (!strcmp(v, "no"))
930 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
931 else if (!strcmp(v, "normal"))
932 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
933 else if (!strcmp(v, "all"))
934 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
935 else
936 return error("Invalid untracked files mode '%s'", v);
937 return 0;
938 }
939 return git_diff_ui_config(k, v, NULL);
940 }
941
942 int cmd_status(int argc, const char **argv, const char *prefix)
943 {
944 struct wt_status s;
945
946 wt_status_prepare(&s);
947 git_config(git_status_config, &s);
948 if (s.use_color == -1)
949 s.use_color = git_use_color_default;
950 if (diff_use_color_default == -1)
951 diff_use_color_default = git_use_color_default;
952
953 argc = parse_and_validate_options(argc, argv, builtin_status_usage,
954 prefix, &s);
955 return dry_run_commit(argc, argv, prefix, &s);
956 }
957
958 static void print_summary(const char *prefix, const unsigned char *sha1)
959 {
960 struct rev_info rev;
961 struct commit *commit;
962 static const char *format = "format:%h] %s";
963 unsigned char junk_sha1[20];
964 const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
965
966 commit = lookup_commit(sha1);
967 if (!commit)
968 die("couldn't look up newly created commit");
969 if (!commit || parse_commit(commit))
970 die("could not parse newly created commit");
971
972 init_revisions(&rev, prefix);
973 setup_revisions(0, NULL, &rev, NULL);
974
975 rev.abbrev = 0;
976 rev.diff = 1;
977 rev.diffopt.output_format =
978 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
979
980 rev.verbose_header = 1;
981 rev.show_root_diff = 1;
982 get_commit_format(format, &rev);
983 rev.always_show_header = 0;
984 rev.diffopt.detect_rename = 1;
985 rev.diffopt.rename_limit = 100;
986 rev.diffopt.break_opt = 0;
987 diff_setup_done(&rev.diffopt);
988
989 printf("[%s%s ",
990 !prefixcmp(head, "refs/heads/") ?
991 head + 11 :
992 !strcmp(head, "HEAD") ?
993 "detached HEAD" :
994 head,
995 initial_commit ? " (root-commit)" : "");
996
997 if (!log_tree_commit(&rev, commit)) {
998 struct pretty_print_context ctx = {0};
999 struct strbuf buf = STRBUF_INIT;
1000 ctx.date_mode = DATE_NORMAL;
1001 format_commit_message(commit, format + 7, &buf, &ctx);
1002 printf("%s\n", buf.buf);
1003 strbuf_release(&buf);
1004 }
1005 }
1006
1007 static int git_commit_config(const char *k, const char *v, void *cb)
1008 {
1009 struct wt_status *s = cb;
1010
1011 if (!strcmp(k, "commit.template"))
1012 return git_config_pathname(&template_file, k, v);
1013
1014 return git_status_config(k, v, s);
1015 }
1016
1017 int cmd_commit(int argc, const char **argv, const char *prefix)
1018 {
1019 struct strbuf sb = STRBUF_INIT;
1020 const char *index_file, *reflog_msg;
1021 char *nl, *p;
1022 unsigned char commit_sha1[20];
1023 struct ref_lock *ref_lock;
1024 struct commit_list *parents = NULL, **pptr = &parents;
1025 struct stat statbuf;
1026 int allow_fast_forward = 1;
1027 struct wt_status s;
1028
1029 wt_status_prepare(&s);
1030 git_config(git_commit_config, &s);
1031
1032 if (s.use_color == -1)
1033 s.use_color = git_use_color_default;
1034
1035 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1036 prefix, &s);
1037 if (dry_run) {
1038 if (diff_use_color_default == -1)
1039 diff_use_color_default = git_use_color_default;
1040 return dry_run_commit(argc, argv, prefix, &s);
1041 }
1042 index_file = prepare_index(argc, argv, prefix, 0);
1043
1044 /* Set up everything for writing the commit object. This includes
1045 running hooks, writing the trees, and interacting with the user. */
1046 if (!prepare_to_commit(index_file, prefix, &s)) {
1047 rollback_index_files();
1048 return 1;
1049 }
1050
1051 /* Determine parents */
1052 if (initial_commit) {
1053 reflog_msg = "commit (initial)";
1054 } else if (amend) {
1055 struct commit_list *c;
1056 struct commit *commit;
1057
1058 reflog_msg = "commit (amend)";
1059 commit = lookup_commit(head_sha1);
1060 if (!commit || parse_commit(commit))
1061 die("could not parse HEAD commit");
1062
1063 for (c = commit->parents; c; c = c->next)
1064 pptr = &commit_list_insert(c->item, pptr)->next;
1065 } else if (in_merge) {
1066 struct strbuf m = STRBUF_INIT;
1067 FILE *fp;
1068
1069 reflog_msg = "commit (merge)";
1070 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1071 fp = fopen(git_path("MERGE_HEAD"), "r");
1072 if (fp == NULL)
1073 die_errno("could not open '%s' for reading",
1074 git_path("MERGE_HEAD"));
1075 while (strbuf_getline(&m, fp, '\n') != EOF) {
1076 unsigned char sha1[20];
1077 if (get_sha1_hex(m.buf, sha1) < 0)
1078 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1079 pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1080 }
1081 fclose(fp);
1082 strbuf_release(&m);
1083 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1084 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1085 die_errno("could not read MERGE_MODE");
1086 if (!strcmp(sb.buf, "no-ff"))
1087 allow_fast_forward = 0;
1088 }
1089 if (allow_fast_forward)
1090 parents = reduce_heads(parents);
1091 } else {
1092 reflog_msg = "commit";
1093 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1094 }
1095
1096 /* Finally, get the commit message */
1097 strbuf_reset(&sb);
1098 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1099 int saved_errno = errno;
1100 rollback_index_files();
1101 die("could not read commit message: %s", strerror(saved_errno));
1102 }
1103
1104 /* Truncate the message just before the diff, if any. */
1105 if (verbose) {
1106 p = strstr(sb.buf, "\ndiff --git ");
1107 if (p != NULL)
1108 strbuf_setlen(&sb, p - sb.buf + 1);
1109 }
1110
1111 if (cleanup_mode != CLEANUP_NONE)
1112 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1113 if (message_is_empty(&sb)) {
1114 rollback_index_files();
1115 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1116 exit(1);
1117 }
1118
1119 if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1120 fmt_ident(author_name, author_email, author_date,
1121 IDENT_ERROR_ON_NO_NAME))) {
1122 rollback_index_files();
1123 die("failed to write commit object");
1124 }
1125
1126 ref_lock = lock_any_ref_for_update("HEAD",
1127 initial_commit ? NULL : head_sha1,
1128 0);
1129
1130 nl = strchr(sb.buf, '\n');
1131 if (nl)
1132 strbuf_setlen(&sb, nl + 1 - sb.buf);
1133 else
1134 strbuf_addch(&sb, '\n');
1135 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1136 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1137
1138 if (!ref_lock) {
1139 rollback_index_files();
1140 die("cannot lock HEAD ref");
1141 }
1142 if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1143 rollback_index_files();
1144 die("cannot update HEAD ref");
1145 }
1146
1147 unlink(git_path("MERGE_HEAD"));
1148 unlink(git_path("MERGE_MSG"));
1149 unlink(git_path("MERGE_MODE"));
1150 unlink(git_path("SQUASH_MSG"));
1151
1152 if (commit_index_files())
1153 die ("Repository has been updated, but unable to write\n"
1154 "new_index file. Check that disk is not full or quota is\n"
1155 "not exceeded, and then \"git reset HEAD\" to recover.");
1156
1157 rerere();
1158 run_hook(get_index_file(), "post-commit", NULL);
1159 if (!quiet)
1160 print_summary(prefix, commit_sha1);
1161
1162 return 0;
1163 }