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