My custom patches to git-stash

git-mystash

#!/bin/sh

#Some custom additions to git-stash.sh (Copyright (c) 2007, Nanako Shiraishi)
#when I am less lazy I should try to submit them upstream

#Additions: 
# Commands: 
# - dosave (save but don't reset the worktree)
# - popbranch (pop the stash like git stash branch does, git mystash branch does not pop the stash)
# - info (info on stash)
#
# Options:
# --ref to set up the stash ref
# -b/--on-branch option on store/dosave/save and apply
ref_stash=refs/mystash

while true;
do
  case "$1" in
    -- ) shift; break ;;
    --ref) shift; ref_stash="refs/$1"; shift ;;
    *) break;;
  esac
done

prog=$(basename $0)
USAGE="[--ref ref_stash] command
$prog list [<options>]
   or: $prog show [<stash>]
   or: $prog drop [-q|--quiet] [<stash>]
   or: $prog ( pop | apply [--on-branch|-b]) [--index] [-q|--quiet] [<stash>]
   or: $prog ( branch | popbranch ) <branchname> [<stash>]
   or: $prog [dosave|save [--on-branch|-b][--patch] [-k|--[no-]keep-index] [-q|--quiet]
		       [-u|--include-untracked] [-a|--all] [<message>]]
   or: $prog clear"

SUBDIRECTORY_OK=Yes
OPTIONS_SPEC=
START_DIR=`pwd`
. $(git --exec-path)/git-sh-setup
. $(git --exec-path)/git-sh-i18n
require_work_tree
cd_to_toplevel

TMP="$GIT_DIR/.git-mystash.$$"
TMPindex=${GIT_INDEX_FILE-"$GIT_DIR/index"}.mystash.$$
trap 'rm -f "$TMP-"* "$TMPindex"' 0

if git config --get-colorbool color.interactive; then
       help_color="$(git config --get-color color.interactive.help 'red bold')"
       reset_color="$(git config --get-color '' reset)"
else
       help_color=
       reset_color=
fi

#update these functions so that they can take a ref as argument
no_changes () {
	git diff-index --quiet --cached HEAD --ignore-submodules -- &&
	git diff-files --quiet --ignore-submodules &&
	(test -z "$untracked" || test -z "$(untracked_files)")
}

untracked_files () {
	excl_opt=--exclude-standard
	test "$untracked" = "all" && excl_opt=
	git ls-files -o -z $excl_opt
}

clear_stash () {
	if test $# != 0
	then
		die "$(gettext "git stash clear with parameters is unimplemented")"
	fi
	if current=$(git rev-parse --verify $ref_stash 2>/dev/null)
	then
		git update-ref -d $ref_stash $current
	fi
}

