git-stash.shon commit git-config: Remove extra whitespaces (8b59007)
   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] [<message>]]
  11   or: $dashless clear"
  12
  13SUBDIRECTORY_OK=Yes
  14OPTIONS_SPEC=
  15START_DIR=`pwd`
  16. git-sh-setup
  17require_work_tree
  18cd_to_toplevel
  19
  20TMP="$GIT_DIR/.git-stash.$$"
  21TMPindex=${GIT_INDEX_FILE-"$GIT_DIR/index"}.stash.$$
  22trap 'rm -f "$TMP-"* "$TMPindex"' 0
  23
  24ref_stash=refs/stash
  25
  26if git config --get-colorbool color.interactive; then
  27       help_color="$(git config --get-color color.interactive.help 'red bold')"
  28       reset_color="$(git config --get-color '' reset)"
  29else
  30       help_color=
  31       reset_color=
  32fi
  33
  34no_changes () {
  35        git diff-index --quiet --cached HEAD --ignore-submodules -- &&
  36        git diff-files --quiet --ignore-submodules
  37}
  38
  39clear_stash () {
  40        if test $# != 0
  41        then
  42                die "git stash clear with parameters is unimplemented"
  43        fi
  44        if current=$(git rev-parse --verify $ref_stash 2>/dev/null)
  45        then
  46                git update-ref -d $ref_stash $current
  47        fi
  48}
  49
  50create_stash () {
  51        stash_msg="$1"
  52
  53        git update-index -q --refresh
  54        if no_changes
  55        then
  56                exit 0
  57        fi
  58
  59        # state of the base commit
  60        if b_commit=$(git rev-parse --verify HEAD)
  61        then
  62                head=$(git rev-list --oneline -n 1 HEAD --)
  63        else
  64                die "You do not have the initial commit yet"
  65        fi
  66
  67        if branch=$(git symbolic-ref -q HEAD)
  68        then
  69                branch=${branch#refs/heads/}
  70        else
  71                branch='(no branch)'
  72        fi
  73        msg=$(printf '%s: %s' "$branch" "$head")
  74
  75        # state of the index
  76        i_tree=$(git write-tree) &&
  77        i_commit=$(printf 'index on %s\n' "$msg" |
  78                git commit-tree $i_tree -p $b_commit) ||
  79                die "Cannot save the current index state"
  80
  81        if test -z "$patch_mode"
  82        then
  83
  84                # state of the working tree
  85                w_tree=$( (
  86                        git read-tree --index-output="$TMPindex" -m $i_tree &&
  87                        GIT_INDEX_FILE="$TMPindex" &&
  88                        export GIT_INDEX_FILE &&
  89                        git diff --name-only -z HEAD | git update-index -z --add --remove --stdin &&
  90                        git write-tree &&
  91                        rm -f "$TMPindex"
  92                ) ) ||
  93                        die "Cannot save the current worktree state"
  94
  95        else
  96
  97                rm -f "$TMP-index" &&
  98                GIT_INDEX_FILE="$TMP-index" git read-tree HEAD &&
  99
 100                # find out what the user wants
 101                GIT_INDEX_FILE="$TMP-index" \
 102                        git add--interactive --patch=stash -- &&
 103
 104                # state of the working tree
 105                w_tree=$(GIT_INDEX_FILE="$TMP-index" git write-tree) ||
 106                die "Cannot save the current worktree state"
 107
 108                git diff-tree -p HEAD $w_tree > "$TMP-patch" &&
 109                test -s "$TMP-patch" ||
 110                die "No changes selected"
 111
 112                rm -f "$TMP-index" ||
 113                die "Cannot remove temporary index (can't happen)"
 114
 115        fi
 116
 117        # create the stash
 118        if test -z "$stash_msg"
 119        then
 120                stash_msg=$(printf 'WIP on %s' "$msg")
 121        else
 122                stash_msg=$(printf 'On %s: %s' "$branch" "$stash_msg")
 123        fi
 124        w_commit=$(printf '%s\n' "$stash_msg" |
 125                git commit-tree $w_tree -p $b_commit -p $i_commit) ||
 126                die "Cannot record working tree state"
 127}
 128
 129save_stash () {
 130        keep_index=
 131        patch_mode=
 132        while test $# != 0
 133        do
 134                case "$1" in
 135                -k|--keep-index)
 136                        keep_index=t
 137                        ;;
 138                --no-keep-index)
 139                        keep_index=n
 140                        ;;
 141                -p|--patch)
 142                        patch_mode=t
 143                        # only default to keep if we don't already have an override
 144                        test -z "$keep_index" && keep_index=t
 145                        ;;
 146                -q|--quiet)
 147                        GIT_QUIET=t
 148                        ;;
 149                --)
 150                        shift
 151                        break
 152                        ;;
 153                -*)
 154                        echo "error: unknown option for 'stash save': $1"
 155                        echo "       To provide a message, use git stash save -- '$1'"
 156                        usage
 157                        ;;
 158                *)
 159                        break
 160                        ;;
 161                esac
 162                shift
 163        done
 164
 165        stash_msg="$*"
 166
 167        git update-index -q --refresh
 168        if no_changes
 169        then
 170                say 'No local changes to save'
 171                exit 0
 172        fi
 173        test -f "$GIT_DIR/logs/$ref_stash" ||
 174                clear_stash || die "Cannot initialize stash"
 175
 176        create_stash "$stash_msg"
 177
 178        # Make sure the reflog for stash is kept.
 179        : >>"$GIT_DIR/logs/$ref_stash"
 180
 181        git update-ref -m "$stash_msg" $ref_stash $w_commit ||
 182                die "Cannot save the current status"
 183        say Saved working directory and index state "$stash_msg"
 184
 185        if test -z "$patch_mode"
 186        then
 187                git reset --hard ${GIT_QUIET:+-q}
 188
 189                if test "$keep_index" = "t" && test -n $i_tree
 190                then
 191                        git read-tree --reset -u $i_tree
 192                fi
 193        else
 194                git apply -R < "$TMP-patch" ||
 195                die "Cannot remove worktree changes"
 196
 197                if test "$keep_index" != "t"
 198                then
 199                        git reset
 200                fi
 201        fi
 202}
 203
 204have_stash () {
 205        git rev-parse --verify $ref_stash >/dev/null 2>&1
 206}
 207
 208list_stash () {
 209        have_stash || return 0
 210        git log --format="%gd: %gs" -g "$@" $ref_stash --
 211}
 212
 213show_stash () {
 214        assert_stash_like "$@"
 215
 216        git diff ${FLAGS:---stat} $b_commit $w_commit
 217}
 218
 219#
 220# Parses the remaining options looking for flags and
 221# at most one revision defaulting to ${ref_stash}@{0}
 222# if none found.
 223#
 224# Derives related tree and commit objects from the
 225# revision, if one is found.
 226#
 227# stash records the work tree, and is a merge between the
 228# base commit (first parent) and the index tree (second parent).
 229#
 230#   REV is set to the symbolic version of the specified stash-like commit
 231#   IS_STASH_LIKE is non-blank if ${REV} looks like a stash
 232#   IS_STASH_REF is non-blank if the ${REV} looks like a stash ref
 233#   s is set to the SHA1 of the stash commit
 234#   w_commit is set to the commit containing the working tree
 235#   b_commit is set to the base commit
 236#   i_commit is set to the commit containing the index tree
 237#   w_tree is set to the working tree
 238#   b_tree is set to the base tree
 239#   i_tree is set to the index tree
 240#
 241#   GIT_QUIET is set to t if -q is specified
 242#   INDEX_OPTION is set to --index if --index is specified.
 243#   FLAGS is set to the remaining flags
 244#
 245# dies if:
 246#   * too many revisions specified
 247#   * no revision is specified and there is no stash stack
 248#   * a revision is specified which cannot be resolve to a SHA1
 249#   * a non-existent stash reference is specified
 250#
 251
 252parse_flags_and_rev()
 253{
 254        test "$PARSE_CACHE" = "$*" && return 0 # optimisation
 255        PARSE_CACHE="$*"
 256
 257        IS_STASH_LIKE=
 258        IS_STASH_REF=
 259        INDEX_OPTION=
 260        s=
 261        w_commit=
 262        b_commit=
 263        i_commit=
 264        w_tree=
 265        b_tree=
 266        i_tree=
 267
 268        REV=$(git rev-parse --no-flags --symbolic "$@") || exit 1
 269
 270        FLAGS=
 271        for opt
 272        do
 273                case "$opt" in
 274                        -q|--quiet)
 275                                GIT_QUIET=-t
 276                        ;;
 277                        --index)
 278                                INDEX_OPTION=--index
 279                        ;;
 280                        -*)
 281                                FLAGS="${FLAGS}${FLAGS:+ }$opt"
 282                        ;;
 283                esac
 284        done
 285
 286        set -- $REV
 287
 288        case $# in
 289                0)
 290                        have_stash || die "No stash found."
 291                        set -- ${ref_stash}@{0}
 292                ;;
 293                1)
 294                        :
 295                ;;
 296                *)
 297                        die "Too many revisions specified: $REV"
 298                ;;
 299        esac
 300
 301        REV=$(git rev-parse --quiet --symbolic --verify $1 2>/dev/null) || die "$1 is not valid reference"
 302
 303        i_commit=$(git rev-parse --quiet --verify $REV^2 2>/dev/null) &&
 304        set -- $(git rev-parse $REV $REV^1 $REV: $REV^1: $REV^2: 2>/dev/null) &&
 305        s=$1 &&
 306        w_commit=$1 &&
 307        b_commit=$2 &&
 308        w_tree=$3 &&
 309        b_tree=$4 &&
 310        i_tree=$5 &&
 311        IS_STASH_LIKE=t &&
 312        test "$ref_stash" = "$(git rev-parse --symbolic-full-name "${REV%@*}")" &&
 313        IS_STASH_REF=t
 314}
 315
 316is_stash_like()
 317{
 318        parse_flags_and_rev "$@"
 319        test -n "$IS_STASH_LIKE"
 320}
 321
 322assert_stash_like() {
 323        is_stash_like "$@" || die "'$*' is not a stash-like commit"
 324}
 325
 326is_stash_ref() {
 327        is_stash_like "$@" && test -n "$IS_STASH_REF"
 328}
 329
 330assert_stash_ref() {
 331        is_stash_ref "$@" || die "'$*' is not a stash reference"
 332}
 333
 334apply_stash () {
 335
 336        assert_stash_like "$@"
 337
 338        git update-index -q --refresh || die 'unable to refresh index'
 339
 340        # current index state
 341        c_tree=$(git write-tree) ||
 342                die 'Cannot apply a stash in the middle of a merge'
 343
 344        unstashed_index_tree=
 345        if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&
 346                        test "$c_tree" != "$i_tree"
 347        then
 348                git diff-tree --binary $s^2^..$s^2 | git apply --cached
 349                test $? -ne 0 &&
 350                        die 'Conflicts in index. Try without --index.'
 351                unstashed_index_tree=$(git write-tree) ||
 352                        die 'Could not save index tree'
 353                git reset
 354        fi
 355
 356        eval "
 357                GITHEAD_$w_tree='Stashed changes' &&
 358                GITHEAD_$c_tree='Updated upstream' &&
 359                GITHEAD_$b_tree='Version stash was based on' &&
 360                export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
 361        "
 362
 363        if test -n "$GIT_QUIET"
 364        then
 365                GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY
 366        fi
 367        if git merge-recursive $b_tree -- $c_tree $w_tree
 368        then
 369                # No conflict
 370                if test -n "$unstashed_index_tree"
 371                then
 372                        git read-tree "$unstashed_index_tree"
 373                else
 374                        a="$TMP-added" &&
 375                        git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
 376                        git read-tree --reset $c_tree &&
 377                        git update-index --add --stdin <"$a" ||
 378                                die "Cannot unstage modified files"
 379                        rm -f "$a"
 380                fi
 381                squelch=
 382                if test -n "$GIT_QUIET"
 383                then
 384                        squelch='>/dev/null 2>&1'
 385                fi
 386                (cd "$START_DIR" && eval "git status $squelch") || :
 387        else
 388                # Merge conflict; keep the exit status from merge-recursive
 389                status=$?
 390                if test -n "$INDEX_OPTION"
 391                then
 392                        echo >&2 'Index was not unstashed.'
 393                fi
 394                exit $status
 395        fi
 396}
 397
 398pop_stash() {
 399        assert_stash_ref "$@"
 400
 401        apply_stash "$@" &&
 402        drop_stash "$@"
 403}
 404
 405drop_stash () {
 406        assert_stash_ref "$@"
 407
 408        git reflog delete --updateref --rewrite "${REV}" &&
 409                say "Dropped ${REV} ($s)" || die "${REV}: Could not drop stash entry"
 410
 411        # clear_stash if we just dropped the last stash entry
 412        git rev-parse --verify "$ref_stash@{0}" > /dev/null 2>&1 || clear_stash
 413}
 414
 415apply_to_branch () {
 416        test -n "$1" || die 'No branch name specified'
 417        branch=$1
 418        shift 1
 419
 420        set -- --index "$@"
 421        assert_stash_like "$@"
 422
 423        git checkout -b $branch $REV^ &&
 424        apply_stash "$@" && {
 425                test -z "$IS_STASH_REF" || drop_stash "$@"
 426        }
 427}
 428
 429PARSE_CACHE='--not-parsed'
 430# The default command is "save" if nothing but options are given
 431seen_non_option=
 432for opt
 433do
 434        case "$opt" in
 435        -*) ;;
 436        *) seen_non_option=t; break ;;
 437        esac
 438done
 439
 440test -n "$seen_non_option" || set "save" "$@"
 441
 442# Main command set
 443case "$1" in
 444list)
 445        shift
 446        list_stash "$@"
 447        ;;
 448show)
 449        shift
 450        show_stash "$@"
 451        ;;
 452save)
 453        shift
 454        save_stash "$@"
 455        ;;
 456apply)
 457        shift
 458        apply_stash "$@"
 459        ;;
 460clear)
 461        shift
 462        clear_stash "$@"
 463        ;;
 464create)
 465        if test $# -gt 0 && test "$1" = create
 466        then
 467                shift
 468        fi
 469        create_stash "$*" && echo "$w_commit"
 470        ;;
 471drop)
 472        shift
 473        drop_stash "$@"
 474        ;;
 475pop)
 476        shift
 477        pop_stash "$@"
 478        ;;
 479branch)
 480        shift
 481        apply_to_branch "$@"
 482        ;;
 483*)
 484        case $# in
 485        0)
 486                save_stash &&
 487                say '(To restore them type "git stash apply")'
 488                ;;
 489        *)
 490                usage
 491        esac
 492        ;;
 493esac