builtin/commit.c

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