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