builtin / commit.con commit Merge branch 'jk/trailers-placeholder-in-pretty' (f008159)
   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
  37static const char * const builtin_commit_usage[] = {
  38        N_("git commit [<options>] [--] <pathspec>..."),
  39        NULL
  40};
  41
  42static const char * const builtin_status_usage[] = {
  43        N_("git status [<options>] [--] <pathspec>..."),
  44        NULL
  45};
  46
  47static const char implicit_ident_advice_noconfig[] =
  48N_("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
  60static const char implicit_ident_advice_config[] =
  61N_("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
  72static const char empty_amend_advice[] =
  73N_("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
  77static const char empty_cherry_pick_advice[] =
  78N_("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
  84static const char empty_cherry_pick_advice_single[] =
  85N_("Otherwise, please use 'git reset'\n");
  86
  87static const char empty_cherry_pick_advice_multi[] =
  88N_("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
  95static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")
  96
  97static const char *use_message_buffer;
  98static struct lock_file index_lock; /* real index */
  99static struct lock_file false_lock; /* used only for partial commits */
 100static enum {
 101        COMMIT_AS_IS = 1,
 102        COMMIT_NORMAL,
 103        COMMIT_PARTIAL
 104} commit_style;
 105
 106static const char *logfile, *force_author;
 107static const char *template_file;
 108/*
 109 * The _message variables are commit names from which to take
 110 * the commit message and/or authorship.
 111 */
 112static const char *author_message, *author_message_buffer;
 113static char *edit_message, *use_message;
 114static char *fixup_message, *squash_message;
 115static int all, also, interactive, patch_interactive, only, amend, signoff;
 116static int edit_flag = -1; /* unspecified */
 117static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
 118static int config_commit_verbose = -1; /* unspecified */
 119static int no_post_rewrite, allow_empty_message;
 120static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
 121static 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 */
 130static enum {
 131        CLEANUP_SPACE,
 132        CLEANUP_NONE,
 133        CLEANUP_SCISSORS,
 134        CLEANUP_ALL
 135} cleanup_mode;
 136static const char *cleanup_arg;
 137
 138static enum commit_whence whence;
 139static int sequencer_in_use;
 140static int use_editor = 1, include_status = 1;
 141static int show_ignored_in_status, have_option_m;
 142static const char *only_include_assumed;
 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        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
 205static 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
 220static 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 */
 243static 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
 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.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
 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;
 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, 1);
 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, 1);
 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, 1);
 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, 1);
 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
 496static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
 497                      struct wt_status *s)
 498{
 499        unsigned char sha1[20];
 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, sha1) ? 1 : 0;
 513        if (!s->is_initial)
 514                hashcpy(s->sha1_commit, sha1);
 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
 524static int is_a_merge(const struct commit *current_head)
 525{
 526        return !!(current_head->parents && current_head->parents->next);
 527}
 528
 529static 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
 535static 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
 545static 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
 560static void set_ident_var(char **buf, char *val)
 561{
 562        free(*buf);
 563        *buf = val;
 564}
 565
 566static 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
 625static int author_date_is_interesting(void)
 626{
 627        return author_message || force_date;
 628}
 629
 630static 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
 660static 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                                git_path(whence == FROM_MERGE
 825                                         ? "MERGE_HEAD"
 826                                         : "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                unsigned char sha1[20];
 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, sha1)) {
 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                char index[PATH_MAX];
 964                const char *env[2] = { NULL };
 965                env[0] =  index;
 966                snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
 967                if (launch_editor(git_path_commit_editmsg(), NULL, env)) {
 968                        fprintf(stderr,
 969                        _("Please supply the message using either -m or -F option.\n"));
 970                        exit(1);
 971                }
 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
 982static 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 */
1012static 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 */
1023static 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
1041static 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
1075static 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
1089static 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 */
1105static 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
1113static 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
1138static 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
1237static 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
1250static 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
1269static 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
1331int cmd_status(int argc, const char **argv, const char *prefix)
1332{
1333        static struct wt_status s;
1334        int fd;
1335        unsigned char sha1[20];
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, sha1) ? 1 : 0;
1386        if (!s.is_initial)
1387                hashcpy(s.sha1_commit, sha1);
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
1405static const char *implicit_ident_advice(void)
1406{
1407        char *user_config = expand_user_path("~/.gitconfig");
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
1421static void print_summary(const char *prefix, const unsigned char *sha1,
1422                          int initial_commit)
1423{
1424        struct rev_info rev;
1425        struct commit *commit;
1426        struct strbuf format = STRBUF_INIT;
1427        unsigned char junk_sha1[20];
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(sha1);
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_sha1, 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
1496static 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
1525static int run_rewrite_hook(const unsigned char *oldsha1,
1526                            const unsigned char *newsha1)
1527{
1528        /* oldsha1 SP newsha1 LF NUL */
1529        static char buf[2*40 + 3];
1530        struct child_process proc = CHILD_PROCESS_INIT;
1531        const char *argv[3];
1532        int code;
1533        size_t n;
1534
1535        argv[0] = find_hook("post-rewrite");
1536        if (!argv[0])
1537                return 0;
1538
1539        argv[1] = "amend";
1540        argv[2] = NULL;
1541
1542        proc.argv = argv;
1543        proc.in = -1;
1544        proc.stdout_to_stderr = 1;
1545
1546        code = start_command(&proc);
1547        if (code)
1548                return code;
1549        n = snprintf(buf, sizeof(buf), "%s %s\n",
1550                     sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1551        sigchain_push(SIGPIPE, SIG_IGN);
1552        write_in_full(proc.in, buf, n);
1553        close(proc.in);
1554        sigchain_pop(SIGPIPE);
1555        return finish_command(&proc);
1556}
1557
1558int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1559{
1560        const char *hook_env[3] =  { NULL };
1561        char index[PATH_MAX];
1562        va_list args;
1563        int ret;
1564
1565        snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1566        hook_env[0] = index;
1567
1568        /*
1569         * Let the hook know that no editor will be launched.
1570         */
1571        if (!editor_is_used)
1572                hook_env[1] = "GIT_EDITOR=:";
1573
1574        va_start(args, name);
1575        ret = run_hook_ve(hook_env, name, args);
1576        va_end(args);
1577
1578        return ret;
1579}
1580
1581int cmd_commit(int argc, const char **argv, const char *prefix)
1582{
1583        static struct wt_status s;
1584        static struct option builtin_commit_options[] = {
1585                OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1586                OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1587
1588                OPT_GROUP(N_("Commit message options")),
1589                OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1590                OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1591                OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1592                OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1593                OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1594                OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1595                OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1596                OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1597                OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1598                OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
1599                OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1600                OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1601                OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1602                OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
1603                { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
1604                  N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1605                /* end commit message options */
1606
1607                OPT_GROUP(N_("Commit contents options")),
1608                OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1609                OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1610                OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1611                OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1612                OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1613                OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
1614                OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
1615                OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1616                            STATUS_FORMAT_SHORT),
1617                OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
1618                OPT_SET_INT(0, "porcelain", &status_format,
1619                            N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1620                OPT_SET_INT(0, "long", &status_format,
1621                            N_("show status in long format (default)"),
1622                            STATUS_FORMAT_LONG),
1623                OPT_BOOL('z', "null", &s.null_termination,
1624                         N_("terminate entries with NUL")),
1625                OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1626                OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1627                { 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" },
1628                /* end commit contents options */
1629
1630                OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1631                                N_("ok to record an empty change")),
1632                OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1633                                N_("ok to record a change with an empty message")),
1634
1635                OPT_END()
1636        };
1637
1638        struct strbuf sb = STRBUF_INIT;
1639        struct strbuf author_ident = STRBUF_INIT;
1640        const char *index_file, *reflog_msg;
1641        char *nl;
1642        unsigned char sha1[20];
1643        struct commit_list *parents = NULL;
1644        struct stat statbuf;
1645        struct commit *current_head = NULL;
1646        struct commit_extra_header *extra = NULL;
1647        struct ref_transaction *transaction;
1648        struct strbuf err = STRBUF_INIT;
1649
1650        if (argc == 2 && !strcmp(argv[1], "-h"))
1651                usage_with_options(builtin_commit_usage, builtin_commit_options);
1652
1653        status_init_config(&s, git_commit_config);
1654        status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1655        s.colopts = 0;
1656
1657        if (get_sha1("HEAD", sha1))
1658                current_head = NULL;
1659        else {
1660                current_head = lookup_commit_or_die(sha1, "HEAD");
1661                if (parse_commit(current_head))
1662                        die(_("could not parse HEAD commit"));
1663        }
1664        verbose = -1; /* unspecified */
1665        argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1666                                          builtin_commit_usage,
1667                                          prefix, current_head, &s);
1668        if (verbose == -1)
1669                verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1670
1671        if (dry_run)
1672                return dry_run_commit(argc, argv, prefix, current_head, &s);
1673        index_file = prepare_index(argc, argv, prefix, current_head, 0);
1674
1675        /* Set up everything for writing the commit object.  This includes
1676           running hooks, writing the trees, and interacting with the user.  */
1677        if (!prepare_to_commit(index_file, prefix,
1678                               current_head, &s, &author_ident)) {
1679                rollback_index_files();
1680                return 1;
1681        }
1682
1683        /* Determine parents */
1684        reflog_msg = getenv("GIT_REFLOG_ACTION");
1685        if (!current_head) {
1686                if (!reflog_msg)
1687                        reflog_msg = "commit (initial)";
1688        } else if (amend) {
1689                if (!reflog_msg)
1690                        reflog_msg = "commit (amend)";
1691                parents = copy_commit_list(current_head->parents);
1692        } else if (whence == FROM_MERGE) {
1693                struct strbuf m = STRBUF_INIT;
1694                FILE *fp;
1695                int allow_fast_forward = 1;
1696                struct commit_list **pptr = &parents;
1697
1698                if (!reflog_msg)
1699                        reflog_msg = "commit (merge)";
1700                pptr = commit_list_append(current_head, pptr);
1701                fp = fopen(git_path_merge_head(), "r");
1702                if (fp == NULL)
1703                        die_errno(_("could not open '%s' for reading"),
1704                                  git_path_merge_head());
1705                while (strbuf_getline_lf(&m, fp) != EOF) {
1706                        struct commit *parent;
1707
1708                        parent = get_merge_parent(m.buf);
1709                        if (!parent)
1710                                die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1711                        pptr = commit_list_append(parent, pptr);
1712                }
1713                fclose(fp);
1714                strbuf_release(&m);
1715                if (!stat(git_path_merge_mode(), &statbuf)) {
1716                        if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1717                                die_errno(_("could not read MERGE_MODE"));
1718                        if (!strcmp(sb.buf, "no-ff"))
1719                                allow_fast_forward = 0;
1720                }
1721                if (allow_fast_forward)
1722                        parents = reduce_heads(parents);
1723        } else {
1724                if (!reflog_msg)
1725                        reflog_msg = (whence == FROM_CHERRY_PICK)
1726                                        ? "commit (cherry-pick)"
1727                                        : "commit";
1728                commit_list_insert(current_head, &parents);
1729        }
1730
1731        /* Finally, get the commit message */
1732        strbuf_reset(&sb);
1733        if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1734                int saved_errno = errno;
1735                rollback_index_files();
1736                die(_("could not read commit message: %s"), strerror(saved_errno));
1737        }
1738
1739        if (verbose || /* Truncate the message just before the diff, if any. */
1740            cleanup_mode == CLEANUP_SCISSORS)
1741                wt_status_truncate_message_at_cut_line(&sb);
1742
1743        if (cleanup_mode != CLEANUP_NONE)
1744                strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1745        if (template_untouched(&sb) && !allow_empty_message) {
1746                rollback_index_files();
1747                fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1748                exit(1);
1749        }
1750        if (message_is_empty(&sb) && !allow_empty_message) {
1751                rollback_index_files();
1752                fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1753                exit(1);
1754        }
1755
1756        if (amend) {
1757                const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1758                extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1759        } else {
1760                struct commit_extra_header **tail = &extra;
1761                append_merge_tag_headers(parents, &tail);
1762        }
1763
1764        if (commit_tree_extended(sb.buf, sb.len, active_cache_tree->sha1,
1765                         parents, sha1, author_ident.buf, sign_commit, extra)) {
1766                rollback_index_files();
1767                die(_("failed to write commit object"));
1768        }
1769        strbuf_release(&author_ident);
1770        free_commit_extra_headers(extra);
1771
1772        nl = strchr(sb.buf, '\n');
1773        if (nl)
1774                strbuf_setlen(&sb, nl + 1 - sb.buf);
1775        else
1776                strbuf_addch(&sb, '\n');
1777        strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1778        strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1779
1780        transaction = ref_transaction_begin(&err);
1781        if (!transaction ||
1782            ref_transaction_update(transaction, "HEAD", sha1,
1783                                   current_head
1784                                   ? current_head->object.oid.hash : null_sha1,
1785                                   0, sb.buf, &err) ||
1786            ref_transaction_commit(transaction, &err)) {
1787                rollback_index_files();
1788                die("%s", err.buf);
1789        }
1790        ref_transaction_free(transaction);
1791
1792        unlink(git_path_cherry_pick_head());
1793        unlink(git_path_revert_head());
1794        unlink(git_path_merge_head());
1795        unlink(git_path_merge_msg());
1796        unlink(git_path_merge_mode());
1797        unlink(git_path_squash_msg());
1798
1799        if (commit_index_files())
1800                die (_("Repository has been updated, but unable to write\n"
1801                     "new_index file. Check that disk is not full and quota is\n"
1802                     "not exceeded, and then \"git reset HEAD\" to recover."));
1803
1804        rerere(0);
1805        run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
1806        if (amend && !no_post_rewrite) {
1807                struct notes_rewrite_cfg *cfg;
1808                cfg = init_copy_notes_for_rewrite("amend");
1809                if (cfg) {
1810                        /* we are amending, so current_head is not NULL */
1811                        copy_note_for_rewrite(cfg, current_head->object.oid.hash, sha1);
1812                        finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1813                }
1814                run_rewrite_hook(current_head->object.oid.hash, sha1);
1815        }
1816        if (!quiet)
1817                print_summary(prefix, sha1, !current_head);
1818
1819        strbuf_release(&err);
1820        return 0;
1821}