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