create_stash () {
	stash_msg="$1"
	untracked="$2"

	git update-index -q --refresh
	if no_changes
	then
		exit 0
	fi

	# state of the base commit
	if b_commit=$(git rev-parse --verify HEAD)
	then
		head=$(git rev-list --oneline -n 1 HEAD --)
	else
		die "$(gettext "You do not have the initial commit yet")"
	fi

	if branch=$(git symbolic-ref -q HEAD)
	then
		branch=${branch#refs/heads/}
	else
		branch='(no branch)'
	fi
	msg=$(printf '%s: %s' "$branch" "$head")

	# state of the index
	i_tree=$(git write-tree) &&
	i_commit=$(printf 'index on %s\n' "$msg" |
		git commit-tree $i_tree -p $b_commit) ||
		die "$(gettext "Cannot save the current index state")"

	if test -n "$untracked"
	then
		# Untracked files are stored by themselves in a parentless commit, for
		# ease of unpacking later.
		u_commit=$(
			untracked_files | (
				export GIT_INDEX_FILE="$TMPindex"
				rm -f "$TMPindex" &&
				git update-index -z --add --remove --stdin &&
				u_tree=$(git write-tree) &&
				printf 'untracked files on %s\n' "$msg" | git commit-tree $u_tree  &&
				rm -f "$TMPindex"
		) ) || die "Cannot save the untracked files"

		untracked_commit_option="-p $u_commit";
	else
		untracked_commit_option=
	fi

	if test -z "$patch_mode"
	then

		# state of the working tree
		w_tree=$( (
			git read-tree --index-output="$TMPindex" -m $i_tree &&
			GIT_INDEX_FILE="$TMPindex" &&
			export GIT_INDEX_FILE &&
			git diff --name-only -z HEAD -- >"$TMP-stagenames" &&
			git update-index -z --add --remove --stdin <"$TMP-stagenames" &&
			git write-tree &&
			rm -f "$TMPindex"
		) ) ||
			die "$(gettext "Cannot save the current worktree state")"

	else

		rm -f "$TMP-index" &&
		GIT_INDEX_FILE="$TMP-index" git read-tree HEAD &&

		# find out what the user wants
		GIT_INDEX_FILE="$TMP-index" \
			git add--interactive --patch=stash -- &&

		# state of the working tree
		w_tree=$(GIT_INDEX_FILE="$TMP-index" git write-tree) ||
		die "$(gettext "Cannot save the current worktree state")"

		git diff-tree -p HEAD $w_tree -- >"$TMP-patch" &&
		test -s "$TMP-patch" ||
		die "$(gettext "No changes selected")"

		rm -f "$TMP-index" ||
		die "$(gettext "Cannot remove temporary index (can't happen)")"

	fi

	# create the stash
	if test -z "$stash_msg"
	then
		stash_msg=$(printf 'WIP on %s' "$msg")
	else
		stash_msg=$(printf 'On %s: %s' "$branch" "$stash_msg")
	fi
	w_commit=$(printf '%s\n' "$stash_msg" |
	git commit-tree $w_tree -p $b_commit -p $i_commit $untracked_commit_option) ||
	die "$(gettext "Cannot record working tree state")"
}

store_stash () {
	onbranch=
	while test $# != 0
	do
		case "$1" in
		-m|--message)
			shift
			stash_msg="$1"
			;;
		-q|--quiet)
			quiet=t
			;;
		-b|--on-branch)
			onbranch=t
			;;
		*)
			break
			;;
		esac
		shift
	done
	test $# = 1 ||
	die "$(eval_gettext "\"$dashless store\" requires one <commit> argument")"

	w_commit="$1"
	if test -z "$stash_msg"
	then
		stash_msg="Created via \"git stash store\"."
	fi

	if test -z "$onbranch"
	then
		# Make sure the reflog for stash is kept.
		mkdir -p $(dirname "$GIT_DIR/logs/$ref_stash")
		: >>"$GIT_DIR/logs/$ref_stash"
		git update-ref -m "$stash_msg" $ref_stash $w_commit
	else
		git update-ref -m "$stash_msg" HEAD $w_commit
	fi
	ret=$?
	test $ret != 0 && test -z $quiet &&
	die "$(eval_gettext "Cannot update \$ref_stash with \$w_commit")"
	return $ret
}

#like save_stash, but don't drop the worktree afterwards
dosave_stash () {
	keep_index=
	patch_mode=
	untracked=
	onbranch=
	while test $# != 0
	do
		case "$1" in
		-k|--keep-index)
			keep_index=t
			;;
		--no-keep-index)
			keep_index=n
			;;
		-p|--patch)
			patch_mode=t
			# only default to keep if we don't already have an override
			test -z "$keep_index" && keep_index=t
			;;
		-q|--quiet)
			GIT_QUIET=t
			;;
		-u|--include-untracked)
			untracked=untracked
			;;
		-a|--all)
			untracked=all
			;;
		-b|--on-branch)
			onbranch="--on-branch"
			;;
		--)
			shift
			break
			;;
		-*)
			option="$1"
			eval_gettextln "error: unknown option for 'stash save': \$option
       To provide a message, use git stash save -- '\$option'"
			usage
			;;
		*)
			break
			;;
		esac
		shift
	done

	if test -n "$patch_mode" && test -n "$untracked"
	then
	    die "Can't use --patch and --include-untracked or --all at the same time"
	fi

	stash_msg="$*"

	git update-index -q --refresh
	if no_changes
	then
		say "$(gettext "No local changes to save")"
		exit 0
	fi
	test -f "$GIT_DIR/logs/$ref_stash" ||
		clear_stash || die "$(gettext "Cannot initialize stash")"

	create_stash "$stash_msg" $untracked
	store_stash $onbranch -m "$stash_msg" -q $w_commit ||
	die "$(gettext "Cannot save the current status")"
	say Saved working directory and index state "$stash_msg"
}
save_stash () {
	dosave_stash "$@"

	if test -z "$patch_mode"
	then
		git reset --hard ${GIT_QUIET:+-q}
		test "$untracked" = "all" && CLEAN_X_OPTION=-x || CLEAN_X_OPTION=
		if test -n "$untracked"
		then
			git clean --force --quiet -d $CLEAN_X_OPTION
		fi

		if test "$keep_index" = "t" && test -n $i_tree
		then
			git read-tree --reset -u $i_tree
		fi
	else
		git apply -R < "$TMP-patch" ||
		die "$(gettext "Cannot remove worktree changes")"

		if test "$keep_index" != "t"
		then
			git reset
		fi
	fi
}

