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