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