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