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