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