8d8e9c2a94 · matheusbsbs/matheus-bagliano

@@ -0,0 +1,769 @@

1 +#!/bin/sh

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 +create_stash () {

84 +

85 + prepare_fallback_ident

86 +

87 + stash_msg=

88 + untracked=

89 + while test $# != 0

90 + do

91 + case "$1" in

92 + -m|--message)

93 + shift

94 + stash_msg=${1?"BUG: create_stash () -m requires an argument"}

95 + ;;

96 + -m*)

97 + stash_msg=${1#-m}

98 + ;;

99 + --message=*)

100 + stash_msg=${1#--message=}

101 + ;;

102 + -u|--include-untracked)

103 + shift

104 + untracked=${1?"BUG: create_stash () -u requires an argument"}

105 + ;;

106 + --)

107 + shift

108 + break

109 + ;;

110 + esac

111 + shift

112 + done

113 +

114 + git update-index -q --refresh

115 + if no_changes "$@"

116 + then

117 + exit 0

118 + fi

119 +

120 + # state of the base commit

121 + if b_commit=$(git rev-parse --verify HEAD)

122 + then

123 + head=$(git rev-list --oneline -n 1 HEAD --)

124 + else

125 + die "$(gettext "You do not have the initial commit yet")"

126 + fi

127 +

128 + if branch=$(git symbolic-ref -q HEAD)

129 + then

130 + branch=${branch#refs/heads/}

131 + else

132 + branch='(no branch)'

133 + fi

134 + msg=$(printf '%s: %s' "$branch" "$head")

135 +

136 + # state of the index

137 + i_tree=$(git write-tree) &&

138 + i_commit=$(printf 'index on %s\n' "$msg" |

139 + git commit-tree $i_tree -p $b_commit) ||

140 + die "$(gettext "Cannot save the current index state")"

141 +

142 + if test -n "$untracked"

143 + then

144 + # Untracked files are stored by themselves in a parentless commit, for

145 + # ease of unpacking later.

146 + u_commit=$(

147 + untracked_files -z "$@" | (

148 + GIT_INDEX_FILE="$TMPindex" &&

149 + export GIT_INDEX_FILE &&

150 + rm -f "$TMPindex" &&

151 + git update-index -z --add --remove --stdin &&

152 + u_tree=$(git write-tree) &&

153 + printf 'untracked files on %s\n' "$msg" | git commit-tree $u_tree &&

154 + rm -f "$TMPindex"

155 + ) ) || die "$(gettext "Cannot save the untracked files")"

156 +

157 + untracked_commit_option="-p $u_commit";

158 + else

159 + untracked_commit_option=

160 + fi

161 +

162 + if test -z "$patch_mode"

163 + then

164 +

165 + # state of the working tree

166 + w_tree=$( (

167 + git read-tree --index-output="$TMPindex" -m $i_tree &&

168 + GIT_INDEX_FILE="$TMPindex" &&

169 + export GIT_INDEX_FILE &&

170 + git diff-index --name-only -z HEAD -- "$@" >"$TMP-stagenames" &&

171 + git update-index -z --add --remove --stdin <"$TMP-stagenames" &&

172 + git write-tree &&

173 + rm -f "$TMPindex"

174 + ) ) ||

175 + die "$(gettext "Cannot save the current worktree state")"

176 +

177 + else

178 +

179 + rm -f "$TMP-index" &&

180 + GIT_INDEX_FILE="$TMP-index" git read-tree HEAD &&

181 +

182 + # find out what the user wants

183 + GIT_INDEX_FILE="$TMP-index" \

184 + git add--interactive --patch=stash -- "$@" &&

185 +

186 + # state of the working tree

187 + w_tree=$(GIT_INDEX_FILE="$TMP-index" git write-tree) ||

188 + die "$(gettext "Cannot save the current worktree state")"

189 +

190 + git diff-tree -p HEAD $w_tree -- >"$TMP-patch" &&

191 + test -s "$TMP-patch" ||

192 + die "$(gettext "No changes selected")"

193 +

194 + rm -f "$TMP-index" ||

195 + die "$(gettext "Cannot remove temporary index (can't happen)")"

196 +

197 + fi

198 +

199 + # create the stash

200 + if test -z "$stash_msg"

201 + then

202 + stash_msg=$(printf 'WIP on %s' "$msg")

203 + else

204 + stash_msg=$(printf 'On %s: %s' "$branch" "$stash_msg")

205 + fi

206 + w_commit=$(printf '%s\n' "$stash_msg" |

207 + git commit-tree $w_tree -p $b_commit -p $i_commit $untracked_commit_option) ||

208 + die "$(gettext "Cannot record working tree state")"

209 +}

210 +

211 +store_stash () {

212 + while test $# != 0

213 + do

214 + case "$1" in

215 + -m|--message)

216 + shift

217 + stash_msg="$1"

218 + ;;

219 + -m*)

