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