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