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