petru
6d0a7ec238
- 5 - I improved conflict reporting so package.json conflicts show the upstream scripts block, the conflicting commit side, and the current branch working-tree side, and the final dry-run summary now includes the total conflict-step count, the local commits that conflicted, and the unique conflicted files.
1092 lines
36 KiB
Bash
Executable File
1092 lines
36 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
set -euo pipefail
|
|
|
|
# This script safely updates the current local branch on top of the official
|
|
# Gitea upstream without losing local work.
|
|
# It:
|
|
# 1. checks that no git operation is already in progress;
|
|
# 2. ensures the upstream remote exists and points to the official repository;
|
|
# 3. creates a local backup branch at the current HEAD;
|
|
# 4. creates a full exact snapshot of the current repository state;
|
|
# 5. stashes tracked and untracked local changes;
|
|
# 6. fetches the latest upstream changes and rebases the current branch on top
|
|
# of upstream/main;
|
|
# 7. reapplies the local stash only after a successful rebase.
|
|
# It also offers a dry-run mode that performs the same verification flow in a
|
|
# temporary clone, so the current repository is left untouched.
|
|
# If a conflict happens, the backup branch and the stash are both kept so the
|
|
# local work can be recovered manually.
|
|
|
|
BRANCH="${BRANCH:-main}"
|
|
REMOTE_NAME="${REMOTE_NAME:-upstream}"
|
|
REMOTE_URL="${REMOTE_URL:-https://github.com/go-gitea/gitea.git}"
|
|
REPO_ROOT=""
|
|
GIT_DIR=""
|
|
STATE_FILE=""
|
|
DRY_RUN_ROOT=""
|
|
SNAPSHOT_ROOT=""
|
|
CURRENT_BRANCH=""
|
|
BACKUP_BRANCH=""
|
|
STASH_REF=""
|
|
STASH_HASH=""
|
|
STATE_BRANCH=""
|
|
STATE_BACKUP_BRANCH=""
|
|
STATE_STASH_HASH=""
|
|
STATE_REMOTE_NAME=""
|
|
STATE_REMOTE_URL=""
|
|
STATE_TARGET_BRANCH=""
|
|
STATE_START_HEAD=""
|
|
STATE_SNAPSHOT_PATH=""
|
|
STATE_STATUS=""
|
|
STATE_UPDATED_AT=""
|
|
|
|
say() {
|
|
printf '%s\n' "$*"
|
|
}
|
|
|
|
die() {
|
|
say "ERROR: $*" >&2
|
|
exit 1
|
|
}
|
|
|
|
show_usage() {
|
|
cat <<EOF
|
|
Usage: $(basename "$0") [command]
|
|
|
|
Available commands:
|
|
sync Run the full safe update flow: backup, stash, fetch, rebase, restore.
|
|
dry-run Run a dry-run verification in a dedicated reusable clone without changing this repository, collecting all detected rebase conflicts.
|
|
fetch Fetch the latest upstream changes only.
|
|
backup Create a safety backup branch from the current HEAD only.
|
|
list-backups
|
|
List available backup branches created by this script.
|
|
rollback [backup-branch]
|
|
Return the current branch to a saved backup branch and restore saved local changes when possible.
|
|
restore-stash
|
|
Re-apply the saved pre-sync local stash from the last recorded sync state.
|
|
clean-dry-run
|
|
Remove the reusable dry-run workspace and legacy temporary dry-run clones.
|
|
restore-snapshot [snapshot-dir]
|
|
Restore the exact saved repository snapshot from the last recorded real action, or from a specific snapshot directory.
|
|
status Show the current repository, branch, remote, and local-change status.
|
|
help Show this help text.
|
|
|
|
If no command is provided and the script is run from a terminal, an interactive
|
|
menu is shown.
|
|
|
|
Recommended order:
|
|
1. Run: ./.update-gitea.sh status
|
|
2. Run: ./.update-gitea.sh dry-run
|
|
3. If dry-run reports conflicts:
|
|
- review the reported conflict steps, commits, and files
|
|
- adjust or resolve the conflicting local changes in your real branch
|
|
- run: ./.update-gitea.sh dry-run
|
|
again until it completes cleanly
|
|
4. If dry-run is clean, run: ./.update-gitea.sh sync
|
|
5. If rebase stops with conflicts:
|
|
- either resolve them and continue with: git rebase --continue
|
|
- or return safely with: ./.update-gitea.sh rollback
|
|
6. If restoring local changes after the rebase causes conflicts:
|
|
- either resolve them manually
|
|
- or return safely with: ./.update-gitea.sh rollback
|
|
7. Use: ./.update-gitea.sh list-backups
|
|
to see the restore points created by the script.
|
|
8. Use: ./.update-gitea.sh restore-stash
|
|
only when you intentionally aborted a failed sync and want the saved local
|
|
changes reapplied again.
|
|
9. Use: ./.update-gitea.sh restore-snapshot
|
|
when you want to restore the exact saved repository state, including
|
|
untracked and ignored files that existed at snapshot time.
|
|
EOF
|
|
}
|
|
|
|
ensure_git_repo() {
|
|
local raw_git_dir
|
|
|
|
REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || die "This script must be run inside a git repository."
|
|
raw_git_dir="$(git rev-parse --git-dir)"
|
|
case "$raw_git_dir" in
|
|
/*) GIT_DIR="$raw_git_dir" ;;
|
|
*) GIT_DIR="$REPO_ROOT/$raw_git_dir" ;;
|
|
esac
|
|
STATE_FILE="$GIT_DIR/.update-gitea-state"
|
|
DRY_RUN_ROOT="$GIT_DIR/.update-gitea-dry-run"
|
|
SNAPSHOT_ROOT="$GIT_DIR/.update-gitea-snapshots"
|
|
}
|
|
|
|
write_state() {
|
|
{
|
|
printf 'STATE_BRANCH=%q\n' "$STATE_BRANCH"
|
|
printf 'STATE_BACKUP_BRANCH=%q\n' "$STATE_BACKUP_BRANCH"
|
|
printf 'STATE_STASH_HASH=%q\n' "$STATE_STASH_HASH"
|
|
printf 'STATE_REMOTE_NAME=%q\n' "$STATE_REMOTE_NAME"
|
|
printf 'STATE_REMOTE_URL=%q\n' "$STATE_REMOTE_URL"
|
|
printf 'STATE_TARGET_BRANCH=%q\n' "$STATE_TARGET_BRANCH"
|
|
printf 'STATE_START_HEAD=%q\n' "$STATE_START_HEAD"
|
|
printf 'STATE_SNAPSHOT_PATH=%q\n' "$STATE_SNAPSHOT_PATH"
|
|
printf 'STATE_STATUS=%q\n' "$STATE_STATUS"
|
|
printf 'STATE_UPDATED_AT=%q\n' "$(date +%Y-%m-%dT%H:%M:%S)"
|
|
} >"$STATE_FILE"
|
|
}
|
|
|
|
load_state() {
|
|
ensure_git_repo
|
|
[ -f "$STATE_FILE" ] || return 1
|
|
# shellcheck disable=SC1090
|
|
. "$STATE_FILE"
|
|
return 0
|
|
}
|
|
|
|
clear_state() {
|
|
ensure_git_repo
|
|
rm -f "$STATE_FILE"
|
|
}
|
|
|
|
worktree_has_local_changes() {
|
|
! git diff --quiet || ! git diff --cached --quiet || [ -n "$(git ls-files --others --exclude-standard)" ]
|
|
}
|
|
|
|
has_rebase_in_progress() {
|
|
[ -e "$(git rev-parse --git-path rebase-merge)" ] || [ -e "$(git rev-parse --git-path rebase-apply)" ]
|
|
}
|
|
|
|
has_rebase_in_progress_in_repo() {
|
|
local repo_path="$1"
|
|
[ -d "$repo_path/.git/rebase-merge" ] || [ -d "$repo_path/.git/rebase-apply" ]
|
|
}
|
|
|
|
sanitize_ref_name() {
|
|
printf '%s\n' "${1//\//-}"
|
|
}
|
|
|
|
ensure_rsync_available() {
|
|
command -v rsync >/dev/null 2>&1 || die "rsync is required for exact repository snapshots."
|
|
}
|
|
|
|
snapshot_repo_dir() {
|
|
printf '%s\n' "$1/repo"
|
|
}
|
|
|
|
is_valid_snapshot_dir() {
|
|
[ -d "$1" ] && [ -d "$(snapshot_repo_dir "$1")" ]
|
|
}
|
|
|
|
create_worktree_snapshot_for_reason() {
|
|
local reason="$1" safe_branch_name timestamp snapshot_dir snapshot_dir_repo
|
|
|
|
ensure_rsync_available
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
snapshot_dir="$SNAPSHOT_ROOT/$safe_branch_name/${timestamp}-${reason}"
|
|
snapshot_dir_repo="$(snapshot_repo_dir "$snapshot_dir")"
|
|
|
|
mkdir -p "$snapshot_dir_repo"
|
|
rsync --archive --delete --exclude='.git' "$REPO_ROOT"/ "$snapshot_dir_repo"/
|
|
|
|
{
|
|
printf 'branch=%s\n' "$CURRENT_BRANCH"
|
|
printf 'head=%s\n' "$(git rev-parse HEAD)"
|
|
printf 'created_at=%s\n' "$(date +%Y-%m-%dT%H:%M:%S)"
|
|
printf 'reason=%s\n' "$reason"
|
|
} >"$snapshot_dir/metadata.txt"
|
|
|
|
printf '%s\n' "$snapshot_dir"
|
|
}
|
|
|
|
restore_worktree_snapshot() {
|
|
local snapshot_dir="$1" snapshot_dir_repo
|
|
|
|
ensure_rsync_available
|
|
is_valid_snapshot_dir "$snapshot_dir" || die "Snapshot directory '$snapshot_dir' is not valid."
|
|
snapshot_dir_repo="$(snapshot_repo_dir "$snapshot_dir")"
|
|
|
|
rsync --archive --delete --exclude='.git' "$snapshot_dir_repo"/ "$REPO_ROOT"/
|
|
}
|
|
|
|
find_latest_snapshot_for_current() {
|
|
local safe_branch_name snapshot_branch_dir
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
snapshot_branch_dir="$SNAPSHOT_ROOT/$safe_branch_name"
|
|
[ -d "$snapshot_branch_dir" ] || return 1
|
|
find "$snapshot_branch_dir" -mindepth 1 -maxdepth 1 -type d | sort -r | head -n 1
|
|
}
|
|
|
|
ensure_no_nonrebase_git_operation_in_progress() {
|
|
local git_path
|
|
for git_path in MERGE_HEAD CHERRY_PICK_HEAD REVERT_HEAD BISECT_LOG; do
|
|
if [ -e "$(git rev-parse --git-path "$git_path")" ]; then
|
|
die "A git operation is already in progress ($git_path). Finish it before running this script."
|
|
fi
|
|
done
|
|
}
|
|
|
|
ensure_no_git_operation_in_progress() {
|
|
local git_path
|
|
ensure_no_nonrebase_git_operation_in_progress
|
|
for git_path in rebase-merge rebase-apply MERGE_HEAD CHERRY_PICK_HEAD REVERT_HEAD BISECT_LOG; do
|
|
if [ -e "$(git rev-parse --git-path "$git_path")" ]; then
|
|
die "A git operation is already in progress ($git_path). Finish it before running this script."
|
|
fi
|
|
done
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are unmerged files in the working tree. Resolve them first."
|
|
fi
|
|
}
|
|
|
|
ensure_current_branch() {
|
|
CURRENT_BRANCH="$(git symbolic-ref --quiet --short HEAD || true)"
|
|
[ -n "$CURRENT_BRANCH" ] || die "Detached HEAD is not supported. Check out a branch first."
|
|
}
|
|
|
|
ensure_current_branch_with_state_fallback() {
|
|
CURRENT_BRANCH="$(git symbolic-ref --quiet --short HEAD || true)"
|
|
if [ -n "$CURRENT_BRANCH" ]; then
|
|
return
|
|
fi
|
|
|
|
if load_state && [ -n "${STATE_BRANCH:-}" ]; then
|
|
CURRENT_BRANCH="$STATE_BRANCH"
|
|
return
|
|
fi
|
|
|
|
die "Detached HEAD is not supported here and no saved branch state was found."
|
|
}
|
|
|
|
update_state_for_sync() {
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$BACKUP_BRANCH"
|
|
STATE_STASH_HASH="$STASH_HASH"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_TARGET_BRANCH="$BRANCH"
|
|
write_state
|
|
}
|
|
|
|
list_current_branch_backup_refs() {
|
|
local safe_branch_name
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
git for-each-ref --sort=-creatordate --format='%(refname:short)' "refs/heads/backup/${safe_branch_name}-*"
|
|
}
|
|
|
|
show_current_branch_backups() {
|
|
local backup_ref
|
|
|
|
if ! list_current_branch_backup_refs | grep -q .; then
|
|
say "No existing backups were found for branch '$CURRENT_BRANCH'."
|
|
return 1
|
|
fi
|
|
|
|
say "Existing backups for branch '$CURRENT_BRANCH':"
|
|
while IFS= read -r backup_ref; do
|
|
[ -n "$backup_ref" ] || continue
|
|
say " - $backup_ref"
|
|
done < <(list_current_branch_backup_refs)
|
|
return 0
|
|
}
|
|
|
|
confirm_yes_no() {
|
|
local prompt="$1" reply
|
|
|
|
while true; do
|
|
printf '%s [Y/n]: ' "$prompt"
|
|
read -r reply
|
|
case "${reply,,}" in
|
|
""|y|yes) return 0 ;;
|
|
n|no) return 1 ;;
|
|
*) say "Please answer yes or no." ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
prepare_backup_before_real_action() {
|
|
local action_label="$1" backup_reason="$2" latest_existing_backup=""
|
|
|
|
STATE_START_HEAD="$(git rev-parse HEAD)"
|
|
STATE_SNAPSHOT_PATH=""
|
|
BACKUP_BRANCH=""
|
|
|
|
latest_existing_backup="$(list_current_branch_backup_refs | head -n 1 || true)"
|
|
if [ -z "$latest_existing_backup" ]; then
|
|
BACKUP_BRANCH="$(create_backup_branch_for_reason "$backup_reason")"
|
|
say "No existing backups were found, so a new backup was created automatically: $BACKUP_BRANCH"
|
|
else
|
|
show_current_branch_backups
|
|
if [ -t 0 ] && [ -t 1 ]; then
|
|
if confirm_yes_no "Create a fresh backup before '$action_label'?"; then
|
|
BACKUP_BRANCH="$(create_backup_branch_for_reason "$backup_reason")"
|
|
say "New backup created: $BACKUP_BRANCH"
|
|
else
|
|
BACKUP_BRANCH="$latest_existing_backup"
|
|
say "No new backup created. The exact current commit was still recorded internally as: $STATE_START_HEAD"
|
|
say "Latest existing backup selected as reference: $BACKUP_BRANCH"
|
|
fi
|
|
else
|
|
BACKUP_BRANCH="$(create_backup_branch_for_reason "$backup_reason")"
|
|
say "Non-interactive mode detected. A fresh backup was created automatically: $BACKUP_BRANCH"
|
|
fi
|
|
fi
|
|
|
|
STATE_SNAPSHOT_PATH="$(create_worktree_snapshot_for_reason "$backup_reason")"
|
|
say "Exact worktree snapshot created: $STATE_SNAPSHOT_PATH"
|
|
}
|
|
|
|
ensure_upstream_remote() {
|
|
local current_remote_url
|
|
|
|
if current_remote_url="$(git remote get-url "$REMOTE_NAME" 2>/dev/null)"; then
|
|
if [ "$current_remote_url" != "$REMOTE_URL" ]; then
|
|
die "Remote '$REMOTE_NAME' points to '$current_remote_url', expected '$REMOTE_URL'."
|
|
fi
|
|
return
|
|
fi
|
|
|
|
say "Adding remote '$REMOTE_NAME'..."
|
|
git remote add "$REMOTE_NAME" "$REMOTE_URL"
|
|
}
|
|
|
|
show_status() {
|
|
local stash_count latest_backup latest_snapshot dry_run_branch_dir
|
|
|
|
ensure_git_repo
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
|
|
stash_count="$(git stash list | wc -l | tr -d ' ')"
|
|
|
|
say "Repository: $(git rev-parse --show-toplevel)"
|
|
say "Current branch: $CURRENT_BRANCH"
|
|
say "Upstream remote: $REMOTE_NAME -> $REMOTE_URL"
|
|
say "Working tree:"
|
|
if ! worktree_has_local_changes; then
|
|
say " clean"
|
|
else
|
|
git status --short
|
|
fi
|
|
say "Stash entries: $stash_count"
|
|
latest_backup="$(find_latest_backup_branch_for_current || true)"
|
|
say "Latest backup for current branch: ${latest_backup:-none}"
|
|
latest_snapshot="$(find_latest_snapshot_for_current || true)"
|
|
say "Latest snapshot for current branch: ${latest_snapshot:-none}"
|
|
dry_run_branch_dir="$DRY_RUN_ROOT/$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
if [ -d "$dry_run_branch_dir/repo/.git" ]; then
|
|
say "Dry-run workspace: $dry_run_branch_dir"
|
|
else
|
|
say "Dry-run workspace: not initialized"
|
|
fi
|
|
if load_state; then
|
|
say "Saved sync state: $STATE_STATUS"
|
|
say "Saved backup branch: ${STATE_BACKUP_BRANCH:-none}"
|
|
say "Saved starting commit: ${STATE_START_HEAD:-none}"
|
|
say "Saved original stash: ${STATE_STASH_HASH:-none}"
|
|
say "Saved exact snapshot: ${STATE_SNAPSHOT_PATH:-none}"
|
|
else
|
|
say "Saved sync state: none"
|
|
fi
|
|
}
|
|
|
|
create_backup_branch_for_reason() {
|
|
local reason="$1" safe_branch_name timestamp branch_name
|
|
safe_branch_name="${CURRENT_BRANCH//\//-}"
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
branch_name="backup/${safe_branch_name}-${reason}-${timestamp}"
|
|
|
|
git branch "$branch_name" HEAD >/dev/null
|
|
printf '%s\n' "$branch_name"
|
|
}
|
|
|
|
create_backup_branch() {
|
|
BACKUP_BRANCH="$(create_backup_branch_for_reason "before-upstream-sync")"
|
|
say "Backup branch created: $BACKUP_BRANCH"
|
|
}
|
|
|
|
stash_current_changes() {
|
|
local stash_prefix="$1" timestamp stash_name
|
|
|
|
STASH_REF=""
|
|
STASH_HASH=""
|
|
if ! worktree_has_local_changes; then
|
|
say "No local tracked/untracked changes to stash."
|
|
return
|
|
fi
|
|
|
|
timestamp="$(date +%Y%m%d-%H%M%S)"
|
|
stash_name="${stash_prefix}-${CURRENT_BRANCH//\//-}-${timestamp}"
|
|
|
|
say "Stashing local tracked and untracked changes..."
|
|
git stash push --include-untracked --message "$stash_name" >/dev/null
|
|
STASH_REF="$(git stash list -1 --format='%gd')"
|
|
[ -n "$STASH_REF" ] || die "Failed to locate the created stash entry."
|
|
STASH_HASH="$(git rev-parse "$STASH_REF")"
|
|
[ -n "$STASH_HASH" ] || die "Failed to resolve the created stash hash."
|
|
say "Local changes saved in $STASH_REF"
|
|
}
|
|
|
|
stash_local_changes() {
|
|
stash_current_changes "pre-upstream-sync"
|
|
}
|
|
|
|
fetch_upstream() {
|
|
say "Fetching latest changes from $REMOTE_NAME/$BRANCH..."
|
|
git fetch --prune "$REMOTE_NAME"
|
|
git show-ref --verify --quiet "refs/remotes/$REMOTE_NAME/$BRANCH" || die "Remote branch '$REMOTE_NAME/$BRANCH' was not found."
|
|
}
|
|
|
|
show_rebase_conflict_details() {
|
|
local repo_path="$1" conflict_label conflict_file found_conflicts=0
|
|
|
|
conflict_label="$(get_rebase_conflict_commit_label "$repo_path")"
|
|
if [ -n "$conflict_label" ]; then
|
|
say "Conflicting local commit: $conflict_label"
|
|
fi
|
|
|
|
while IFS= read -r conflict_file; do
|
|
if [ "$found_conflicts" -eq 0 ]; then
|
|
say "Conflicted files:"
|
|
found_conflicts=1
|
|
fi
|
|
say " - $conflict_file"
|
|
if [ "$conflict_file" = "package.json" ]; then
|
|
show_package_json_conflict_details "$repo_path" "$conflict_file"
|
|
fi
|
|
done < <(git -C "$repo_path" diff --name-only --diff-filter=U)
|
|
|
|
if [ "$found_conflicts" -eq 0 ]; then
|
|
say "No explicit conflicted files were detected, but the rebase did stop."
|
|
fi
|
|
}
|
|
|
|
get_rebase_conflict_commit_label() {
|
|
local repo_path="$1" rebase_head
|
|
|
|
rebase_head="$(git -C "$repo_path" rev-parse --short REBASE_HEAD 2>/dev/null || true)"
|
|
if [ -n "$rebase_head" ]; then
|
|
git -C "$repo_path" show --no-patch --format='%h %s' REBASE_HEAD
|
|
fi
|
|
}
|
|
|
|
array_contains_item() {
|
|
local item="$1" existing
|
|
shift || true
|
|
for existing in "$@"; do
|
|
if [ "$existing" = "$item" ]; then
|
|
return 0
|
|
fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
extract_package_json_scripts_block() {
|
|
sed -n '/"scripts"[[:space:]]*:[[:space:]]*{/,/^[[:space:]]*}[[:space:]]*,\{0,1\}[[:space:]]*$/p'
|
|
}
|
|
|
|
show_package_json_conflict_details() {
|
|
local repo_path="$1" file_path="$2" upstream_side conflict_commit_side current_branch_side
|
|
|
|
upstream_side="$(git -C "$repo_path" show ":2:$file_path" 2>/dev/null || true)"
|
|
conflict_commit_side="$(git -C "$repo_path" show ":3:$file_path" 2>/dev/null || true)"
|
|
current_branch_side="$(cat "$REPO_ROOT/$file_path" 2>/dev/null || true)"
|
|
|
|
say " package.json scripts comparison:"
|
|
if [ -n "$upstream_side" ]; then
|
|
say " Upstream/current side:"
|
|
printf '%s\n' "$upstream_side" | extract_package_json_scripts_block | sed 's/^/ /'
|
|
fi
|
|
if [ -n "$conflict_commit_side" ]; then
|
|
say " Conflicting commit side:"
|
|
printf '%s\n' "$conflict_commit_side" | extract_package_json_scripts_block | sed 's/^/ /'
|
|
fi
|
|
if [ -n "$current_branch_side" ]; then
|
|
say " Current branch working tree side:"
|
|
printf '%s\n' "$current_branch_side" | extract_package_json_scripts_block | sed 's/^/ /'
|
|
fi
|
|
}
|
|
|
|
auto_resolve_current_rebase_conflicts_in_temp_clone() {
|
|
local repo_path="$1" conflict_file
|
|
|
|
while IFS= read -r conflict_file; do
|
|
if ! git -C "$repo_path" checkout --theirs -- "$conflict_file" 2>/dev/null; then
|
|
git -C "$repo_path" rm --force -- "$conflict_file" >/dev/null 2>&1 || true
|
|
fi
|
|
git -C "$repo_path" add -A -- "$conflict_file"
|
|
done < <(git -C "$repo_path" diff --name-only --diff-filter=U)
|
|
}
|
|
|
|
collect_all_rebase_conflicts_in_temp_clone() {
|
|
local repo_path="$1" conflict_count=0 commit_label conflict_file
|
|
local -a conflict_commits=()
|
|
local -a unique_conflict_files=()
|
|
|
|
while has_rebase_in_progress_in_repo "$repo_path"; do
|
|
conflict_count=$((conflict_count + 1))
|
|
commit_label="$(get_rebase_conflict_commit_label "$repo_path")"
|
|
if [ -n "$commit_label" ] && ! array_contains_item "$commit_label" "${conflict_commits[@]}"; then
|
|
conflict_commits+=("$commit_label")
|
|
fi
|
|
while IFS= read -r conflict_file; do
|
|
[ -n "$conflict_file" ] || continue
|
|
if ! array_contains_item "$conflict_file" "${unique_conflict_files[@]}"; then
|
|
unique_conflict_files+=("$conflict_file")
|
|
fi
|
|
done < <(git -C "$repo_path" diff --name-only --diff-filter=U)
|
|
|
|
say "Conflict step #$conflict_count:"
|
|
show_rebase_conflict_details "$repo_path"
|
|
auto_resolve_current_rebase_conflicts_in_temp_clone "$repo_path"
|
|
if ! GIT_EDITOR=: git -C "$repo_path" rebase --continue >/dev/null 2>&1; then
|
|
if has_rebase_in_progress_in_repo "$repo_path"; then
|
|
continue
|
|
fi
|
|
say "Dry-run could not continue after automatically recording a conflict step."
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
say "Total detected rebase conflict steps: $conflict_count"
|
|
if [ "${#conflict_commits[@]}" -gt 0 ]; then
|
|
say "Local commits with conflicts (${#conflict_commits[@]}):"
|
|
for commit_label in "${conflict_commits[@]}"; do
|
|
say " - $commit_label"
|
|
done
|
|
fi
|
|
if [ "${#unique_conflict_files[@]}" -gt 0 ]; then
|
|
say "Unique conflicted files (${#unique_conflict_files[@]}):"
|
|
for conflict_file in "${unique_conflict_files[@]}"; do
|
|
say " - $conflict_file"
|
|
done
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
prepare_dry_run_workspace() {
|
|
local dry_run_branch_dir="$1" dry_run_repo="$2"
|
|
|
|
mkdir -p "$dry_run_branch_dir"
|
|
|
|
if [ ! -d "$dry_run_repo/.git" ]; then
|
|
say "Creating reusable dry-run clone in $dry_run_repo..."
|
|
git clone --quiet --no-local --branch "$CURRENT_BRANCH" --single-branch "$REPO_ROOT" "$dry_run_repo"
|
|
else
|
|
say "Reusing dry-run clone in $dry_run_repo..."
|
|
if has_rebase_in_progress_in_repo "$dry_run_repo"; then
|
|
git -C "$dry_run_repo" rebase --abort >/dev/null 2>&1 || true
|
|
fi
|
|
git -C "$dry_run_repo" reset --hard >/dev/null
|
|
git -C "$dry_run_repo" clean -fdx >/dev/null
|
|
git -C "$dry_run_repo" remote set-url origin "$REPO_ROOT"
|
|
git -C "$dry_run_repo" fetch --prune origin "$CURRENT_BRANCH"
|
|
git -C "$dry_run_repo" checkout -B "$CURRENT_BRANCH" "origin/$CURRENT_BRANCH" >/dev/null 2>&1
|
|
fi
|
|
|
|
if git -C "$dry_run_repo" remote get-url "$REMOTE_NAME" >/dev/null 2>&1; then
|
|
git -C "$dry_run_repo" remote set-url "$REMOTE_NAME" "$REMOTE_URL"
|
|
else
|
|
git -C "$dry_run_repo" remote add "$REMOTE_NAME" "$REMOTE_URL"
|
|
fi
|
|
}
|
|
|
|
run_clean_dry_run() {
|
|
local tmp_root legacy_dir removed_any=0
|
|
|
|
ensure_git_repo
|
|
|
|
if [ -d "$DRY_RUN_ROOT" ]; then
|
|
rm -rf "$DRY_RUN_ROOT"
|
|
say "Removed reusable dry-run workspace: $DRY_RUN_ROOT"
|
|
removed_any=1
|
|
fi
|
|
|
|
tmp_root="${TMPDIR:-/tmp}"
|
|
shopt -s nullglob
|
|
for legacy_dir in "$tmp_root"/gitea-upstream-test.*; do
|
|
if [ -d "$legacy_dir" ]; then
|
|
rm -rf "$legacy_dir"
|
|
say "Removed legacy dry-run directory: $legacy_dir"
|
|
removed_any=1
|
|
fi
|
|
done
|
|
shopt -u nullglob
|
|
|
|
if [ "$removed_any" -eq 0 ]; then
|
|
say "No dry-run workspace or legacy temporary directories were found."
|
|
fi
|
|
}
|
|
|
|
rebase_onto_upstream() {
|
|
say "Rebasing '$CURRENT_BRANCH' onto '$REMOTE_NAME/$BRANCH'..."
|
|
if git rebase "$REMOTE_NAME/$BRANCH"; then
|
|
say "Rebase completed successfully."
|
|
STATE_STATUS="rebase_completed"
|
|
update_state_for_sync
|
|
return
|
|
fi
|
|
|
|
STATE_STATUS="rebase_conflict"
|
|
update_state_for_sync
|
|
say "Rebase stopped because of conflicts."
|
|
show_rebase_conflict_details "."
|
|
say "Backup branch kept at: $BACKUP_BRANCH"
|
|
if [ -n "$STASH_HASH" ]; then
|
|
say "Local stash kept at: $STASH_HASH"
|
|
fi
|
|
say "Resolve conflicts and run 'git rebase --continue', or abort with 'git rebase --abort'."
|
|
exit 1
|
|
}
|
|
|
|
find_stash_ref_by_hash() {
|
|
local target_hash="$1" hash ref
|
|
while read -r hash ref; do
|
|
if [ "$hash" = "$target_hash" ]; then
|
|
printf '%s\n' "$ref"
|
|
return 0
|
|
fi
|
|
done < <(git stash list --format='%H %gd')
|
|
return 1
|
|
}
|
|
|
|
drop_stash_by_hash_if_present() {
|
|
local target_hash="$1" stash_ref
|
|
[ -n "$target_hash" ] || return 0
|
|
if stash_ref="$(find_stash_ref_by_hash "$target_hash")"; then
|
|
git stash drop "$stash_ref" >/dev/null
|
|
fi
|
|
}
|
|
|
|
restore_stash() {
|
|
local keep_saved_copy="${1:-0}" restore_target
|
|
|
|
if [ -z "$STASH_HASH" ] && [ -z "$STASH_REF" ]; then
|
|
return
|
|
fi
|
|
|
|
restore_target="${STASH_HASH:-$STASH_REF}"
|
|
say "Restoring stashed local changes from $restore_target..."
|
|
if git stash apply --index "$restore_target"; then
|
|
STASH_REF=""
|
|
if [ "$keep_saved_copy" -eq 0 ]; then
|
|
drop_stash_by_hash_if_present "$STASH_HASH"
|
|
STASH_HASH=""
|
|
STATE_STASH_HASH=""
|
|
else
|
|
STATE_STASH_HASH="${STASH_HASH:-$restore_target}"
|
|
fi
|
|
STATE_STATUS="completed"
|
|
update_state_for_sync
|
|
if [ "$keep_saved_copy" -eq 0 ]; then
|
|
say "Local changes restored successfully."
|
|
else
|
|
say "Local changes restored successfully. The original stash was kept for rollback safety."
|
|
fi
|
|
return
|
|
fi
|
|
|
|
STATE_STATUS="restore_conflict"
|
|
update_state_for_sync
|
|
say "Conflicts occurred while restoring local changes."
|
|
say "Backup branch kept at: $BACKUP_BRANCH"
|
|
say "Stash kept at: $restore_target"
|
|
say "Resolve the conflicts manually. After that, drop the stash yourself if it is no longer needed."
|
|
exit 1
|
|
}
|
|
|
|
find_latest_backup_branch_for_current() {
|
|
local safe_branch_name
|
|
safe_branch_name="$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
git for-each-ref --sort=-creatordate --format='%(refname:short)' "refs/heads/backup/${safe_branch_name}-before-upstream-sync-*" | head -n 1
|
|
}
|
|
|
|
run_list_backups() {
|
|
ensure_git_repo
|
|
if ! git for-each-ref --format='%(refname:short)' refs/heads/backup/ | grep -q .; then
|
|
say "No backup branches found."
|
|
return
|
|
fi
|
|
|
|
git for-each-ref --sort=-creatordate \
|
|
--format='%(refname:short) | %(creatordate:iso8601-local) | %(objectname:short) | %(subject)' \
|
|
refs/heads/backup/
|
|
}
|
|
|
|
run_restore_saved_stash() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
load_state || die "No saved sync state was found."
|
|
if [ -n "${STATE_BRANCH:-}" ] && [ "$CURRENT_BRANCH" != "$STATE_BRANCH" ]; then
|
|
die "Saved sync state belongs to branch '$STATE_BRANCH'. Check out that branch before restoring the saved stash."
|
|
fi
|
|
[ -n "$STATE_STASH_HASH" ] || die "There is no saved pre-sync stash to restore."
|
|
if worktree_has_local_changes; then
|
|
die "The working tree is not clean. Commit, stash, or discard current changes before restoring the saved stash."
|
|
fi
|
|
|
|
prepare_backup_before_real_action "restore-stash" "before-restore-stash"
|
|
|
|
STASH_HASH="$STATE_STASH_HASH"
|
|
STASH_REF=""
|
|
restore_stash 1
|
|
say "Saved pre-sync local changes restored."
|
|
}
|
|
|
|
run_rollback() {
|
|
local explicit_target=0 target_backup="${1:-}" rollback_safety_backup rollback_safety_snapshot=""
|
|
local reset_target="" reset_snapshot="" preserve_stash_hash=""
|
|
local original_restore_stash_hash="" original_restore_start_head=""
|
|
local rollback_safety_start_head=""
|
|
local explicit_snapshot=0
|
|
|
|
ensure_git_repo
|
|
ensure_no_nonrebase_git_operation_in_progress
|
|
load_state || true
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
|
|
if [ -n "$target_backup" ]; then
|
|
explicit_target=1
|
|
if is_valid_snapshot_dir "$target_backup"; then
|
|
explicit_snapshot=1
|
|
reset_snapshot="$target_backup"
|
|
fi
|
|
fi
|
|
|
|
if [ "$explicit_target" -eq 0 ] && [ -n "${STATE_BRANCH:-}" ] && [ "$CURRENT_BRANCH" != "$STATE_BRANCH" ]; then
|
|
die "Saved sync state belongs to branch '$STATE_BRANCH'. Check out that branch or pass an explicit backup branch."
|
|
fi
|
|
if [ "$explicit_snapshot" -eq 0 ] && [ "$explicit_target" -eq 0 ] && [ -n "${STATE_SNAPSHOT_PATH:-}" ] && is_valid_snapshot_dir "$STATE_SNAPSHOT_PATH"; then
|
|
reset_snapshot="$STATE_SNAPSHOT_PATH"
|
|
fi
|
|
if [ "$explicit_snapshot" -eq 0 ] && [ "$explicit_target" -eq 0 ] && [ -n "${STATE_START_HEAD:-}" ]; then
|
|
reset_target="$STATE_START_HEAD"
|
|
fi
|
|
if [ -z "$reset_target" ] && [ -z "$reset_snapshot" ] && [ -z "$target_backup" ]; then
|
|
target_backup="${STATE_BACKUP_BRANCH:-}"
|
|
fi
|
|
if [ -z "$reset_target" ] && [ -z "$reset_snapshot" ] && [ -z "$target_backup" ]; then
|
|
target_backup="$(find_latest_backup_branch_for_current || true)"
|
|
fi
|
|
if [ -z "$reset_target" ] && [ -z "$reset_snapshot" ]; then
|
|
[ -n "$target_backup" ] || die "No backup branch was found for rollback."
|
|
git show-ref --verify --quiet "refs/heads/$target_backup" || die "Backup branch '$target_backup' does not exist."
|
|
reset_target="$target_backup"
|
|
fi
|
|
|
|
original_restore_stash_hash="${STATE_STASH_HASH:-}"
|
|
original_restore_start_head="${STATE_START_HEAD:-}"
|
|
|
|
if has_rebase_in_progress; then
|
|
say "Aborting in-progress rebase before rollback..."
|
|
git rebase --abort || die "Failed to abort the in-progress rebase."
|
|
fi
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are still unmerged files in the working tree. Resolve or discard them before rollback."
|
|
fi
|
|
|
|
prepare_backup_before_real_action "rollback" "before-rollback"
|
|
rollback_safety_backup="$BACKUP_BRANCH"
|
|
rollback_safety_snapshot="$STATE_SNAPSHOT_PATH"
|
|
rollback_safety_start_head="$STATE_START_HEAD"
|
|
|
|
preserve_stash_hash=""
|
|
if worktree_has_local_changes; then
|
|
stash_current_changes "pre-rollback-preserve"
|
|
preserve_stash_hash="$STASH_HASH"
|
|
fi
|
|
|
|
if [ -n "$reset_target" ]; then
|
|
say "Resetting '$CURRENT_BRANCH' to '$reset_target'..."
|
|
git reset --hard "$reset_target" >/dev/null
|
|
fi
|
|
|
|
if [ -n "$original_restore_stash_hash" ]; then
|
|
STASH_HASH="$original_restore_stash_hash"
|
|
STASH_REF=""
|
|
BACKUP_BRANCH="$rollback_safety_backup"
|
|
say "Restoring original pre-sync local changes..."
|
|
restore_stash 1
|
|
fi
|
|
|
|
if [ -n "$reset_snapshot" ]; then
|
|
say "Restoring exact worktree snapshot from: $reset_snapshot"
|
|
restore_worktree_snapshot "$reset_snapshot"
|
|
fi
|
|
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$rollback_safety_backup"
|
|
STATE_STASH_HASH="$preserve_stash_hash"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_TARGET_BRANCH="$BRANCH"
|
|
STATE_START_HEAD="$rollback_safety_start_head"
|
|
STATE_SNAPSHOT_PATH="$rollback_safety_snapshot"
|
|
STATE_STATUS="rollback_completed"
|
|
write_state
|
|
|
|
say "Rollback completed."
|
|
if [ -n "$reset_snapshot" ]; then
|
|
say "Current branch and worktree restored from saved state."
|
|
say "Restored starting commit: ${original_restore_start_head:-$reset_target}"
|
|
say "Restored snapshot: $reset_snapshot"
|
|
else
|
|
say "Current branch restored from: $reset_target"
|
|
fi
|
|
say "Safety backup of the pre-rollback state kept at: $rollback_safety_backup"
|
|
say "Safety snapshot of the pre-rollback state kept at: $rollback_safety_snapshot"
|
|
if [ -n "$preserve_stash_hash" ]; then
|
|
say "Safety stash of the pre-rollback local changes kept at: $preserve_stash_hash"
|
|
fi
|
|
}
|
|
|
|
run_restore_snapshot() {
|
|
local target_snapshot="${1:-}" restore_safety_backup restore_safety_snapshot=""
|
|
local preserve_stash_hash="" restore_start_head="" restore_safety_start_head=""
|
|
|
|
ensure_git_repo
|
|
ensure_no_nonrebase_git_operation_in_progress
|
|
load_state || die "No saved sync state was found."
|
|
ensure_current_branch_with_state_fallback
|
|
ensure_upstream_remote
|
|
|
|
if [ -z "$target_snapshot" ]; then
|
|
target_snapshot="${STATE_SNAPSHOT_PATH:-}"
|
|
fi
|
|
is_valid_snapshot_dir "$target_snapshot" || die "No valid saved snapshot was found to restore."
|
|
restore_start_head="${STATE_START_HEAD:-}"
|
|
[ -n "$restore_start_head" ] || die "No saved starting commit was found for the snapshot restore."
|
|
|
|
if has_rebase_in_progress; then
|
|
say "Aborting in-progress rebase before snapshot restore..."
|
|
git rebase --abort || die "Failed to abort the in-progress rebase."
|
|
fi
|
|
|
|
if [ -n "$(git diff --name-only --diff-filter=U)" ]; then
|
|
die "There are still unmerged files in the working tree. Resolve or discard them before restoring the snapshot."
|
|
fi
|
|
|
|
prepare_backup_before_real_action "restore-snapshot" "before-restore-snapshot"
|
|
restore_safety_backup="$BACKUP_BRANCH"
|
|
restore_safety_snapshot="$STATE_SNAPSHOT_PATH"
|
|
restore_safety_start_head="$STATE_START_HEAD"
|
|
|
|
if worktree_has_local_changes; then
|
|
stash_current_changes "pre-restore-snapshot-preserve"
|
|
preserve_stash_hash="$STASH_HASH"
|
|
fi
|
|
|
|
say "Resetting '$CURRENT_BRANCH' to '$restore_start_head' before snapshot restore..."
|
|
git reset --hard "$restore_start_head" >/dev/null
|
|
|
|
if [ -n "${STATE_STASH_HASH:-}" ]; then
|
|
STASH_HASH="$STATE_STASH_HASH"
|
|
STASH_REF=""
|
|
BACKUP_BRANCH="$restore_safety_backup"
|
|
say "Restoring saved pre-sync local changes..."
|
|
restore_stash 1
|
|
fi
|
|
|
|
say "Restoring exact worktree snapshot from: $target_snapshot"
|
|
restore_worktree_snapshot "$target_snapshot"
|
|
|
|
STATE_BRANCH="$CURRENT_BRANCH"
|
|
STATE_BACKUP_BRANCH="$restore_safety_backup"
|
|
STATE_STASH_HASH="$preserve_stash_hash"
|
|
STATE_REMOTE_NAME="$REMOTE_NAME"
|
|
STATE_REMOTE_URL="$REMOTE_URL"
|
|
STATE_TARGET_BRANCH="$BRANCH"
|
|
STATE_START_HEAD="$restore_safety_start_head"
|
|
STATE_SNAPSHOT_PATH="$restore_safety_snapshot"
|
|
STATE_STATUS="snapshot_restored"
|
|
write_state
|
|
|
|
say "Snapshot restore completed."
|
|
say "Safety backup of the pre-restore state kept at: $restore_safety_backup"
|
|
say "Safety snapshot of the pre-restore state kept at: $restore_safety_snapshot"
|
|
if [ -n "$preserve_stash_hash" ]; then
|
|
say "Safety stash of the pre-restore local changes kept at: $preserve_stash_hash"
|
|
fi
|
|
}
|
|
|
|
run_dry_run_sync() {
|
|
local dry_run_branch_dir temp_repo patch_file has_tracked_changes has_untracked_changes
|
|
local dry_run_has_conflicts=0 untracked_conflicts=0 path
|
|
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
|
|
dry_run_branch_dir="$DRY_RUN_ROOT/$(sanitize_ref_name "$CURRENT_BRANCH")"
|
|
temp_repo="$dry_run_branch_dir/repo"
|
|
patch_file="$dry_run_branch_dir/local-changes.patch"
|
|
has_tracked_changes=0
|
|
has_untracked_changes=0
|
|
|
|
prepare_dry_run_workspace "$dry_run_branch_dir" "$temp_repo"
|
|
|
|
say "Testing upstream fetch in the dry-run clone..."
|
|
git -C "$temp_repo" fetch --prune "$REMOTE_NAME"
|
|
git -C "$temp_repo" show-ref --verify --quiet "refs/remotes/$REMOTE_NAME/$BRANCH" || die "Remote branch '$REMOTE_NAME/$BRANCH' was not found during test."
|
|
|
|
say "Testing rebase in the dry-run clone..."
|
|
if ! git -C "$temp_repo" rebase "$REMOTE_NAME/$BRANCH"; then
|
|
say "Dry-run failed during rebase."
|
|
if ! collect_all_rebase_conflicts_in_temp_clone "$temp_repo"; then
|
|
say "Dry-run could not enumerate all remaining rebase conflicts."
|
|
say "Current repository was not modified."
|
|
say "Dry-run workspace kept at: $temp_repo"
|
|
exit 1
|
|
fi
|
|
dry_run_has_conflicts=1
|
|
fi
|
|
|
|
if ! git diff --quiet HEAD || ! git diff --cached --quiet; then
|
|
has_tracked_changes=1
|
|
git diff --binary HEAD >"$patch_file"
|
|
if [ -s "$patch_file" ]; then
|
|
say "Testing re-apply of tracked local changes..."
|
|
if ! git -C "$temp_repo" apply --3way --index "$patch_file"; then
|
|
say "Dry-run detected tracked local-change conflicts during re-apply."
|
|
dry_run_has_conflicts=1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$(git ls-files --others --exclude-standard)" ]; then
|
|
has_untracked_changes=1
|
|
say "Testing collisions for untracked local files..."
|
|
while IFS= read -r -d '' path; do
|
|
if [ -e "$temp_repo/$path" ]; then
|
|
say "Untracked file would conflict after sync: $path"
|
|
untracked_conflicts=1
|
|
fi
|
|
done < <(git ls-files --others --exclude-standard -z)
|
|
fi
|
|
|
|
if [ "$untracked_conflicts" -ne 0 ]; then
|
|
say "Dry-run detected untracked-file conflicts."
|
|
dry_run_has_conflicts=1
|
|
fi
|
|
|
|
if [ "$dry_run_has_conflicts" -ne 0 ]; then
|
|
say "Dry-run completed with conflicts detected."
|
|
say "A real sync would require manual conflict resolution."
|
|
say "Current repository was not modified."
|
|
say "Dry-run workspace kept at: $temp_repo"
|
|
return 0
|
|
fi
|
|
|
|
if [ "$has_tracked_changes" -eq 0 ] && [ "$has_untracked_changes" -eq 0 ]; then
|
|
say "Dry-run passed. No local changes needed to be re-applied."
|
|
else
|
|
say "Dry-run passed. Local changes appear safe to restore after sync."
|
|
fi
|
|
say "Dry-run workspace ready for reuse at: $temp_repo"
|
|
}
|
|
|
|
run_sync() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
prepare_backup_before_real_action "sync" "before-upstream-sync"
|
|
stash_local_changes
|
|
STATE_STATUS="prepared"
|
|
update_state_for_sync
|
|
fetch_upstream
|
|
rebase_onto_upstream
|
|
restore_stash 1
|
|
say "Project is now synchronized with $REMOTE_NAME/$BRANCH."
|
|
say "Safety backup branch available at: $BACKUP_BRANCH"
|
|
say "Safety snapshot available at: $STATE_SNAPSHOT_PATH"
|
|
if [ -n "$STATE_STASH_HASH" ]; then
|
|
say "Original pre-sync stash retained for full rollback at: $STATE_STASH_HASH"
|
|
fi
|
|
}
|
|
|
|
run_fetch_only() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
fetch_upstream
|
|
say "Latest changes fetched from $REMOTE_NAME/$BRANCH."
|
|
}
|
|
|
|
run_backup_only() {
|
|
ensure_git_repo
|
|
ensure_no_git_operation_in_progress
|
|
ensure_current_branch
|
|
ensure_upstream_remote
|
|
create_backup_branch
|
|
}
|
|
|
|
show_menu() {
|
|
local choice
|
|
|
|
while true; do
|
|
cat <<EOF
|
|
Available actions:
|
|
1) Full safe sync
|
|
2) Dry-run
|
|
3) Fetch upstream only
|
|
4) Create backup branch only
|
|
5) List backup branches
|
|
6) Rollback to saved backup
|
|
7) Restore saved stash
|
|
8) Clean dry-run workspace
|
|
9) Restore exact snapshot
|
|
10) Show repository status
|
|
11) Help
|
|
0) Exit
|
|
EOF
|
|
printf 'Choose an action: '
|
|
read -r choice
|
|
|
|
case "$choice" in
|
|
1) run_sync; return ;;
|
|
2) run_dry_run_sync; return ;;
|
|
3) run_fetch_only; return ;;
|
|
4) run_backup_only; return ;;
|
|
5) run_list_backups ;;
|
|
6) run_rollback; return ;;
|
|
7) run_restore_saved_stash; return ;;
|
|
8) run_clean_dry_run ;;
|
|
9) run_restore_snapshot; return ;;
|
|
10) show_status ;;
|
|
11) show_usage ;;
|
|
0) exit 0 ;;
|
|
*) say "Invalid menu selection: $choice" ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
main() {
|
|
case "${1:-menu}" in
|
|
sync) run_sync ;;
|
|
dry-run|test) run_dry_run_sync ;;
|
|
fetch) run_fetch_only ;;
|
|
backup) run_backup_only ;;
|
|
list-backups) run_list_backups ;;
|
|
rollback) run_rollback "${2:-}" ;;
|
|
restore-stash) run_restore_saved_stash ;;
|
|
clean-dry-run) run_clean_dry_run ;;
|
|
restore-snapshot) run_restore_snapshot "${2:-}" ;;
|
|
status) show_status ;;
|
|
help|-h|--help) show_usage ;;
|
|
menu)
|
|
if [ -t 0 ] && [ -t 1 ]; then
|
|
show_menu
|
|
else
|
|
show_usage
|
|
fi
|
|
;;
|
|
*)
|
|
die "Unknown command: $1. Run with 'help' to see available options."
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "$@"
|