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