builtin/commit.c

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