have_stash () {
	git rev-parse --verify $ref_stash >/dev/null 2>&1
}

list_stash () {
	have_stash || return 0
	git log --format="%gd: %gs" -g "$@" $ref_stash --
}

show_stash () {
	assert_stash_like "$@"

	git diff ${FLAGS:---stat} $b_commit $w_commit
}

#
# Parses the remaining options looking for flags and
# at most one revision defaulting to ${ref_stash}@{0}
# if none found.
#
# Derives related tree and commit objects from the
# revision, if one is found.
#
# stash records the work tree, and is a merge between the
# base commit (first parent) and the index tree (second parent).
#
#   REV is set to the symbolic version of the specified stash-like commit
#   IS_STASH_LIKE is non-blank if ${REV} looks like a stash
#   IS_STASH_REF is non-blank if the ${REV} looks like a stash ref
#   s is set to the SHA1 of the stash commit
#   w_commit is set to the commit containing the working tree
#   b_commit is set to the base commit
#   i_commit is set to the commit containing the index tree
#   u_commit is set to the commit containing the untracked files tree
#   w_tree is set to the working tree
#   b_tree is set to the base tree
#   i_tree is set to the index tree
#   u_tree is set to the untracked files tree
#
#   GIT_QUIET is set to t if -q is specified
#   INDEX_OPTION is set to --index if --index is specified.
#   FLAGS is set to the remaining flags
#
# dies if:
#   * too many revisions specified
#   * no revision is specified and there is no stash stack
#   * a revision is specified which cannot be resolve to a SHA1
#   * a non-existent stash reference is specified
#

parse_flags_and_rev()
{
	test "$PARSE_CACHE" = "$*" && return 0 # optimisation
	PARSE_CACHE="$*"

	IS_STASH_LIKE=
	IS_STASH_REF=
	INDEX_OPTION=
	s=
	w_commit=
	b_commit=
	i_commit=
	u_commit=
	w_tree=
	b_tree=
	i_tree=
	u_tree=

	REV=$(git rev-parse --no-flags --symbolic "$@") || exit 1

	onbranch=
	FLAGS=
	for opt
	do
		case "$opt" in
			-q|--quiet)
				GIT_QUIET=-t
			;;
			--index)
				INDEX_OPTION=--index
			;;
			-b|--on-branch)
				onbranch=t
				;;
			-*)
				FLAGS="${FLAGS}${FLAGS:+ }$opt"
			;;
		esac
	done

	set -- $REV

	case $# in
		0)
			if test -z "$onbranch"
			then
				have_stash || die "$(gettext "No stash found.")"
				set -- ${ref_stash}@{0}
			else
				set -- HEAD
			fi
		;;
		1)
			test -n "$onbranch" && die "$(eval_gettext "--on-branch is incompatible with passing a revision: \$REV")"
			:
		;;
		*)
			die "$(eval_gettext "Too many revisions specified: \$REV")"
		;;
	esac

	REV=$(git rev-parse --quiet --symbolic --verify $1 2>/dev/null) || {
		reference="$1"
		die "$(eval_gettext "\$reference is not valid reference")"
	}

	i_commit=$(git rev-parse --quiet --verify $REV^2 2>/dev/null) &&
	set -- $(git rev-parse $REV $REV^1 $REV: $REV^1: $REV^2: 2>/dev/null) &&
	s=$1 &&
	w_commit=$1 &&
	b_commit=$2 &&
	w_tree=$3 &&
	b_tree=$4 &&
	i_tree=$5 &&
	IS_STASH_LIKE=t &&
	test "$ref_stash" = "$(git rev-parse --symbolic-full-name "${REV%@*}")" &&
	IS_STASH_REF=t

	u_commit=$(git rev-parse --quiet --verify $REV^3 2>/dev/null) &&
	u_tree=$(git rev-parse $REV^3: 2>/dev/null)
}

