git-review-workflow 0.1.0

package/bin/git-review-verbs/finish

@@ -0,0 +1,494 @@
+#!/usr/bin/env sh
+#
+# git review finish — extract your review edits from the current review/* branch.
+#
+# By default it creates review-fixes/<branch> on top of the PR tip with your
+# edits staged. With --onto-source it stages your edits on the PR branch itself
+# instead. Either way the result stays local; review and commit it yourself.
+#
+# --abort undoes the last finish and drops you back on review/<branch> exactly
+# where you were editing, the same way git merge --abort backs out a merge. To
+# make that possible, a fresh finish first records an undo point (the review
+# branch's HEAD, index and working tree, à la ORIG_HEAD) before it mutates
+# anything, so --abort is a verbatim restore regardless of whole/step mode.
+#
+set -eu
+
+prog="git review finish"
+
+usage() {
+	cat <<EOF
+usage: $prog [--onto-source] [--resume | --abort [--force]]
+
+Extract your review edits from the current review/* branch.
+
+  (default)        create review-fixes/<branch> on top of the PR tip and stage your edits
+  --onto-source    instead, stage your edits on the PR branch itself
+  --resume         continue after resolving conflicts from a commit-by-commit replay
+  --abort          undo the last finish and return to editing the review
+  --force          with --abort, discard changes made to the finish branch since
+EOF
+}
+
+onto=0
+resume=0
+abort=0
+force=0
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-h | --h)
+		usage
+		exit 0
+		;;
+	--onto-source) onto=1 ;;
+	--resume) resume=1 ;;
+	--abort) abort=1 ;;
+	--force) force=1 ;;
+	*)
+		echo "error: unknown option $1" >&2
+		usage >&2
+		exit 1
+		;;
+	esac
+	shift
+done
+
+cur="$(git symbolic-ref --quiet --short HEAD || true)"
+[ -n "$cur" ] || {
+	echo "error: not on a branch" >&2
+	exit 1
+}
+
+# worktree_tree: the tree of the current working tree captured with `git add -A`
+# (so brand-new untracked files count too), via a throwaway index that leaves the
+# real index untouched. Used to snapshot state and to detect later divergence.
+worktree_tree() {
+	_gd="$(git rev-parse --git-dir)"
+	_ti="$_gd/finish-wt-index.$$"
+	cp "$(git rev-parse --git-path index)" "$_ti"
+	GIT_INDEX_FILE="$_ti" git add -A
+	GIT_INDEX_FILE="$_ti" git write-tree
+	rm -f "$_ti"
+}
+
+# apply_review_patch FROM TO [git-apply-args...]
+# Diff FROM..TO and apply it, routing the patch through a temp file rather than a
+# shell variable. Capturing a binary patch with command substitution drops its
+# NUL bytes and trailing newline, so git apply later rejects it ("corrupt binary
+# patch") — which broke every review edit touching a binary file. An empty diff
+# is a no-op success; the function returns git apply's exit status so callers can
+# branch on conflicts.
+apply_review_patch() {
+	_from="$1"
+	_to="$2"
+	shift 2
+	_pf="$(git rev-parse --git-dir)/finish-apply.$$"
+	git diff --binary "$_from" "$_to" >"$_pf"
+	if [ -s "$_pf" ]; then
+		if git apply "$@" <"$_pf"; then _rc=0; else _rc=$?; fi
+	else
+		_rc=0
+	fi
+	rm -f "$_pf"
+	return "$_rc"
+}
+
+# record_exit: once a finish has produced its branch ($1), snapshot that branch's
+# HEAD and working tree onto the review branch's config so a later --abort can tell
+# whether you have changed it since — and tell you up front that abort will not
+# silently throw that work away. Recorded only on a completed finish, never for one
+# stopped mid-conflict.
+record_exit() {
+	git config "branch.$cur.reviewundoouthead" "$(git rev-parse HEAD)"
+	git config "branch.$cur.reviewundoouttree" "$(worktree_tree)"
+	echo "note: commits you make on $1 are kept, and uncommitted edits too while you stay on $1 — git review finish --abort refuses to discard them without --force." >&2
+}
+
+# --abort restores the undo point recorded by the finish being undone. It runs
+# before the review/* check on purpose: after a finish you are on
+# review-fixes/<branch> (or, with --onto-source, on the PR branch), never on
+# review/<branch>.
+do_abort() {
+	# Find the review branch the undo point belongs to from wherever we landed
+	# after the finish.
+	case "$cur" in
+	review-fixes/*) asrc="${cur#review-fixes/}" ;;
+	review/*) asrc="${cur#review/}" ;;
+	*) asrc="$cur" ;;
+	esac
+
+	rb="review/$asrc"
+	head="$(git config "branch.$rb.reviewundohead" || true)"
+	[ -n "$head" ] || {
+		echo "error: no finish to abort (no undo point for $rb)" >&2
+		exit 1
+	}
+	git rev-parse --verify --quiet "refs/heads/$rb" >/dev/null || {
+		echo "error: $rb is gone; cannot restore the review" >&2
+		exit 1
+	}
+
+	# The pre-finish index and working tree live only in refs/review-undo/<src>/.
+	# If those refs were deleted by hand while the config undo record survived,
+	# there is nothing left to restore the review from. Resolve them up front, with
+	# --quiet, and bail with a clear pointer — otherwise rev-parse --verify dies
+	# below with an opaque "Needed a single revision", possibly only after
+	# reset --hard has already mutated the tree.
+	idxtree="$(git rev-parse --verify --quiet "refs/review-undo/$asrc/index^{tree}" || true)"
+	wttree="$(git rev-parse --verify --quiet "refs/review-undo/$asrc/worktree^{tree}" || true)"
+	if [ -z "$idxtree" ] || [ -z "$wttree" ]; then
+		echo "error: the undo snapshot for $rb is gone (refs/review-undo/$asrc deleted); cannot restore the review." >&2
+		echo "the leftover undo record is stale — run git review clean $asrc to clear it." >&2
+		exit 1
+	fi
+
+	kind="$(git config "branch.$rb.reviewundokind" || echo fixes)"
+	srccreated="$(git config "branch.$rb.reviewundosrccreated" || echo 0)"
+	editstep="$(git config "branch.$rb.reviewundoeditstep" || true)"
+	editold="$(git config "branch.$rb.reviewundoeditold" || true)"
+
+	# Guard: a finish leaves your edits on the branch it produced (review-fixes, or
+	# the PR branch with --onto-source). If you have since changed that branch — new
+	# commits, or an edited working tree — aborting would throw that work away. Like
+	# git branch -d, refuse and point at the work; --force tears it down anyway.
+	# Skipped when no exit state was recorded: a finish stopped mid-conflict never
+	# produced the branch, so --abort there discards the in-progress conflict
+	# resolution the way git rebase --abort does.
+	outhead="$(git config "branch.$rb.reviewundoouthead" || true)"
+	outtree="$(git config "branch.$rb.reviewundoouttree" || true)"
+	if [ "$force" -eq 0 ] && [ -n "$outhead" ]; then
+		if [ "$kind" = "onto-source" ]; then
+			outbranch="$asrc"
+		else
+			outbranch="review-fixes/$asrc"
+		fi
+		diverged=0
+		nowhead="$(git rev-parse --verify --quiet "refs/heads/$outbranch" || true)"
+		if [ -n "$nowhead" ] && [ "$nowhead" != "$outhead" ]; then
+			diverged=1
+		fi
+		# Only the working tree of the branch we are actually on is meaningful; if
+		# you switched away, fall back to the committed-divergence check above.
+		if [ "$diverged" -eq 0 ] && [ "$cur" = "$outbranch" ] && [ -n "$outtree" ] &&
+			[ "$(worktree_tree)" != "$outtree" ]; then
+			diverged=1
+		fi
+		if [ "$diverged" -eq 1 ]; then
+			echo "error: $outbranch has changes since the finish; aborting would discard them." >&2
+			echo "your work stays on $outbranch — switch there to keep it, or rerun with --force to discard." >&2
+			exit 1
+		fi
+	fi
+
+	# Return to the review branch and restore the exact pre-finish state: HEAD,
+	# then the working tree (read-tree -m -u brings back additions, edits,
+	# deletions and the captured untracked files), then the index on top.
+	# When already on the review branch — e.g. aborting a finish that stopped
+	# mid-conflict — skip the checkout (the index may hold unmerged entries that
+	# a same-branch checkout chokes on); the reset --hard below clears them.
+	if [ "$cur" != "$rb" ]; then
+		git checkout -q -f "$rb"
+	fi
+	git reset -q --hard "$head"
+	git read-tree -m -u "$wttree"
+	git read-tree "$idxtree"
+
+	# Restore the current step's banked edit ref to what it was before finish
+	# banked it (or remove it if finish was the one that created it).
+	if [ -n "$editstep" ]; then
+		eref="refs/review-edits/$asrc/$editstep"
+		if [ "$editold" = "none" ] || [ -z "$editold" ]; then
+			git update-ref -d "$eref" 2>/dev/null || true
+		else
+			git update-ref "$eref" "$editold"
+		fi
+	fi
+
+	# Drop the branch finish created, leaving only the review/<branch> you are
+	# back on. --onto-source deletes the PR branch when finish created it; when it
+	# already existed, finish staged onto it without committing and left it at the
+	# reviewed tip ($outhead), so reset it back there — this also discards any
+	# commits made on it since, which is what reaching here (untouched, or --force)
+	# means. Skipped when no exit state was recorded (mid-conflict never touched
+	# the PR branch).
+	if [ "$kind" = "onto-source" ]; then
+		if [ "$srccreated" = "1" ] &&
+			git rev-parse --verify --quiet "refs/heads/$asrc" >/dev/null; then
+			git branch -D "$asrc" >/dev/null
+		elif [ -n "$outhead" ] &&
+			git rev-parse --verify --quiet "refs/heads/$asrc" >/dev/null; then
+			git update-ref "refs/heads/$asrc" "$outhead"
+		fi
+	elif git rev-parse --verify --quiet "refs/heads/review-fixes/$asrc" >/dev/null; then
+		git branch -D "review-fixes/$asrc" >/dev/null
+	fi
+
+	# Clear a mid-conflict marker (finish may have been aborted part-way) and the
+	# whole undo record.
+	git config --unset "branch.$rb.reviewresume" 2>/dev/null || true
+	for k in reviewundohead reviewundokind reviewundosrccreated \
+		reviewundoeditstep reviewundoeditold reviewundoouthead reviewundoouttree; do
+		git config --unset "branch.$rb.$k" 2>/dev/null || true
+	done
+	git for-each-ref --format='%(refname)' "refs/review-undo/$asrc/" |
+		while read -r ref; do
+			git update-ref -d "$ref"
+		done
+
+	echo "aborted finish; back on $rb — keep editing, then run git review finish"
+}
+
+if [ "$abort" -eq 1 ]; then
+	if [ "$resume" -eq 1 ] || [ "$onto" -eq 1 ]; then
+		echo "error: --abort takes no other options" >&2
+		exit 1
+	fi
+	do_abort
+	exit 0
+fi
+
+if [ "$force" -eq 1 ]; then
+	echo "error: --force only applies to --abort" >&2
+	exit 1
+fi
+
+case "$cur" in
+review/*) ;;
+*)
+	echo "error: not on a review/* branch (HEAD is $cur)" >&2
+	exit 1
+	;;
+esac
+
+src="$(git config "branch.$cur.reviewsource" || true)"
+tip="$(git config "branch.$cur.reviewtip" || true)"
+if [ -z "$src" ] || [ -z "$tip" ]; then
+	echo "error: missing review metadata; was $cur created with git review start?" >&2
+	exit 1
+fi
+
+# A compare review (git review compare) has no writable source branch — it only
+# stages a diff to read — so there is nothing to extract. Refuse explicitly rather
+# than producing an empty or meaningless review-fixes branch.
+if [ "$(git config "branch.$cur.reviewreadonly" || true)" = "1" ]; then
+	echo "error: $cur is a read-only compare review; there is nothing to write back" >&2
+	echo "compare just stages a diff to read — run git review clean ${cur#review/} when done." >&2
+	exit 1
+fi
+
+# Shared helpers, sourced from the libexec directory the dispatcher points us at,
+# so the step block below validates its metadata through load_step_review_meta —
+# the same guard the other step commands use — instead of reading the keys raw.
+# shellcheck source=../git-review-lib.sh
+. "${GIT_REVIEW_LIBEXEC:?}/git-review-lib.sh"
+
+# A step review records reviewmode=step alongside reviewstart/reviewcount/
+# reviewstep; a whole review records none of those keys. If reviewmode was lost to
+# a hand-edit but the step keys survive, we would fall through to the whole-mode
+# tail below and diff the current step commit (not the tip) against the tip —
+# silently reversing the author's later commits into the extracted fix. Report the
+# inconsistency rather than producing a corrupt patch.
+mode="$(git config "branch.$cur.reviewmode" || true)"
+if [ "$mode" != "step" ]; then
+	for k in reviewstart reviewcount reviewstep; do
+		[ -z "$(git config "branch.$cur.$k" || true)" ] || {
+			echo "error: corrupt review metadata: $cur has step-review keys but reviewmode is not 'step'" >&2
+			exit 1
+		}
+	done
+fi
+
+# record_undo: snapshot everything finish is about to mutate so --abort can put
+# it back verbatim — the review branch's HEAD, its index, and its working tree
+# (captured via a throwaway index so brand-new untracked edits are included).
+# The trees are pinned under refs/review-undo/<src>/ so gc cannot drop them.
+record_undo() {
+	wttree="$(worktree_tree)"
+	idxtree="$(git write-tree)"
+	orig="$(git rev-parse HEAD)"
+
+	git update-ref "refs/review-undo/$src/head" "$orig"
+	git update-ref "refs/review-undo/$src/index" \
+		"$(git commit-tree "$idxtree" -m 'git review finish undo (index)')"
+	git update-ref "refs/review-undo/$src/worktree" \
+		"$(git commit-tree "$wttree" -m 'git review finish undo (worktree)')"
+
+	git config "branch.$cur.reviewundohead" "$orig"
+	if [ "$onto" -eq 1 ]; then
+		git config "branch.$cur.reviewundokind" "onto-source"
+		# Remember whether the PR branch already existed, so --abort only deletes
+		# it when finish was the one that created it.
+		if git rev-parse --verify --quiet "refs/heads/$src" >/dev/null; then
+			git config "branch.$cur.reviewundosrccreated" 0
+		else
+			git config "branch.$cur.reviewundosrccreated" 1
+		fi
+	else
+		git config "branch.$cur.reviewundokind" "fixes"
+		git config "branch.$cur.reviewundosrccreated" 0
+	fi
+
+	# In step mode finish overwrites the current step's banked edit ref; record
+	# its prior value (or "none") so --abort restores exactly that.
+	if [ "$mode" = "step" ]; then
+		ustep="$(git config "branch.$cur.reviewstep" || echo 1)"
+		git config "branch.$cur.reviewundoeditstep" "$ustep"
+		uold="$(git rev-parse --verify --quiet "refs/review-edits/$src/$ustep" || true)"
+		git config "branch.$cur.reviewundoeditold" "${uold:-none}"
+	else
+		git config --unset "branch.$cur.reviewundoeditstep" 2>/dev/null || true
+		git config --unset "branch.$cur.reviewundoeditold" 2>/dev/null || true
+	fi
+}
+
+# A finish records an undo point that lives until you --abort it (or tear the
+# review down). If one already exists when starting a fresh finish, a previous
+# finish on this branch has not been resolved — switching back to review/<branch>
+# by hand and finishing again would clobber the undo point with new HEAD/index/
+# worktree snapshots while leaving the old exit state behind, so a later --abort
+# would restore a mix of the two and could delete the earlier finish's branch.
+# Refuse the way git refuses a second merge or rebase while one is in progress,
+# and point at the way out.
+if [ "$resume" -eq 0 ] && [ -n "$(git config "branch.$cur.reviewundohead" || true)" ]; then
+	if [ "$(git config "branch.$cur.reviewresume" || true)" = "conflict" ]; then
+		echo "error: a finish on $cur stopped at a conflict and is still pending." >&2
+		echo "resolve the markers and run git review finish --resume, or git review finish --abort to back out." >&2
+	else
+		echo "error: a previous finish on $cur has not been resolved." >&2
+		echo "run git review finish --abort to undo it (or git review abort to drop the whole review) before finishing again." >&2
+	fi
+	exit 1
+fi
+
+# Only a fresh finish records an undo point; --resume continues the same finish
+# and must keep the point its first invocation took.
+if [ "$resume" -eq 0 ]; then
+	record_undo
+fi
+
+# In commit-by-commit mode, bank the current commit's edits, move to the tip and
+# replay every banked edit there, so what follows sees the same state as a normal
+# whole-PR review. With --resume we skip the replay: the working tree already
+# holds the resolved edits.
+if [ "$mode" = "step" ] && [ "$resume" -eq 0 ]; then
+	# Validate and load the step metadata (count, step, start, commits) through the
+	# shared helper, so a hand-deleted or corrupt key is reported the same way the
+	# other step commands report it — instead of defaulting count to 0 (which
+	# silently discards every banked edit) or letting a missing reviewstart kill us
+	# under set -e with no message.
+	load_step_review_meta
+	cstep="$(printf '%s\n' "$commits" | sed -n "${step}p")"
+	git add -A
+	tree="$(git write-tree)"
+	if [ "$tree" != "$(git rev-parse "$cstep^{tree}")" ]; then
+		edit="$(git commit-tree "$tree" -p "$cstep" -m "review edits step $step")"
+		git update-ref "refs/review-edits/$src/$step" "$edit"
+	else
+		# Reverting the step back to a clean tree must clear any edits we banked
+		# earlier, or they resurrect in the replay below.
+		git update-ref -d "refs/review-edits/$src/$step" 2>/dev/null || true
+	fi
+	git reset -q --hard "$tip"
+	conflict=0
+	i=1
+	while [ "$i" -le "$count" ]; do
+		ref="refs/review-edits/$src/$i"
+		if git rev-parse --verify --quiet "$ref" >/dev/null; then
+			# Keep going on conflict so every edit lands; conflicts are left as
+			# markers for the user to resolve. apply_review_patch routes the diff
+			# through a file so a binary banked edit is not corrupted.
+			apply_review_patch "${ref}^" "$ref" --3way ||
+				conflict=1
+		fi
+		i=$((i + 1))
+	done
+	if [ "$conflict" -eq 1 ]; then
+		git config "branch.$cur.reviewresume" conflict
+		flags=""
+		[ "$onto" -eq 1 ] && flags="$flags --onto-source"
+		echo "conflict: some banked edits overlap the PR tip." >&2
+		echo "the working tree has conflict markers — resolve them, then run:" >&2
+		echo "    git review finish --resume$flags" >&2
+		echo "(git review finish --abort here discards the resolution, like git rebase --abort.)" >&2
+		exit 1
+	fi
+elif [ "$resume" -eq 1 ]; then
+	if [ "$(git config "branch.$cur.reviewresume" || true)" != "conflict" ]; then
+		echo "error: nothing to resume" >&2
+		exit 1
+	fi
+	git config --unset "branch.$cur.reviewresume" || true
+fi
+
+# Fold any edits into the review branch so we can diff them back out cleanly.
+git add -A
+if ! git diff --cached --quiet; then
+	git commit -q -m "review session ($src)"
+fi
+
+if git diff --quiet "$tip" "$cur"; then
+	# No edits came out of the review. The undo point recorded above guards a
+	# finish branch that will never be produced, so roll it back — otherwise it
+	# would block a later finish on this branch (and leave nothing meaningful to
+	# --abort). Then honour --onto-source by leaving you on the PR branch, the
+	# whole point of the flag, instead of stranding you on review/<branch>.
+	git config --unset "branch.$cur.reviewresume" 2>/dev/null || true
+	for k in reviewundohead reviewundokind reviewundosrccreated \
+		reviewundoeditstep reviewundoeditold reviewundoouthead reviewundoouttree; do
+		git config --unset "branch.$cur.$k" 2>/dev/null || true
+	done
+	git for-each-ref --format='%(refname)' "refs/review-undo/$src/" |
+		while read -r ref; do
+			git update-ref -d "$ref"
+		done
+
+	if [ "$onto" -eq 1 ]; then
+		# Same guard as the edited path: never move onto a local $src that sits
+		# somewhere other than the reviewed tip.
+		if git rev-parse --verify --quiet "refs/heads/$src" >/dev/null; then
+			if [ "$(git rev-parse "$src")" != "$tip" ]; then
+				echo "error: local $src is not at the reviewed tip; move or delete it first" >&2
+				exit 1
+			fi
+			git switch -q "$src"
+		else
+			git switch -q -c "$src" "$tip"
+		fi
+		echo "no review changes to apply; on $src at the reviewed tip" >&2
+		exit 0
+	fi
+
+	echo "no review changes to apply" >&2
+	exit 0
+fi
+
+if [ "$onto" -eq 1 ]; then
+	if git rev-parse --verify --quiet "refs/heads/$src" >/dev/null; then
+		if [ "$(git rev-parse "$src")" != "$tip" ]; then
+			echo "error: local $src is not at the reviewed tip; move or delete it first" >&2
+			exit 1
+		fi
+		git switch -q "$src"
+	else
+		git switch -q -c "$src" "$tip"
+	fi
+	apply_review_patch "$tip" "$cur" --index --3way || {
+		echo "error: could not apply review changes onto $src" >&2
+		exit 1
+	}
+	record_exit "$src"
+	echo "$src ready with your edits staged — review and commit"
+else
+	fb="review-fixes/$src"
+	git rev-parse --verify --quiet "refs/heads/$fb" >/dev/null && {
+		echo "error: $fb already exists; remove it first" >&2
+		exit 1
+	}
+	git switch -q -c "$fb" "$tip"
+	apply_review_patch "$tip" "$cur" --index --3way || {
+		echo "error: could not apply review changes onto $fb" >&2
+		exit 1
+	}
+	record_exit "$fb"
+	echo "$fb ready with your edits staged — review and commit"
+fi