[thirdparty/git.git] / git-legacy-stash.sh

#!/bin/sh
# Copyright (c) 2007, Nanako Shiraishi

dashless=$(basename "$0" | sed -e 's/-/ /')
USAGE="list [<options>]
   or: $dashless show [<stash>]
   or: $dashless drop [-q|--quiet] [<stash>]
   or: $dashless ( pop | apply ) [--index] [-q|--quiet] [<stash>]
   or: $dashless branch <branchname> [<stash>]
   or: $dashless save [--patch] [-k|--[no-]keep-index] [-q|--quiet]
		      [-u|--include-untracked] [-a|--all] [<message>]
   or: $dashless [push [--patch] [-k|--[no-]keep-index] [-q|--quiet]
		       [-u|--include-untracked] [-a|--all] [-m <message>]
		       [-- <pathspec>...]]
   or: $dashless clear"

SUBDIRECTORY_OK=Yes
OPTIONS_SPEC=
START_DIR=$(pwd)
. git-sh-setup
require_work_tree
prefix=$(git rev-parse --show-prefix) || exit 1
cd_to_toplevel

TMP="$GIT_DIR/.git-stash.$$"
TMPindex=${GIT_INDEX_FILE-"$(git rev-parse --git-path index)"}.stash.$$
trap 'rm -f "$TMP-"* "$TMPindex"' 0

ref_stash=refs/stash

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

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 () {
	if test "$1" = "-z"
	then
		shift
		z=-z
	else
		z=
	fi
	excl_opt=--exclude-standard
	test "$untracked" = "all" && excl_opt=
	git ls-files -o $z $excl_opt -- "$@"
}

prepare_fallback_ident () {
	if ! git -c user.useconfigonly=yes var GIT_COMMITTER_IDENT >/dev/null 2>&1
	then
		GIT_AUTHOR_NAME="git stash"
		GIT_AUTHOR_EMAIL=git@stash
		GIT_COMMITTER_NAME="git stash"
		GIT_COMMITTER_EMAIL=git@stash
		export GIT_AUTHOR_NAME
		export GIT_AUTHOR_EMAIL
		export GIT_COMMITTER_NAME
		export GIT_COMMITTER_EMAIL
	fi
}

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

maybe_quiet () {
	case "$1" in
	--keep-stdout)
		shift
		if test -n "$GIT_QUIET"
		then
			"$@" 2>/dev/null
		else
			"$@"
		fi
		;;
	*)
		if test -n "$GIT_QUIET"
		then
			"$@" >/dev/null 2>&1
		else
			"$@"
		fi
		;;
	esac
}

create_stash () {

	prepare_fallback_ident

	stash_msg=
	untracked=
	while test $# != 0
	do
		case "$1" in
		-m|--message)
			shift
			stash_msg=${1?"BUG: create_stash () -m requires an argument"}
			;;
		-m*)
			stash_msg=${1#-m}
			;;
		--message=*)
			stash_msg=${1#--message=}
			;;
		-u|--include-untracked)
			shift
			untracked=${1?"BUG: create_stash () -u requires an argument"}
			;;
		--)
			shift
			break
			;;
		esac
		shift
	done

	git update-index -q --refresh
	if maybe_quiet no_changes "$@"
	then
		exit 0
	fi

	# state of the base commit
	if b_commit=$(maybe_quiet --keep-stdout git rev-parse --verify HEAD)
	then
		head=$(git rev-list --oneline -n 1 HEAD --)
	elif test -n "$GIT_QUIET"
	then
		exit 1
	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 -z "$@" | (
				GIT_INDEX_FILE="$TMPindex" &&
				export GIT_INDEX_FILE &&
				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 "$(gettext "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-index --name-only -z HEAD -- "$@" >"$TMP-stagenames" &&
			git update-index --ignore-skip-worktree-entries \
				-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 () {
	while test $# != 0
	do
		case "$1" in
		-m|--message)
			shift
			stash_msg="$1"
			;;
		-m*)
			stash_msg=${1#-m}
			;;
		--message=*)
			stash_msg=${1#--message=}
			;;
		-q|--quiet)
			quiet=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

	git update-ref --create-reflog -m "$stash_msg" $ref_stash $w_commit
	ret=$?
	test $ret != 0 && test -z "$quiet" &&
	die "$(eval_gettext "Cannot update \$ref_stash with \$w_commit")"
	return $ret
}