is_stash_like()
{
	parse_flags_and_rev "$@"
	test -n "$IS_STASH_LIKE"
}

assert_stash_like() {
	is_stash_like "$@" || {
		args="$*"
		die "$(eval_gettext "'\$args' is not a stash-like commit")"
	}
}

is_stash_ref() {
	is_stash_like "$@" && test -n "$IS_STASH_REF"
}

assert_stash_ref() {
	is_stash_ref "$@" || {
		args="$*"
		die "$(eval_gettext "'\$args' is not a stash reference")"
	}
}

apply_stash () {

	assert_stash_like "$@"

	git update-index -q --refresh || die "$(gettext "unable to refresh index")"

	# current index state
	c_tree=$(git write-tree) ||
		die "$(gettext "Cannot apply a stash in the middle of a merge")"

	if test -n "$onbranch"
	then
		stash_msg="Moved back via \"$prog $@\"."
		git update-ref -m "$stash_msg" HEAD $b_commit ||
			die "$(eval_gettext "Could not move back on \${b_commit}")"
	fi

	unstashed_index_tree=
	if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&
			test "$c_tree" != "$i_tree"
	then
		git diff-tree --binary $s^2^..$s^2 | git apply --cached
		test $? -ne 0 &&
			die "$(gettext "Conflicts in index. Try without --index.")"
		unstashed_index_tree=$(git write-tree) ||
			die "$(gettext "Could not save index tree")"
		git reset
	fi

	if test -n "$u_tree"
	then
		GIT_INDEX_FILE="$TMPindex" git-read-tree "$u_tree" &&
		GIT_INDEX_FILE="$TMPindex" git checkout-index --all &&
		rm -f "$TMPindex" ||
		die 'Could not restore untracked files from stash'
	fi

	eval "
		GITHEAD_$w_tree='Stashed changes' &&
		GITHEAD_$c_tree='Updated upstream' &&
		GITHEAD_$b_tree='Version stash was based on' &&
		export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
	"

	if test -n "$GIT_QUIET"
	then
		GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY
	fi
	if git merge-recursive $b_tree -- $c_tree $w_tree
	then
		# No conflict
		if test -n "$unstashed_index_tree"
		then
			git read-tree "$unstashed_index_tree"
		else
			a="$TMP-added" &&
			git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
			git read-tree --reset $c_tree &&
			git update-index --add --stdin <"$a" ||
				die "$(gettext "Cannot unstage modified files")"
			rm -f "$a"
		fi
		squelch=
		if test -n "$GIT_QUIET"
		then
			squelch='>/dev/null 2>&1'
		fi
		(cd "$START_DIR" && eval "git status $squelch") || :
	else
		# Merge conflict; keep the exit status from merge-recursive
		status=$?
		git rerere
		if test -n "$INDEX_OPTION"
		then
			gettextln "Index was not unstashed." >&2
		fi
		exit $status
	fi
}

pop_stash() {
	assert_stash_ref "$@"
	apply_stash "$@" &&
	drop_stash "$@"
}

drop_stash () {
	assert_stash_ref "$@"

	git reflog delete --updateref --rewrite "${REV}" &&
		say "$(eval_gettext "Dropped \${REV} (\$s)")" ||
		die "$(eval_gettext "\${REV}: Could not drop stash entry")"

	# clear_stash if we just dropped the last stash entry
	git rev-parse --verify "$ref_stash@{0}" >/dev/null 2>&1 || clear_stash
}

pop_apply_to_branch () {
	apply_to_branch "$@" && {
		test -z "$IS_STASH_REF" || drop_stash "$@"
	}
}
apply_to_branch () {
	test -n "$1" || die "$(gettext "No branch name specified")"
	branch=$1
	shift 1

	set -- --index "$@"
	assert_stash_like "$@"

	git checkout -b $branch $REV^ &&
	apply_stash "$@"
}

