Hands-on lab — Day 34: Undoing Things: Reset, Revert, and Reflog

#!/usr/bin/env bash
# Day 034 lab — completed reference: undo and recover in Git.
#
# Builds a THROWAWAY git repository in a temporary directory, then walks
# through every undo move from the lesson and ends with a deliberate
# "disaster" (git reset --hard HEAD~2) that we recover from with the reflog.
# Nothing outside the temp directory is touched, and it is deleted on exit.
#
# Run it from the lab directory:  bash examples/undo_recover.sh
set -euo pipefail

# --- create an isolated scratch repo ------------------------------------
work="$(mktemp -d "${TMPDIR:-/tmp}/undo-recover.XXXXXX")"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT
cd "${work}"

section() { printf '\n=== %s ===\n' "$1"; }

git init -q
# Local identity only — your global git config is left untouched.
git config user.email "learner@example.com"
git config user.name "Undo Learner"
# Keep the branch name predictable across git versions.
git symbolic-ref HEAD refs/heads/main 2>/dev/null || true

section "1. Build a small history"
echo "line 1" > notes.txt
git add notes.txt
git commit -q -m "Frist commit"          # deliberate typo, fixed next
echo "step two" >> notes.txt
git commit -q -am "Second commit"
echo "step three" >> notes.txt
git commit -q -am "Third commit"
git log --oneline

section "2. git commit --amend fixes the last message"
echo "before amend, HEAD subject:"
git log -1 --pretty=%s
git commit -q --amend -m "Third commit (message fixed)"
echo "after amend, HEAD subject:"
git log -1 --pretty=%s

section "3. git restore --staged un-stages a file"
echo "a scratch change" > scratch.txt
git add scratch.txt
echo "status shows scratch.txt as staged:"
git status --short
git restore --staged scratch.txt
echo "after restore --staged, scratch.txt is no longer staged:"
git status --short
rm -f scratch.txt

section "4. git restore discards a working-tree change"
echo "OOPS unwanted edit" >> notes.txt
echo "notes.txt now has an unwanted last line:"
tail -n 1 notes.txt
git restore notes.txt
echo "after restore, the unwanted line is gone; last line is:"
tail -n 1 notes.txt

section "5. git reset --soft keeps changes staged, then re-commit"
git reset --soft HEAD~1
echo "after --soft reset, the change is still staged:"
git status --short
git commit -q -m "Third commit (re-committed after soft reset)"
git log --oneline

section "6. git revert adds an inverse commit (safe for shared history)"
target="$(git rev-parse --short HEAD)"
git revert --no-edit "${target}"
echo "log now shows the original commit AND its revert:"
git log --oneline -n 2

section "7. DISASTER: git reset --hard HEAD~2 drops two commits"
before_count="$(git rev-list --count HEAD)"
echo "commit count before disaster: ${before_count}"
git reset --hard HEAD~2
after_count="$(git rev-list --count HEAD)"
echo "commit count after --hard reset: ${after_count}"
echo "log is now shorter:"
git log --oneline

section "8. RECOVER with git reflog"
echo "the reflog still remembers where HEAD used to be:"
git reflog -n 5
# The commit we were on BEFORE the disastrous reset is reflog entry HEAD@{1}.
lost="$(git rev-parse --short 'HEAD@{1}')"
echo "recovering to the pre-disaster commit: ${lost}"
git reset --hard "${lost}"
recovered_count="$(git rev-list --count HEAD)"
echo "commit count after recovery: ${recovered_count}"
git log --oneline

section "Result"
if [ "${recovered_count}" = "${before_count}" ]; then
  echo "SUCCESS: recovered ${recovered_count} commits — nothing was truly lost."
else
  echo "MISMATCH: expected ${before_count}, got ${recovered_count}" >&2
  exit 1
fi

lesson_id: D034
day: 34
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-034-undoing-things-reset-revert-and-reflog
run_commands:
  - bash examples/undo_recover.sh
  - bash starter/undo_recover.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# none needed: scripts work only inside a temp dir deleted on exit'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), git 2.50.1, bash tests/run_tests.sh → 8 checks, 0 failures'

# Dependencies — Day 034 lab

**Only Git and a POSIX shell.** This lab has zero installable dependencies
beyond tools you already have from the Git section:

- `git` (2.23 or newer recommended, so that `git restore` is available;
  every command was verified on git 2.50.1). Check yours with `git --version`.
- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution).
- Standard utilities: `mktemp`, `rm`, `tail` — all part of the base system.

No network access is required and no API key is needed: every operation runs
against a throwaway local repository created in a temporary directory. If
`git restore` is unavailable on an older Git, the lesson and troubleshooting
notes give the equivalent `git reset HEAD <file>` and `git checkout -- <file>`
commands.