220 + stash_msg=${1#-m}

221 + ;;

222 + --message=*)

223 + stash_msg=${1#--message=}

224 + ;;

225 + -q|--quiet)

226 + quiet=t

227 + ;;

228 + *)

229 + break

230 + ;;

231 + esac

232 + shift

233 + done

234 + test $# = 1 ||

235 + die "$(eval_gettext "\"$dashless store\" requires one <commit> argument")"

236 +

237 + w_commit="$1"

238 + if test -z "$stash_msg"

239 + then

240 + stash_msg="Created via \"git stash store\"."

241 + fi

242 +

243 + git update-ref --create-reflog -m "$stash_msg" $ref_stash $w_commit

244 + ret=$?

245 + test $ret != 0 && test -z "$quiet" &&

246 + die "$(eval_gettext "Cannot update \$ref_stash with \$w_commit")"

247 + return $ret

248 +}

249 +

250 +push_stash () {

251 + keep_index=

252 + patch_mode=

253 + untracked=

254 + stash_msg=

255 + while test $# != 0

256 + do

257 + case "$1" in

258 + -k|--keep-index)

259 + keep_index=t

260 + ;;

261 + --no-keep-index)

262 + keep_index=n

263 + ;;

264 + -p|--patch)

265 + patch_mode=t

266 + # only default to keep if we don't already have an override

267 + test -z "$keep_index" && keep_index=t

268 + ;;

269 + -q|--quiet)

270 + GIT_QUIET=t

271 + ;;

272 + -u|--include-untracked)

273 + untracked=untracked

274 + ;;

275 + -a|--all)

276 + untracked=all

277 + ;;

278 + -m|--message)

279 + shift

280 + test -z ${1+x} && usage

281 + stash_msg=$1

282 + ;;

283 + -m*)

284 + stash_msg=${1#-m}

285 + ;;

286 + --message=*)

287 + stash_msg=${1#--message=}

288 + ;;

289 + --help)

290 + show_help

291 + ;;

292 + --)

293 + shift

294 + break

295 + ;;

296 + -*)

297 + option="$1"

298 + eval_gettextln "error: unknown option for 'stash push': \$option"

299 + usage

300 + ;;

301 + *)

302 + break

303 + ;;

304 + esac

305 + shift

306 + done

307 +

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

309 +

310 + if test -n "$patch_mode" && test -n "$untracked"

311 + then

312 + die "$(gettext "Can't use --patch and --include-untracked or --all at the same time")"

313 + fi

314 +

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

316 +

317 + git update-index -q --refresh

318 + if no_changes "$@"

319 + then

320 + say "$(gettext "No local changes to save")"

321 + exit 0

322 + fi

323 +

324 + git reflog exists $ref_stash ||

325 + clear_stash || die "$(gettext "Cannot initialize stash")"

326 +

327 + create_stash -m "$stash_msg" -u "$untracked" -- "$@"

328 + store_stash -m "$stash_msg" -q $w_commit ||

329 + die "$(gettext "Cannot save the current status")"

330 + say "$(eval_gettext "Saved working directory and index state \$stash_msg")"

331 +

332 + if test -z "$patch_mode"

333 + then

334 + test "$untracked" = "all" && CLEAN_X_OPTION=-x || CLEAN_X_OPTION=

335 + if test -n "$untracked" && test $# = 0

336 + then

337 + git clean --force --quiet -d $CLEAN_X_OPTION

338 + fi

339 +

340 + if test $# != 0

341 + then

342 + test -z "$untracked" && UPDATE_OPTION="-u" || UPDATE_OPTION=

343 + test "$untracked" = "all" && FORCE_OPTION="--force" || FORCE_OPTION=

