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