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