344 + git add $UPDATE_OPTION $FORCE_OPTION -- "$@"

345 + git diff-index -p --cached --binary HEAD -- "$@" |

346 + git apply --index -R

347 + else

348 + git reset --hard -q

349 + fi

350 +

351 + if test "$keep_index" = "t" && test -n "$i_tree"

352 + then

353 + git read-tree --reset $i_tree

354 + git ls-files -z --modified -- "$@" |

355 + git checkout-index -z --force --stdin

356 + fi

357 + else

358 + git apply -R < "$TMP-patch" ||

359 + die "$(gettext "Cannot remove worktree changes")"

360 +

361 + if test "$keep_index" != "t"

362 + then

363 + git reset -q -- "$@"

364 + fi

365 + fi

366 +}

367 +

368 +save_stash () {

369 + push_options=

370 + while test $# != 0

371 + do

372 + case "$1" in

373 + --)

374 + shift

375 + break

376 + ;;

377 + -*)

378 + # pass all options through to push_stash

379 + push_options="$push_options $1"

380 + ;;

381 + *)

382 + break

383 + ;;

384 + esac

385 + shift

386 + done

387 +

388 + stash_msg="$*"

389 +

390 + if test -z "$stash_msg"

391 + then

392 + push_stash $push_options

393 + else

394 + push_stash $push_options -m "$stash_msg"

395 + fi

396 +}

397 +

398 +have_stash () {

399 + git rev-parse --verify --quiet $ref_stash >/dev/null

400 +}

401 +

402 +list_stash () {

403 + have_stash || return 0

404 + git log --format="%gd: %gs" -g --first-parent -m "$@" $ref_stash --

405 +}

406 +

407 +show_stash () {

408 + ALLOW_UNKNOWN_FLAGS=t

409 + assert_stash_like "$@"

410 +

411 + if test -z "$FLAGS"

412 + then

413 + if test "$(git config --bool stash.showStat || echo true)" = "true"

414 + then

415 + FLAGS=--stat

416 + fi

417 +

418 + if test "$(git config --bool stash.showPatch || echo false)" = "true"

419 + then

420 + FLAGS=${FLAGS}${FLAGS:+ }-p

421 + fi

422 +

423 + if test -z "$FLAGS"

424 + then

425 + return 0

426 + fi

427 + fi

428 +

429 + git diff ${FLAGS} $b_commit $w_commit

430 +}

431 +

432 +show_help () {

433 + exec git help stash

434 + exit 1

435 +}

436 +

437 +#

438 +# Parses the remaining options looking for flags and

439 +# at most one revision defaulting to ${ref_stash}@{0}

440 +# if none found.

441 +#

442 +# Derives related tree and commit objects from the

443 +# revision, if one is found.

444 +#

445 +# stash records the work tree, and is a merge between the

446 +# base commit (first parent) and the index tree (second parent).

447 +#

448 +# REV is set to the symbolic version of the specified stash-like commit

449 +# IS_STASH_LIKE is non-blank if ${REV} looks like a stash

450 +# IS_STASH_REF is non-blank if the ${REV} looks like a stash ref

451 +# s is set to the SHA1 of the stash commit

452 +# w_commit is set to the commit containing the working tree

453 +# b_commit is set to the base commit

454 +# i_commit is set to the commit containing the index tree

455 +# u_commit is set to the commit containing the untracked files tree

456 +# w_tree is set to the working tree

457 +# b_tree is set to the base tree

458 +# i_tree is set to the index tree

459 +# u_tree is set to the untracked files tree

460 +#

461 +# GIT_QUIET is set to t if -q is specified

462 +# INDEX_OPTION is set to --index if --index is specified.

463 +# FLAGS is set to the remaining flags (if allowed)

464 +#

465 +# dies if:

466 +# * too many revisions specified

467 +# * no revision is specified and there is no stash stack

468 +# * a revision is specified which cannot be resolve to a SHA1

469 +# * a non-existent stash reference is specified

470 +# * unknown flags were set and ALLOW_UNKNOWN_FLAGS is not "t"

471 +#

472 +

473 +parse_flags_and_rev()

