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