builtin/commit.c

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