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