#!/usr/bin/env bash
# Day 034 lab — YOUR working file: undo and recover in Git.
#
# This starter builds a THROWAWAY git repository in a temporary directory
# and sets up a small history for you. Your job is to complete the five
# numbered exercises below: replace each line marked  # <-- replace  with the
# single git command named just above it in the  # TASK:  comment. The
# completed reference is in examples/undo_recover.sh — try it yourself first.
#
# As shipped, the script runs to the end and prints "NOT YET" because the
# recovery is not done. When you have finished all five tasks it prints
# "SUCCESS". Nothing outside the temp directory is touched; it is deleted on
# exit. Run it from the lab directory:  bash starter/undo_recover.sh
#
# Note: this starter uses `set -uo pipefail` (no `-e`) on purpose, so an
# unfinished exercise does not abort the whole script.
set -uo pipefail

work="$(mktemp -d "${TMPDIR:-/tmp}/undo-starter.XXXXXX")"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT
cd "${work}" || exit 1

section() { printf '\n=== %s ===\n' "$1"; }

git init -q
git config user.email "learner@example.com"
git config user.name "Undo Learner"
git symbolic-ref HEAD refs/heads/main 2>/dev/null || true

section "Setup: a three-commit history"
echo "line 1" > notes.txt
git add notes.txt
git commit -q -m "Frist commit"          # note the deliberate typo
echo "line 2" >> notes.txt
git commit -q -am "Second commit"
echo "line 3" >> notes.txt
git commit -q -am "Third commit"
git log --oneline

section "Exercise 1: fix the last commit message with amend"
echo "before:"; git log -1 --pretty=%s
# TASK 1: amend the last commit's message here, using:
#         git commit --amend -m "Third commit (fixed)"
echo 'TASK 1 not done — replace this line with the amend command'   # <-- replace
echo "after:"; git log -1 --pretty=%s

section "Exercise 2: un-stage a file with restore --staged"
echo "scratch" > scratch.txt
git add scratch.txt
echo "staged now:"; git status --short
# TASK 2: un-stage scratch.txt using:  git restore --staged scratch.txt
echo 'TASK 2 not done — replace this line with the restore --staged command'   # <-- replace
echo "after un-staging (should be ?? not A):"; git status --short
rm -f scratch.txt

section "Exercise 3: discard a working change with restore"
echo "unwanted line" >> notes.txt
echo "last line before restore:"; tail -n 1 notes.txt
# TASK 3: discard the edit to notes.txt using:  git restore notes.txt
echo 'TASK 3 not done — replace this line with the restore command'   # <-- replace
echo "last line after restore (should be 'line 3'):"; tail -n 1 notes.txt
git checkout -q -- notes.txt 2>/dev/null || true   # keep the repo tidy for later steps

section "Exercise 4: un-commit with reset --soft, then re-commit"
echo "line 3 again" >> notes.txt
# TASK 4: rewind one commit but keep the change staged, using:
#         git reset --soft HEAD~1
echo 'TASK 4 not done — replace this line with the reset --soft command'   # <-- replace
echo "staged after soft reset (should list notes.txt as M):"; git status --short
git commit -q -am "Third commit (re-committed)" 2>/dev/null || true

section "Exercise 5: DISASTER and RECOVERY"
before_count="$(git rev-list --count HEAD)"
echo "commit count before disaster: ${before_count}"
git reset --hard HEAD~2 >/dev/null
echo "count after --hard HEAD~2: $(git rev-list --count HEAD)"
git reflog -n 5
# TASK 5: recover the dropped commits. The pre-disaster commit is HEAD@{1}
#         in the reflog. Restore it using:  git reset --hard 'HEAD@{1}'
echo 'TASK 5 not done — replace this line with the recovery reset command'   # <-- replace
recovered_count="$(git rev-list --count HEAD)"
echo "commit count after recovery attempt: ${recovered_count}"
git log --oneline

section "Result"
if [ "${recovered_count}" = "${before_count}" ]; then
  echo "SUCCESS: recovered ${recovered_count} commits — nothing was lost."
else
  echo "NOT YET: expected ${before_count}, got ${recovered_count}. Finish the five TASKs above."
fi

# Undo and Recover — Day 034 worksheet

Fill this in as you complete the five exercises in `undo_recover.sh` (or as
you run the reference in `examples/undo_recover.sh`). Keep it — the Week 5
project (a versioned notes repository) expects you to demonstrate a clean
recovery, and this is your rehearsal.

## 1. What `git commit --amend` changed

| | Before amend | After amend |
| --- | --- | --- |
| Commit message (subject) |  |  |
| Commit hash (short) |  |  |

