Merge branch 'js/update-index-ignore-removal-for-skip-worktree'
[thirdparty/git.git] / git-legacy-stash.sh
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
83 maybe_quiet () {
84         case "$1" in
85         --keep-stdout)
86                 shift
87                 if test -n "$GIT_QUIET"
88                 then
89                         "$@" 2>/dev/null
90                 else
91                         "$@"
92                 fi
93                 ;;
94         *)
95                 if test -n "$GIT_QUIET"
96                 then
97                         "$@" >/dev/null 2>&1
98                 else
99                         "$@"
100                 fi
101                 ;;
102         esac
103 }
104
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
137         if maybe_quiet no_changes "$@"
138         then
139                 exit 0
140         fi
141
142         # state of the base commit
143         if b_commit=$(maybe_quiet --keep-stdout git rev-parse --verify HEAD)
144         then
145                 head=$(git rev-list --oneline -n 1 HEAD --)
146         elif test -n "$GIT_QUIET"
147         then
148                 exit 1
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" &&
196                         git update-index --ignore-skip-worktree-entries \
197                                 -z --add --remove --stdin <"$TMP-stagenames" &&
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
344         if maybe_quiet no_changes "$@"
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
374                         git reset --hard -q --no-recurse-submodules
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
399                 -q|--quiet)
400                         GIT_QUIET=t
401                         ;;
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