git-stash.shon commit notes: Initialise variable to appease gcc (89fe121)
   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=
  15. git-sh-setup
  16require_work_tree
  17cd_to_toplevel
  18
  19TMP="$GIT_DIR/.git-stash.$$"
  20trap 'rm -f "$TMP-*"' 0
  21
  22ref_stash=refs/stash
  23
  24if git config --get-colorbool color.interactive; then
  25       help_color="$(git config --get-color color.interactive.help 'red bold')"
  26       reset_color="$(git config --get-color '' reset)"
  27else
  28       help_color=
  29       reset_color=
  30fi
  31
  32no_changes () {
  33        git diff-index --quiet --cached HEAD --ignore-submodules -- &&
  34        git diff-files --quiet --ignore-submodules
  35}
  36
  37clear_stash () {
  38        if test $# != 0
  39        then
  40                die "git stash clear with parameters is unimplemented"
  41        fi
  42        if current=$(git rev-parse --verify $ref_stash 2>/dev/null)
  43        then
  44                git update-ref -d $ref_stash $current
  45        fi
  46}
  47
  48create_stash () {
  49        stash_msg="$1"
  50
  51        git update-index -q --refresh
  52        if no_changes
  53        then
  54                exit 0
  55        fi
  56
  57        # state of the base commit
  58        if b_commit=$(git rev-parse --verify HEAD)
  59        then
  60                head=$(git log --no-color --abbrev-commit --pretty=oneline -n 1 HEAD --)
  61        else
  62                die "You do not have the initial commit yet"
  63        fi
  64
  65        if branch=$(git symbolic-ref -q HEAD)
  66        then
  67                branch=${branch#refs/heads/}
  68        else
  69                branch='(no branch)'
  70        fi
  71        msg=$(printf '%s: %s' "$branch" "$head")
  72
  73        # state of the index
  74        i_tree=$(git write-tree) &&
  75        i_commit=$(printf 'index on %s\n' "$msg" |
  76                git commit-tree $i_tree -p $b_commit) ||
  77                die "Cannot save the current index state"
  78
  79        if test -z "$patch_mode"
  80        then
  81
  82                # state of the working tree
  83                w_tree=$( (
  84                        rm -f "$TMP-index" &&
  85                        cp -p ${GIT_INDEX_FILE-"$GIT_DIR/index"} "$TMP-index" &&
  86                        GIT_INDEX_FILE="$TMP-index" &&
  87                        export GIT_INDEX_FILE &&
  88                        git read-tree -m $i_tree &&
  89                        git diff --name-only -z HEAD | git update-index -z --add --remove --stdin &&
  90                        git write-tree &&
  91                        rm -f "$TMP-index"
  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=
 140                        ;;
 141                -p|--patch)
 142                        patch_mode=t
 143                        keep_index=t
 144                        ;;
 145                -q|--quiet)
 146                        GIT_QUIET=t
 147                        ;;
 148                --)
 149                        shift
 150                        break
 151                        ;;
 152                -*)
 153                        echo "error: unknown option for 'stash save': $1"
 154                        echo "       To provide a message, use git stash save -- '$1'"
 155                        usage
 156                        ;;
 157                *)
 158                        break
 159                        ;;
 160                esac
 161                shift
 162        done
 163
 164        stash_msg="$*"
 165
 166        git update-index -q --refresh
 167        if no_changes
 168        then
 169                say 'No local changes to save'
 170                exit 0
 171        fi
 172        test -f "$GIT_DIR/logs/$ref_stash" ||
 173                clear_stash || die "Cannot initialize stash"
 174
 175        create_stash "$stash_msg"
 176
 177        # Make sure the reflog for stash is kept.
 178        : >>"$GIT_DIR/logs/$ref_stash"
 179
 180        git update-ref -m "$stash_msg" $ref_stash $w_commit ||
 181                die "Cannot save the current status"
 182        say Saved working directory and index state "$stash_msg"
 183
 184        if test -z "$patch_mode"
 185        then
 186                git reset --hard ${GIT_QUIET:+-q}
 187
 188                if test -n "$keep_index" && test -n $i_tree
 189                then
 190                        git read-tree --reset -u $i_tree
 191                fi
 192        else
 193                git apply -R < "$TMP-patch" ||
 194                die "Cannot remove worktree changes"
 195
 196                if test -z "$keep_index"
 197                then
 198                        git reset
 199                fi
 200        fi
 201}
 202
 203have_stash () {
 204        git rev-parse --verify $ref_stash >/dev/null 2>&1
 205}
 206
 207list_stash () {
 208        have_stash || return 0
 209        git log --format="%gd: %gs" -g "$@" $ref_stash --
 210}
 211
 212show_stash () {
 213        have_stash || die 'No stash found'
 214
 215        flags=$(git rev-parse --no-revs --flags "$@")
 216        if test -z "$flags"
 217        then
 218                flags=--stat
 219        fi
 220
 221        w_commit=$(git rev-parse --quiet --verify --default $ref_stash "$@") &&
 222        b_commit=$(git rev-parse --quiet --verify "$w_commit^") ||
 223                die "'$*' is not a stash"
 224
 225        git diff $flags $b_commit $w_commit
 226}
 227
 228apply_stash () {
 229        applied_stash=
 230        unstash_index=
 231
 232        while test $# != 0
 233        do
 234                case "$1" in
 235                --index)
 236                        unstash_index=t
 237                        ;;
 238                -q|--quiet)
 239                        GIT_QUIET=t
 240                        ;;
 241                *)
 242                        break
 243                        ;;
 244                esac
 245                shift
 246        done
 247
 248        if test $# = 0
 249        then
 250                have_stash || die 'Nothing to apply'
 251                applied_stash="$ref_stash@{0}"
 252        else
 253                applied_stash="$*"
 254        fi
 255
 256        # stash records the work tree, and is a merge between the
 257        # base commit (first parent) and the index tree (second parent).
 258        s=$(git rev-parse --quiet --verify --default $ref_stash "$@") &&
 259        w_tree=$(git rev-parse --quiet --verify "$s:") &&
 260        b_tree=$(git rev-parse --quiet --verify "$s^1:") &&
 261        i_tree=$(git rev-parse --quiet --verify "$s^2:") ||
 262                die "$*: no valid stashed state found"
 263
 264        git update-index -q --refresh &&
 265        git diff-files --quiet --ignore-submodules ||
 266                die 'Cannot apply to a dirty working tree, please stage your changes'
 267
 268        # current index state
 269        c_tree=$(git write-tree) ||
 270                die 'Cannot apply a stash in the middle of a merge'
 271
 272        unstashed_index_tree=
 273        if test -n "$unstash_index" && test "$b_tree" != "$i_tree" &&
 274                        test "$c_tree" != "$i_tree"
 275        then
 276                git diff-tree --binary $s^2^..$s^2 | git apply --cached
 277                test $? -ne 0 &&
 278                        die 'Conflicts in index. Try without --index.'
 279                unstashed_index_tree=$(git write-tree) ||
 280                        die 'Could not save index tree'
 281                git reset
 282        fi
 283
 284        eval "
 285                GITHEAD_$w_tree='Stashed changes' &&
 286                GITHEAD_$c_tree='Updated upstream' &&
 287                GITHEAD_$b_tree='Version stash was based on' &&
 288                export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
 289        "
 290
 291        if test -n "$GIT_QUIET"
 292        then
 293                export GIT_MERGE_VERBOSITY=0
 294        fi
 295        if git merge-recursive $b_tree -- $c_tree $w_tree
 296        then
 297                # No conflict
 298                if test -n "$unstashed_index_tree"
 299                then
 300                        git read-tree "$unstashed_index_tree"
 301                else
 302                        a="$TMP-added" &&
 303                        git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
 304                        git read-tree --reset $c_tree &&
 305                        git update-index --add --stdin <"$a" ||
 306                                die "Cannot unstage modified files"
 307                        rm -f "$a"
 308                fi
 309                squelch=
 310                if test -n "$GIT_QUIET"
 311                then
 312                        squelch='>/dev/null 2>&1'
 313                fi
 314                eval "git status $squelch" || :
 315        else
 316                # Merge conflict; keep the exit status from merge-recursive
 317                status=$?
 318                if test -n "$unstash_index"
 319                then
 320                        echo >&2 'Index was not unstashed.'
 321                fi
 322                exit $status
 323        fi
 324}
 325
 326drop_stash () {
 327        have_stash || die 'No stash entries to drop'
 328
 329        while test $# != 0
 330        do
 331                case "$1" in
 332                -q|--quiet)
 333                        GIT_QUIET=t
 334                        ;;
 335                *)
 336                        break
 337                        ;;
 338                esac
 339                shift
 340        done
 341
 342        if test $# = 0
 343        then
 344                set x "$ref_stash@{0}"
 345                shift
 346        fi
 347        # Verify supplied argument looks like a stash entry
 348        s=$(git rev-parse --verify "$@") &&
 349        git rev-parse --verify "$s:"   > /dev/null 2>&1 &&
 350        git rev-parse --verify "$s^1:" > /dev/null 2>&1 &&
 351        git rev-parse --verify "$s^2:" > /dev/null 2>&1 ||
 352                die "$*: not a valid stashed state"
 353
 354        git reflog delete --updateref --rewrite "$@" &&
 355                say "Dropped $* ($s)" || die "$*: Could not drop stash entry"
 356
 357        # clear_stash if we just dropped the last stash entry
 358        git rev-parse --verify "$ref_stash@{0}" > /dev/null 2>&1 || clear_stash
 359}
 360
 361apply_to_branch () {
 362        have_stash || die 'Nothing to apply'
 363
 364        test -n "$1" || die 'No branch name specified'
 365        branch=$1
 366
 367        if test -z "$2"
 368        then
 369                set x "$ref_stash@{0}"
 370        fi
 371        stash=$2
 372
 373        git checkout -b $branch $stash^ &&
 374        apply_stash --index $stash &&
 375        drop_stash $stash
 376}
 377
 378# The default command is "save" if nothing but options are given
 379seen_non_option=
 380for opt
 381do
 382        case "$opt" in
 383        -*) ;;
 384        *) seen_non_option=t; break ;;
 385        esac
 386done
 387
 388test -n "$seen_non_option" || set "save" "$@"
 389
 390# Main command set
 391case "$1" in
 392list)
 393        shift
 394        list_stash "$@"
 395        ;;
 396show)
 397        shift
 398        show_stash "$@"
 399        ;;
 400save)
 401        shift
 402        save_stash "$@"
 403        ;;
 404apply)
 405        shift
 406        apply_stash "$@"
 407        ;;
 408clear)
 409        shift
 410        clear_stash "$@"
 411        ;;
 412create)
 413        if test $# -gt 0 && test "$1" = create
 414        then
 415                shift
 416        fi
 417        create_stash "$*" && echo "$w_commit"
 418        ;;
 419drop)
 420        shift
 421        drop_stash "$@"
 422        ;;
 423pop)
 424        shift
 425        if apply_stash "$@"
 426        then
 427                drop_stash "$applied_stash"
 428        fi
 429        ;;
 430branch)
 431        shift
 432        apply_to_branch "$@"
 433        ;;
 434*)
 435        case $# in
 436        0)
 437                save_stash &&
 438                say '(To restore them type "git stash apply")'
 439                ;;
 440        *)
 441                usage
 442        esac
 443        ;;
 444esac