push_stash () {
	keep_index=
	patch_mode=
	untracked=
	stash_msg=
	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
			;;
		-m|--message)
			shift
			test -z ${1+x} && usage
			stash_msg=$1
			;;
		-m*)
			stash_msg=${1#-m}
			;;
		--message=*)
			stash_msg=${1#--message=}
			;;
		--help)
			show_help
			;;
		--)
			shift
			break
			;;
		-*)
			option="$1"
			eval_gettextln "error: unknown option for 'stash push': \$option"
			usage
			;;
		*)
			break
			;;
		esac
		shift
	done

	eval "set $(git rev-parse --sq --prefix "$prefix" -- "$@")"

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

	test -n "$untracked" || git ls-files --error-unmatch -- "$@" >/dev/null || exit 1

	git update-index -q --refresh
	if maybe_quiet no_changes "$@"
	then
		say "$(gettext "No local changes to save")"
		exit 0
	fi

	git reflog exists $ref_stash ||
		clear_stash || die "$(gettext "Cannot initialize stash")"

	create_stash -m "$stash_msg" -u "$untracked" -- "$@"
	store_stash -m "$stash_msg" -q $w_commit ||
	die "$(gettext "Cannot save the current status")"
	say "$(eval_gettext "Saved working directory and index state \$stash_msg")"

	if test -z "$patch_mode"
	then
		test "$untracked" = "all" && CLEAN_X_OPTION=-x || CLEAN_X_OPTION=
		if test -n "$untracked" && test $# = 0
		then
			git clean --force --quiet -d $CLEAN_X_OPTION
		fi

		if test $# != 0
		then
			test -z "$untracked" && UPDATE_OPTION="-u" || UPDATE_OPTION=
			test "$untracked" = "all" && FORCE_OPTION="--force" || FORCE_OPTION=
			git add $UPDATE_OPTION $FORCE_OPTION -- "$@"
			git diff-index -p --cached --binary HEAD -- "$@" |
			git apply --index -R
		else
			git reset --hard -q --no-recurse-submodules
		fi

		if test "$keep_index" = "t" && test -n "$i_tree"
		then
			git read-tree --reset $i_tree
			git ls-files -z --modified -- "$@" |
			git checkout-index -z --force --stdin
		fi
	else
		git apply -R < "$TMP-patch" ||
		die "$(gettext "Cannot remove worktree changes")"

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

save_stash () {
	push_options=
	while test $# != 0
	do
		case "$1" in
		-q|--quiet)
			GIT_QUIET=t
			;;
		--)
			shift
			break
			;;
		-*)
			# pass all options through to push_stash
			push_options="$push_options $1"
			;;
		*)
			break
			;;
		esac
		shift
	done

	stash_msg="$*"

	if test -z "$stash_msg"
	then
		push_stash $push_options
	else
		push_stash $push_options -m "$stash_msg"
	fi
}

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

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

show_stash () {
	ALLOW_UNKNOWN_FLAGS=t
	assert_stash_like "$@"

	if test -z "$FLAGS"
	then
		if test "$(git config --bool stash.showStat || echo true)" = "true"
		then
			FLAGS=--stat
		fi

		if test "$(git config --bool stash.showPatch || echo false)" = "true"
		then
			FLAGS=${FLAGS}${FLAGS:+ }-p
		fi

		if test -z "$FLAGS"
		then
			return 0
		fi
	fi

	git diff ${FLAGS} $b_commit $w_commit
}

show_help () {
	exec git help stash
	exit 1
}

#
# 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 (if allowed)
#
# 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
#   * unknown flags were set and ALLOW_UNKNOWN_FLAGS is not "t"
#

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=

	FLAGS=
	REV=
	for opt
	do
		case "$opt" in
			-q|--quiet)
				GIT_QUIET=-t
			;;
			--index)
				INDEX_OPTION=--index
			;;
			--help)
				show_help
			;;
			-*)
				test "$ALLOW_UNKNOWN_FLAGS" = t ||
					die "$(eval_gettext "unknown option: \$opt")"
				FLAGS="${FLAGS}${FLAGS:+ }$opt"
			;;
			*)
				REV="${REV}${REV:+ }'$opt'"
			;;
		esac
	done

	eval set -- $REV

	case $# in
		0)
			have_stash || die "$(gettext "No stash entries found.")"
			set -- ${ref_stash}@{0}
		;;
		1)
			:
		;;
		*)
			die "$(eval_gettext "Too many revisions specified: \$REV")"
		;;
	esac

	case "$1" in
		*[!0-9]*)
			:
		;;
		*)
			set -- "${ref_stash}@{$1}"
		;;
	esac

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

	i_commit=$(git rev-parse --verify --quiet "$REV^2") &&
	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 --verify --quiet "$REV^3") &&
	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")"

	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 "$(gettext "Could not restore untracked files from stash entry")"
	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 "$@"

	if apply_stash "$@"
	then
		drop_stash "$@"
	else
		status=$?
		say "$(gettext "The stash entry is kept in case you need it again.")"
		exit $status
	fi
}

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 --quiet "$ref_stash@{0}" >/dev/null ||
	clear_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 "$@" && {
		test -z "$IS_STASH_REF" || drop_stash "$@"
	}
}

test "$1" = "-p" && set "push" "$@"

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

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

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