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