474 +{

475 + test "$PARSE_CACHE" = "$*" && return 0 # optimisation

476 + PARSE_CACHE="$*"

477 +

478 + IS_STASH_LIKE=

479 + IS_STASH_REF=

480 + INDEX_OPTION=

481 + s=

482 + w_commit=

483 + b_commit=

484 + i_commit=

485 + u_commit=

486 + w_tree=

487 + b_tree=

488 + i_tree=

489 + u_tree=

490 +

491 + FLAGS=

492 + REV=

493 + for opt

494 + do

495 + case "$opt" in

496 + -q|--quiet)

497 + GIT_QUIET=-t

498 + ;;

499 + --index)

500 + INDEX_OPTION=--index

501 + ;;

502 + --help)

503 + show_help

504 + ;;

505 + -*)

506 + test "$ALLOW_UNKNOWN_FLAGS" = t ||

507 + die "$(eval_gettext "unknown option: \$opt")"

508 + FLAGS="${FLAGS}${FLAGS:+ }$opt"

509 + ;;

510 + *)

511 + REV="${REV}${REV:+ }'$opt'"

512 + ;;

513 + esac

514 + done

515 +

516 + eval set -- $REV

517 +

518 + case $# in

519 + 0)

520 + have_stash || die "$(gettext "No stash entries found.")"

521 + set -- ${ref_stash}@{0}

522 + ;;

523 + 1)

524 + :

525 + ;;

526 + *)

527 + die "$(eval_gettext "Too many revisions specified: \$REV")"

528 + ;;

529 + esac

530 +

531 + case "$1" in

532 + *[!0-9]*)

533 + :

534 + ;;

535 + *)

536 + set -- "${ref_stash}@{$1}"

537 + ;;

538 + esac

539 +

540 + REV=$(git rev-parse --symbolic --verify --quiet "$1") || {

541 + reference="$1"

542 + die "$(eval_gettext "\$reference is not a valid reference")"

543 + }

544 +

545 + i_commit=$(git rev-parse --verify --quiet "$REV^2") &&

546 + set -- $(git rev-parse "$REV" "$REV^1" "$REV:" "$REV^1:" "$REV^2:" 2>/dev/null) &&

547 + s=$1 &&

548 + w_commit=$1 &&

549 + b_commit=$2 &&

550 + w_tree=$3 &&

551 + b_tree=$4 &&

552 + i_tree=$5 &&

553 + IS_STASH_LIKE=t &&

554 + test "$ref_stash" = "$(git rev-parse --symbolic-full-name "${REV%@*}")" &&

555 + IS_STASH_REF=t

556 +

557 + u_commit=$(git rev-parse --verify --quiet "$REV^3") &&

558 + u_tree=$(git rev-parse "$REV^3:" 2>/dev/null)

559 +}

560 +

561 +is_stash_like()

562 +{

563 + parse_flags_and_rev "$@"

564 + test -n "$IS_STASH_LIKE"

565 +}

566 +

567 +assert_stash_like() {

568 + is_stash_like "$@" || {

569 + args="$*"

570 + die "$(eval_gettext "'\$args' is not a stash-like commit")"

571 + }

572 +}

573 +

574 +is_stash_ref() {

575 + is_stash_like "$@" && test -n "$IS_STASH_REF"

576 +}

577 +

578 +assert_stash_ref() {

579 + is_stash_ref "$@" || {

580 + args="$*"

581 + die "$(eval_gettext "'\$args' is not a stash reference")"

582 + }

583 +}

584 +

