builtin/commit.c

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