One sentence: why did the hash change even though I only edited the message?

>

## 2. `git reset --soft` versus `git reset --hard`

For each mode, record what happened to your **staged changes** (the index)
and your **edited files** (the working tree).

| Reset mode | What happened to staged changes | What happened to edited files |
| --- | --- | --- |
| `git reset --soft HEAD~1` |  |  |
| `git reset --hard HEAD~1` |  |  |

One sentence: which mode is safe to run with uncommitted work you care about,
and which one would destroy it?

>

## 3. The reflog hash I recovered

- Commit count **before** the disaster (`git reset --hard HEAD~2`): __________
- Commit count **after** the disaster: __________
- The reflog line I recovered from (paste it): 

  ```
  
  ```

- The exact command I ran to recover: 

  ```
  
  ```

- Commit count **after** recovery: __________

One or two sentences: why did restoring to that single commit bring back the
*whole* chain of commits, not just one?

>

## One thing that surprised me

One or two sentences.

#!/usr/bin/env bash
# Tests for the Day 034 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Builds its own throwaway repository in a temp directory and independently
# verifies the three claims of the lesson:
#   (1) git commit --amend changes the last commit,
#   (2) git revert creates a new inverse commit,
#   (3) after git reset --hard the dropped commits are RECOVERED via reflog.
# Exits 0 on success, non-zero on any failure. No network, no sudo.
set -u

# Resolve the lab directory before we change into the scratch repo.
lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# --- isolated scratch repo ----------------------------------------------
work="$(mktemp -d "${TMPDIR:-/tmp}/undo-test.XXXXXX")"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT
cd "${work}" || { echo "cannot enter temp dir"; exit 1; }

git init -q
git config user.email "test@example.com"
git config user.name "Undo Test"
git symbolic-ref HEAD refs/heads/main 2>/dev/null || true

echo "Testing undo and recovery in a throwaway repo ..."

# Build a three-commit history.
echo "a" > f.txt; git add f.txt; git commit -q -m "Frist commit"
echo "b" >> f.txt; git commit -q -am "Second commit"
echo "c" >> f.txt; git commit -q -am "Third commit"

# (1) amend changes the last commit (subject and hash both change).
before_hash="$(git rev-parse HEAD)"
before_subj="$(git log -1 --pretty=%s)"
git commit -q --amend -m "Third commit (fixed)"
after_hash="$(git rev-parse HEAD)"
after_subj="$(git log -1 --pretty=%s)"
[ "${before_hash}" != "${after_hash}" ] && check "amend changes the commit hash" "yes" || check "amend changes the commit hash" "no"
[ "${before_subj}" = "Third commit" ] && [ "${after_subj}" = "Third commit (fixed)" ] \
  && check "amend changes the commit message" "yes" || check "amend changes the commit message" "no"

# (2) revert creates a new inverse commit on top.
count_before_revert="$(git rev-list --count HEAD)"
git revert --no-edit HEAD >/dev/null
count_after_revert="$(git rev-list --count HEAD)"
revert_subj="$(git log -1 --pretty=%s)"
[ "${count_after_revert}" -eq "$((count_before_revert + 1))" ] \
  && check "revert adds one new commit" "yes" || check "revert adds one new commit" "no"
case "${revert_subj}" in
  Revert*) check "the new commit is an inverse (Revert) commit" "yes" ;;
  *)       check "the new commit is an inverse (Revert) commit" "no" ;;
esac

# (3) hard reset drops commits; reflog recovers them.
full_count="$(git rev-list --count HEAD)"
git reset --hard HEAD~2 >/dev/null
dropped_count="$(git rev-list --count HEAD)"
[ "${dropped_count}" -eq "$((full_count - 2))" ] \
  && check "hard reset drops two commits" "yes" || check "hard reset drops two commits" "no"

# The pre-disaster commit is reflog entry HEAD@{1}.
lost="$(git rev-parse 'HEAD@{1}')"
[ -n "${lost}" ] && check "reflog still references the lost commit" "yes" || check "reflog still references the lost commit" "no"
git reset --hard "${lost}" >/dev/null
recovered_count="$(git rev-list --count HEAD)"
[ "${recovered_count}" -eq "${full_count}" ] \
  && check "commits RECOVERED via reflog (count restored)" "yes" || check "commits RECOVERED via reflog (count restored)" "no"

# The reference implementation runs end to end and exits 0.
if bash "${lab_dir}/examples/undo_recover.sh" >/dev/null 2>&1; then
  check "examples/undo_recover.sh runs end to end" "yes"
else
  check "examples/undo_recover.sh runs end to end" "no"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]