info_stash() {
	assert_stash_like "$@"
#   REV is set to the symbolic version of the specified stash-like commit
#   IS_STASH_LIKE is non-blank if ${REV} looks like a stash
#   IS_STASH_REF is non-blank if the ${REV} looks like a stash ref
#   s is set to the SHA1 of the stash commit
#   w_commit is set to the commit containing the working tree
#   b_commit is set to the base commit
#   i_commit is set to the commit containing the index tree
#   u_commit is set to the commit containing the untracked files tree
#   w_tree is set to the working tree
#   b_tree is set to the base tree
#   i_tree is set to the index tree
#   u_tree is set to the untracked files tree
	first="Rev: $REV"
	[ -z "$IS_STASH_REF" ] && first+=" (not a stash ref)"
	first+=", stash: $s"
	echo $first
	echo "Commits - base: $b_commit, worktree: $w_commit, index: $i_commit, untracked: $u_commit"
}

PARSE_CACHE='--not-parsed'
# The default command is "save" if nothing but options are given
seen_non_option=
for opt
do
	case "$opt" in
	-*) ;;
	*) seen_non_option=t; break ;;
	esac
done

test -n "$seen_non_option" || set "save" "$@"

# Main command set
case "$1" in
  #take only options as arguments
clear) shift; clear_stash "$@" ;;
list) shift; list_stash "$@" ;;

  #arguments: 'stash message', 'untracked_mode'
create) shift; create_stash "$*" && echo "$w_commit" ;;
  #arguments: 'commit', 'stash message'
store) shift; store_stash "$@" ;;
  #arguments: options, 'stash message'
save) shift; save_stash "$@" ;;
#same as save, but don't reset the worktree afterwards
dosave) shift; dosave_stash "$@" ;;

  #take any commit that looks like a stash
show) shift; show_stash "$@" ;;
apply) shift; apply_stash "$@" ;;
#git stash branch pop the stash (if it is in $ref_stash), but I prefer not
#to do this by default, so I renamed the function apply_to_branch from git
#stash as pop_apply_to_branch
branch) shift; apply_to_branch "$@" ;;
popbranch) shift; pop_apply_to_branch "$@" ;;

  #take any commit that is inside $ref_stash
drop) shift; drop_stash "$@" ;;
pop) shift; pop_stash "$@" ;;

  #take any commit that looks like a stash
info) shift; info_stash "$@" ;;

*) case $# in
  0) save_stash &&
  say "$(gettext "(To restore them type \"git stash apply\")")" ;;
  *) usage ;;
  esac 
  ;;
esac

git-mystash is adapted from git/git-stash.sh, and has the following
(mis)features added:

• There is a global --ref option that allows to specify the reference the
  stash will use (by default this is refs/mystash, git-stash.sh uses
  refs/stash).

  This allows to differenciate between different uses of stashes: save WIP
  before switching branch; keep a backup before a git reset;...

• There is a new command git mystash dosave that works like git stash but
  does not reset the worktree afterwards. Note that git stash create
  already does that, but it handles options differently than git stash save.
  git mystash dosave can be seen as a wrapper around git stash create.
  The reason is that while git stash create is intended for scripts, git mystash dosave
  is intended for the UI. One example of when we don't want to drop the worktree is
  when we want to do a git checkout -m -- paths but we want to save the current state
  in case the merge has conflicts.

• git stash branch pops the stash once the branch is created. I did not
  like this feature so git mystash branch does not pop the stash; use
  git mystash popbranch to have the original meaning of git stash branch.

• git mystash save (and git stash dosave) has a new option
  --on-branch which stores the stash onto the current branch rather than
  in $ref_stash. The idea is that when I use git stash for a WIP, then
  when I come back to the original branch I always forget that I had a
  stash for this branch, and if there were several WIP in between it can be
  hard to remember which stash to apply. With --on-branch, when I come
  back to the original branch I am now on the stash, and I know I just need
  to apply it. For that git mystash apply (or git mystash pop) also has
  a --on-branch option that tells it to use the stash on the current
  branch.

• git mystash info gives informations about a stash.