git-stash.shon commit t3404: cleanup double empty lines between tests (8172c42)
   1#!/bin/sh
   2# Copyright (c) 2007, Nanako Shiraishi
   3
   4dashless=$(basename "$0" | sed -e 's/-/ /')
   5USAGE="list [<options>]
   6   or: $dashless show [<stash>]
   7   or: $dashless drop [-q|--quiet] [<stash>]
   8   or: $dashless ( pop | apply ) [--index] [-q|--quiet] [<stash>]
   9   or: $dashless branch <branchname> [<stash>]
  10   or: $dashless [save [--patch] [-k|--[no-]keep-index] [-q|--quiet]
  11                       [-u|--include-untracked] [-a|--all] [<message>]]
  12   or: $dashless clear"
  13
  14SUBDIRECTORY_OK=Yes
  15OPTIONS_SPEC=
  16START_DIR=$(pwd)
  17. git-sh-setup
  18. git-sh-i18n
  19require_work_tree
  20cd_to_toplevel
  21
  22TMP="$GIT_DIR/.git-stash.$$"
  23TMPindex=${GIT_INDEX_FILE-"$(git rev-parse --git-path index)"}.stash.$$
  24trap 'rm -f "$TMP-"* "$TMPindex"' 0
  25
  26ref_stash=refs/stash
  27
  28if git config --get-colorbool color.interactive; then
  29       help_color="$(git config --get-color color.interactive.help 'red bold')"
  30       reset_color="$(git config --get-color '' reset)"
  31else
  32       help_color=
  33       reset_color=
  34fi
  35
  36no_changes () {
  37        git diff-index --quiet --cached HEAD --ignore-submodules -- &&
  38        git diff-files --quiet --ignore-submodules &&
  39        (test -z "$untracked" || test -z "$(untracked_files)")
  40}
  41
  42untracked_files () {
  43        excl_opt=--exclude-standard
  44        test "$untracked" = "all" && excl_opt=
  45        git ls-files -o -z $excl_opt
  46}
  47
  48clear_stash () {
  49        if test $# != 0
  50        then
  51                die "$(gettext "git stash clear with parameters is unimplemented")"
  52        fi
  53        if current=$(git rev-parse --verify --quiet $ref_stash)
  54        then
  55                git update-ref -d $ref_stash $current
  56        fi
  57}
  58
  59create_stash () {
  60        stash_msg="$1"
  61        untracked="$2"
  62
  63        git update-index -q --refresh
  64        if no_changes
  65        then
  66                exit 0
  67        fi
  68
  69        # state of the base commit
  70        if b_commit=$(git rev-parse --verify HEAD)
  71        then
  72                head=$(git rev-list --oneline -n 1 HEAD --)
  73        else
  74                die "$(gettext "You do not have the initial commit yet")"
  75        fi
  76
  77        if branch=$(git symbolic-ref -q HEAD)
  78        then
  79                branch=${branch#refs/heads/}
  80        else
  81                branch='(no branch)'
  82        fi
  83        msg=$(printf '%s: %s' "$branch" "$head")
  84
  85        # state of the index
  86        i_tree=$(git write-tree) &&
  87        i_commit=$(printf 'index on %s\n' "$msg" |
  88                git commit-tree $i_tree -p $b_commit) ||
  89                die "$(gettext "Cannot save the current index state")"
  90
  91        if test -n "$untracked"
  92        then
  93                # Untracked files are stored by themselves in a parentless commit, for
  94                # ease of unpacking later.
  95                u_commit=$(
  96                        untracked_files | (
  97                                GIT_INDEX_FILE="$TMPindex" &&
  98                                export GIT_INDEX_FILE &&
  99                                rm -f "$TMPindex" &&
 100                                git update-index -z --add --remove --stdin &&
 101                                u_tree=$(git write-tree) &&
 102                                printf 'untracked files on %s\n' "$msg" | git commit-tree $u_tree  &&
 103                                rm -f "$TMPindex"
 104                ) ) || die "Cannot save the untracked files"
 105
 106                untracked_commit_option="-p $u_commit";
 107        else
 108                untracked_commit_option=
 109        fi
 110
 111        if test -z "$patch_mode"
 112        then
 113
 114                # state of the working tree
 115                w_tree=$( (
 116                        git read-tree --index-output="$TMPindex" -m $i_tree &&
 117                        GIT_INDEX_FILE="$TMPindex" &&
 118                        export GIT_INDEX_FILE &&
 119                        git diff --name-only -z HEAD -- >"$TMP-stagenames" &&
 120                        git update-index -z --add --remove --stdin <"$TMP-stagenames" &&
 121                        git write-tree &&
 122                        rm -f "$TMPindex"
 123                ) ) ||
 124                        die "$(gettext "Cannot save the current worktree state")"
 125
 126        else
 127
 128                rm -f "$TMP-index" &&
 129                GIT_INDEX_FILE="$TMP-index" git read-tree HEAD &&
 130
 131                # find out what the user wants
 132                GIT_INDEX_FILE="$TMP-index" \
 133                        git add--interactive --patch=stash -- &&
 134
 135                # state of the working tree
 136                w_tree=$(GIT_INDEX_FILE="$TMP-index" git write-tree) ||
 137                die "$(gettext "Cannot save the current worktree state")"
 138
 139                git diff-tree -p HEAD $w_tree -- >"$TMP-patch" &&
 140                test -s "$TMP-patch" ||
 141                die "$(gettext "No changes selected")"
 142
 143                rm -f "$TMP-index" ||
 144                die "$(gettext "Cannot remove temporary index (can't happen)")"
 145
 146        fi
 147
 148        # create the stash
 149        if test -z "$stash_msg"
 150        then
 151                stash_msg=$(printf 'WIP on %s' "$msg")
 152        else
 153                stash_msg=$(printf 'On %s: %s' "$branch" "$stash_msg")
 154        fi
 155        w_commit=$(printf '%s\n' "$stash_msg" |
 156        git commit-tree $w_tree -p $b_commit -p $i_commit $untracked_commit_option) ||
 157        die "$(gettext "Cannot record working tree state")"
 158}
 159
 160store_stash () {
 161        while test $# != 0
 162        do
 163                case "$1" in
 164                -m|--message)
 165                        shift
 166                        stash_msg="$1"
 167                        ;;
 168                -q|--quiet)
 169                        quiet=t
 170                        ;;
 171                *)
 172                        break
 173                        ;;
 174                esac
 175                shift
 176        done
 177        test $# = 1 ||
 178        die "$(eval_gettext "\"$dashless store\" requires one <commit> argument")"
 179
 180        w_commit="$1"
 181        if test -z "$stash_msg"
 182        then
 183                stash_msg="Created via \"git stash store\"."
 184        fi
 185
 186        git update-ref --create-reflog -m "$stash_msg" $ref_stash $w_commit
 187        ret=$?
 188        test $ret != 0 && test -z $quiet &&
 189        die "$(eval_gettext "Cannot update \$ref_stash with \$w_commit")"
 190        return $ret
 191}
 192
 193save_stash () {
 194        keep_index=
 195        patch_mode=
 196        untracked=
 197        while test $# != 0
 198        do
 199                case "$1" in
 200                -k|--keep-index)
 201                        keep_index=t
 202                        ;;
 203                --no-keep-index)
 204                        keep_index=n
 205                        ;;
 206                -p|--patch)
 207                        patch_mode=t
 208                        # only default to keep if we don't already have an override
 209                        test -z "$keep_index" && keep_index=t
 210                        ;;
 211                -q|--quiet)
 212                        GIT_QUIET=t
 213                        ;;
 214                -u|--include-untracked)
 215                        untracked=untracked
 216                        ;;
 217                -a|--all)
 218                        untracked=all
 219                        ;;
 220                --help)
 221                        show_help
 222                        ;;
 223                --)
 224                        shift
 225                        break
 226                        ;;
 227                -*)
 228                        option="$1"
 229                        # TRANSLATORS: $option is an invalid option, like
 230                        # `--blah-blah'. The 7 spaces at the beginning of the
 231                        # second line correspond to "error: ". So you should line
 232                        # up the second line with however many characters the
 233                        # translation of "error: " takes in your language. E.g. in
 234                        # English this is:
 235                        #
 236                        #    $ git stash save --blah-blah 2>&1 | head -n 2
 237                        #    error: unknown option for 'stash save': --blah-blah
 238                        #           To provide a message, use git stash save -- '--blah-blah'
 239                        eval_gettextln "error: unknown option for 'stash save': \$option
 240       To provide a message, use git stash save -- '\$option'"
 241                        usage
 242                        ;;
 243                *)
 244                        break
 245                        ;;
 246                esac
 247                shift
 248        done
 249
 250        if test -n "$patch_mode" && test -n "$untracked"
 251        then
 252            die "Can't use --patch and --include-untracked or --all at the same time"
 253        fi
 254
 255        stash_msg="$*"
 256
 257        git update-index -q --refresh
 258        if no_changes
 259        then
 260                say "$(gettext "No local changes to save")"
 261                exit 0
 262        fi
 263        git reflog exists $ref_stash ||
 264                clear_stash || die "$(gettext "Cannot initialize stash")"
 265
 266        create_stash "$stash_msg" $untracked
 267        store_stash -m "$stash_msg" -q $w_commit ||
 268        die "$(gettext "Cannot save the current status")"
 269        say Saved working directory and index state "$stash_msg"
 270
 271        if test -z "$patch_mode"
 272        then
 273                git reset --hard ${GIT_QUIET:+-q}
 274                test "$untracked" = "all" && CLEAN_X_OPTION=-x || CLEAN_X_OPTION=
 275                if test -n "$untracked"
 276                then
 277                        git clean --force --quiet -d $CLEAN_X_OPTION
 278                fi
 279
 280                if test "$keep_index" = "t" && test -n $i_tree
 281                then
 282                        git read-tree --reset -u $i_tree
 283                fi
 284        else
 285                git apply -R < "$TMP-patch" ||
 286                die "$(gettext "Cannot remove worktree changes")"
 287
 288                if test "$keep_index" != "t"
 289                then
 290                        git reset
 291                fi
 292        fi
 293}
 294
 295have_stash () {
 296        git rev-parse --verify --quiet $ref_stash >/dev/null
 297}
 298
 299list_stash () {
 300        have_stash || return 0
 301        git log --format="%gd: %gs" -g --first-parent -m "$@" $ref_stash --
 302}
 303
 304show_stash () {
 305        ALLOW_UNKNOWN_FLAGS=t
 306        assert_stash_like "$@"
 307
 308        if test -z "$FLAGS"
 309        then
 310                if test "$(git config --bool stash.showStat || echo true)" = "true"
 311                then
 312                        FLAGS=--stat
 313                fi
 314
 315                if test "$(git config --bool stash.showPatch || echo false)" = "true"
 316                then
 317                        FLAGS=${FLAGS}${FLAGS:+ }-p
 318                fi
 319
 320                if test -z "$FLAGS"
 321                then
 322                        return 0
 323                fi
 324        fi
 325
 326        git diff ${FLAGS} $b_commit $w_commit
 327}
 328
 329show_help () {
 330        exec git help stash
 331        exit 1
 332}
 333
 334#
 335# Parses the remaining options looking for flags and
 336# at most one revision defaulting to ${ref_stash}@{0}
 337# if none found.
 338#
 339# Derives related tree and commit objects from the
 340# revision, if one is found.
 341#
 342# stash records the work tree, and is a merge between the
 343# base commit (first parent) and the index tree (second parent).
 344#
 345#   REV is set to the symbolic version of the specified stash-like commit
 346#   IS_STASH_LIKE is non-blank if ${REV} looks like a stash
 347#   IS_STASH_REF is non-blank if the ${REV} looks like a stash ref
 348#   s is set to the SHA1 of the stash commit
 349#   w_commit is set to the commit containing the working tree
 350#   b_commit is set to the base commit
 351#   i_commit is set to the commit containing the index tree
 352#   u_commit is set to the commit containing the untracked files tree
 353#   w_tree is set to the working tree
 354#   b_tree is set to the base tree
 355#   i_tree is set to the index tree
 356#   u_tree is set to the untracked files tree
 357#
 358#   GIT_QUIET is set to t if -q is specified
 359#   INDEX_OPTION is set to --index if --index is specified.
 360#   FLAGS is set to the remaining flags (if allowed)
 361#
 362# dies if:
 363#   * too many revisions specified
 364#   * no revision is specified and there is no stash stack
 365#   * a revision is specified which cannot be resolve to a SHA1
 366#   * a non-existent stash reference is specified
 367#   * unknown flags were set and ALLOW_UNKNOWN_FLAGS is not "t"
 368#
 369
 370parse_flags_and_rev()
 371{
 372        test "$PARSE_CACHE" = "$*" && return 0 # optimisation
 373        PARSE_CACHE="$*"
 374
 375        IS_STASH_LIKE=
 376        IS_STASH_REF=
 377        INDEX_OPTION=
 378        s=
 379        w_commit=
 380        b_commit=
 381        i_commit=
 382        u_commit=
 383        w_tree=
 384        b_tree=
 385        i_tree=
 386        u_tree=
 387
 388        REV=$(git rev-parse --no-flags --symbolic --sq "$@") || exit 1
 389
 390        FLAGS=
 391        for opt
 392        do
 393                case "$opt" in
 394                        -q|--quiet)
 395                                GIT_QUIET=-t
 396                        ;;
 397                        --index)
 398                                INDEX_OPTION=--index
 399                        ;;
 400                        --help)
 401                                show_help
 402                        ;;
 403                        -*)
 404                                test "$ALLOW_UNKNOWN_FLAGS" = t ||
 405                                        die "$(eval_gettext "unknown option: \$opt")"
 406                                FLAGS="${FLAGS}${FLAGS:+ }$opt"
 407                        ;;
 408                esac
 409        done
 410
 411        eval set -- $REV
 412
 413        case $# in
 414                0)
 415                        have_stash || die "$(gettext "No stash found.")"
 416                        set -- ${ref_stash}@{0}
 417                ;;
 418                1)
 419                        :
 420                ;;
 421                *)
 422                        die "$(eval_gettext "Too many revisions specified: \$REV")"
 423                ;;
 424        esac
 425
 426        REV=$(git rev-parse --symbolic --verify --quiet "$1") || {
 427                reference="$1"
 428                die "$(eval_gettext "\$reference is not a valid reference")"
 429        }
 430
 431        i_commit=$(git rev-parse --verify --quiet "$REV^2") &&
 432        set -- $(git rev-parse "$REV" "$REV^1" "$REV:" "$REV^1:" "$REV^2:" 2>/dev/null) &&
 433        s=$1 &&
 434        w_commit=$1 &&
 435        b_commit=$2 &&
 436        w_tree=$3 &&
 437        b_tree=$4 &&
 438        i_tree=$5 &&
 439        IS_STASH_LIKE=t &&
 440        test "$ref_stash" = "$(git rev-parse --symbolic-full-name "${REV%@*}")" &&
 441        IS_STASH_REF=t
 442
 443        u_commit=$(git rev-parse --verify --quiet "$REV^3") &&
 444        u_tree=$(git rev-parse "$REV^3:" 2>/dev/null)
 445}
 446
 447is_stash_like()
 448{
 449        parse_flags_and_rev "$@"
 450        test -n "$IS_STASH_LIKE"
 451}
 452
 453assert_stash_like() {
 454        is_stash_like "$@" || {
 455                args="$*"
 456                die "$(eval_gettext "'\$args' is not a stash-like commit")"
 457        }
 458}
 459
 460is_stash_ref() {
 461        is_stash_like "$@" && test -n "$IS_STASH_REF"
 462}
 463
 464assert_stash_ref() {
 465        is_stash_ref "$@" || {
 466                args="$*"
 467                die "$(eval_gettext "'\$args' is not a stash reference")"
 468        }
 469}
 470
 471apply_stash () {
 472
 473        assert_stash_like "$@"
 474
 475        git update-index -q --refresh || die "$(gettext "unable to refresh index")"
 476
 477        # current index state
 478        c_tree=$(git write-tree) ||
 479                die "$(gettext "Cannot apply a stash in the middle of a merge")"
 480
 481        unstashed_index_tree=
 482        if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&
 483                        test "$c_tree" != "$i_tree"
 484        then
 485                git diff-tree --binary $s^2^..$s^2 | git apply --cached
 486                test $? -ne 0 &&
 487                        die "$(gettext "Conflicts in index. Try without --index.")"
 488                unstashed_index_tree=$(git write-tree) ||
 489                        die "$(gettext "Could not save index tree")"
 490                git reset
 491        fi
 492
 493        if test -n "$u_tree"
 494        then
 495                GIT_INDEX_FILE="$TMPindex" git-read-tree "$u_tree" &&
 496                GIT_INDEX_FILE="$TMPindex" git checkout-index --all &&
 497                rm -f "$TMPindex" ||
 498                die 'Could not restore untracked files from stash'
 499        fi
 500
 501        eval "
 502                GITHEAD_$w_tree='Stashed changes' &&
 503                GITHEAD_$c_tree='Updated upstream' &&
 504                GITHEAD_$b_tree='Version stash was based on' &&
 505                export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
 506        "
 507
 508        if test -n "$GIT_QUIET"
 509        then
 510                GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY
 511        fi
 512        if git merge-recursive $b_tree -- $c_tree $w_tree
 513        then
 514                # No conflict
 515                if test -n "$unstashed_index_tree"
 516                then
 517                        git read-tree "$unstashed_index_tree"
 518                else
 519                        a="$TMP-added" &&
 520                        git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
 521                        git read-tree --reset $c_tree &&
 522                        git update-index --add --stdin <"$a" ||
 523                                die "$(gettext "Cannot unstage modified files")"
 524                        rm -f "$a"
 525                fi
 526                squelch=
 527                if test -n "$GIT_QUIET"
 528                then
 529                        squelch='>/dev/null 2>&1'
 530                fi
 531                (cd "$START_DIR" && eval "git status $squelch") || :
 532        else
 533                # Merge conflict; keep the exit status from merge-recursive
 534                status=$?
 535                git rerere
 536                if test -n "$INDEX_OPTION"
 537                then
 538                        gettextln "Index was not unstashed." >&2
 539                fi
 540                exit $status
 541        fi
 542}
 543
 544pop_stash() {
 545        assert_stash_ref "$@"
 546
 547        if apply_stash "$@"
 548        then
 549                drop_stash "$@"
 550        else
 551                status=$?
 552                say "The stash is kept in case you need it again."
 553                exit $status
 554        fi
 555}
 556
 557drop_stash () {
 558        assert_stash_ref "$@"
 559
 560        git reflog delete --updateref --rewrite "${REV}" &&
 561                say "$(eval_gettext "Dropped \${REV} (\$s)")" ||
 562                die "$(eval_gettext "\${REV}: Could not drop stash entry")"
 563
 564        # clear_stash if we just dropped the last stash entry
 565        git rev-parse --verify --quiet "$ref_stash@{0}" >/dev/null ||
 566        clear_stash
 567}
 568
 569apply_to_branch () {
 570        test -n "$1" || die "$(gettext "No branch name specified")"
 571        branch=$1
 572        shift 1
 573
 574        set -- --index "$@"
 575        assert_stash_like "$@"
 576
 577        git checkout -b $branch $REV^ &&
 578        apply_stash "$@" && {
 579                test -z "$IS_STASH_REF" || drop_stash "$@"
 580        }
 581}
 582
 583PARSE_CACHE='--not-parsed'
 584# The default command is "save" if nothing but options are given
 585seen_non_option=
 586for opt
 587do
 588        case "$opt" in
 589        -*) ;;
 590        *) seen_non_option=t; break ;;
 591        esac
 592done
 593
 594test -n "$seen_non_option" || set "save" "$@"
 595
 596# Main command set
 597case "$1" in
 598list)
 599        shift
 600        list_stash "$@"
 601        ;;
 602show)
 603        shift
 604        show_stash "$@"
 605        ;;
 606save)
 607        shift
 608        save_stash "$@"
 609        ;;
 610apply)
 611        shift
 612        apply_stash "$@"
 613        ;;
 614clear)
 615        shift
 616        clear_stash "$@"
 617        ;;
 618create)
 619        shift
 620        create_stash "$*" && echo "$w_commit"
 621        ;;
 622store)
 623        shift
 624        store_stash "$@"
 625        ;;
 626drop)
 627        shift
 628        drop_stash "$@"
 629        ;;
 630pop)
 631        shift
 632        pop_stash "$@"
 633        ;;
 634branch)
 635        shift
 636        apply_to_branch "$@"
 637        ;;
 638*)
 639        case $# in
 640        0)
 641                save_stash &&
 642                say "$(gettext "(To restore them type \"git stash apply\")")"
 643                ;;
 644        *)
 645                usage
 646        esac
 647        ;;
 648esac