585 +apply_stash () {

586 +

587 + assert_stash_like "$@"

588 +

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

590 +

591 + # current index state

592 + c_tree=$(git write-tree) ||

593 + die "$(gettext "Cannot apply a stash in the middle of a merge")"

594 +

595 + unstashed_index_tree=

596 + if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&

597 + test "$c_tree" != "$i_tree"

598 + then

599 + git diff-tree --binary $s^2^..$s^2 | git apply --cached

600 + test $? -ne 0 &&

601 + die "$(gettext "Conflicts in index. Try without --index.")"

602 + unstashed_index_tree=$(git write-tree) ||

603 + die "$(gettext "Could not save index tree")"

604 + git reset

605 + fi

606 +

607 + if test -n "$u_tree"

608 + then

609 + GIT_INDEX_FILE="$TMPindex" git read-tree "$u_tree" &&

610 + GIT_INDEX_FILE="$TMPindex" git checkout-index --all &&

611 + rm -f "$TMPindex" ||

612 + die "$(gettext "Could not restore untracked files from stash entry")"

613 + fi

614 +

615 + eval "

616 + GITHEAD_$w_tree='Stashed changes' &&

617 + GITHEAD_$c_tree='Updated upstream' &&

618 + GITHEAD_$b_tree='Version stash was based on' &&

619 + export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree

620 + "

621 +

622 + if test -n "$GIT_QUIET"

623 + then

624 + GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY

625 + fi

626 + if git merge-recursive $b_tree -- $c_tree $w_tree

627 + then

628 + # No conflict

629 + if test -n "$unstashed_index_tree"

630 + then

631 + git read-tree "$unstashed_index_tree"

632 + else

633 + a="$TMP-added" &&

634 + git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&

635 + git read-tree --reset $c_tree &&

636 + git update-index --add --stdin <"$a" ||

637 + die "$(gettext "Cannot unstage modified files")"

638 + rm -f "$a"

639 + fi

640 + squelch=

641 + if test -n "$GIT_QUIET"

642 + then

643 + squelch='>/dev/null 2>&1'

644 + fi

645 + (cd "$START_DIR" && eval "git status $squelch") || :

646 + else

647 + # Merge conflict; keep the exit status from merge-recursive

648 + status=$?

649 + git rerere

650 + if test -n "$INDEX_OPTION"

651 + then

652 + gettextln "Index was not unstashed." >&2

653 + fi

654 + exit $status

655 + fi

656 +}

657 +

658 +pop_stash() {

659 + assert_stash_ref "$@"

660 +

661 + if apply_stash "$@"

662 + then

663 + drop_stash "$@"

664 + else

665 + status=$?

666 + say "$(gettext "The stash entry is kept in case you need it again.")"

667 + exit $status

668 + fi

669 +}

670 +

671 +drop_stash () {

672 + assert_stash_ref "$@"

673 +

674 + git reflog delete --updateref --rewrite "${REV}" &&

675 + say "$(eval_gettext "Dropped \${REV} (\$s)")" ||

676 + die "$(eval_gettext "\${REV}: Could not drop stash entry")"

677 +

678 + # clear_stash if we just dropped the last stash entry

679 + git rev-parse --verify --quiet "$ref_stash@{0}" >/dev/null ||

680 + clear_stash

681 +}

682 +

683 +apply_to_branch () {

684 + test -n "$1" || die "$(gettext "No branch name specified")"

685 + branch=$1

686 + shift 1

687 +

688 + set -- --index "$@"

689 + assert_stash_like "$@"

690 +

691 + git checkout -b $branch $REV^ &&

692 + apply_stash "$@" && {

693 + test -z "$IS_STASH_REF" || drop_stash "$@"

694 + }

695 +}

696 +

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

698 +

699 +PARSE_CACHE='--not-parsed'

700 +# The default command is "push" if nothing but options are given

701 +seen_non_option=

702 +for opt

703 +do

704 + case "$opt" in

705 + --) break ;;

706 + -*) ;;

707 + *) seen_non_option=t; break ;;

708 + esac

709 +done

710 +

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

712 +

713 +# Main command set

714 +case "$1" in

715 +list)

716 + shift

717 + list_stash "$@"

718 + ;;

719 +show)

720 + shift

721 + show_stash "$@"

722 + ;;

723 +save)

724 + shift

725 + save_stash "$@"

726 + ;;

727 +push)

728 + shift

729 + push_stash "$@"

730 + ;;

731 +apply)

732 + shift

733 + apply_stash "$@"

734 + ;;

735 +clear)

736 + shift

737 + clear_stash "$@"

738 + ;;

739 +create)

740 + shift

741 + create_stash -m "$*" && echo "$w_commit"

742 + ;;

743 +store)

744 + shift

745 + store_stash "$@"

746 + ;;

747 +drop)

748 + shift

749 + drop_stash "$@"

750 + ;;

751 +pop)

752 + shift

753 + pop_stash "$@"

754 + ;;

755 +branch)

756 + shift

757 + apply_to_branch "$@"

758 + ;;

759 +*)

760 + case $# in

761 + 0)

762 + push_stash &&

763 + say "$(gettext "(To restore them type \"git stash apply\")")"

764 + ;;

765 + *)

766 + usage

767 + esac

768 + ;;

769 +esac

stash: add back the original, scripted `git stash`