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