Git Advanced Lab

# 4 messy commits → 1 clean commit
git rebase -i HEAD~4
# Editor opens — change actions:
# pick  d4f5a6b feat: add login form  ← keep
# fixup c2d8e3b fix typo             ← merge, drop msg
# fixup b1e9f4a oops forgot a file   ← merge, drop msg
# fixup a3f7c2d WIP: trying approach ← merge, drop msg
# Save → result:
git log --oneline
# e5g6h7i feat: add login form ✅ clean!

# ── rebase -i action keywords ────────
# pick   = keep as-is (default)
# squash = merge + keep message
# fixup  = merge + discard message ★
# reword = keep commit, edit message
# drop   = delete commit entirely
# reorder = drag lines to reorder

# Keep branch fresh daily:
git rebase origin/main

# === Scenario: hotfix needed from feature branch ===
# You're on main. A critical security fix is on feat/auth
# but that branch has unfinished features too.
# You only want the security fix commit.

# Step 1: Find the commit hash
git log feat/auth --oneline
# a1b2c3d feat: add OAuth flow        ← don't want this yet
# e4f5g6h fix: patch SQL injection     ← want THIS
# h7i8j9k feat: start user profile     ← don't want this

# Step 2: Cherry-pick only the security fix
git switch main
git cherry-pick e4f5g6h
# [main k1l2m3n] fix: patch SQL injection
# Applied as a new commit on main!

# === Cherry-pick a range of commits ===
git cherry-pick abc123^..def456   # from abc123 to def456 (inclusive)

# === Cherry-pick without committing (--no-commit) ===
git cherry-pick --no-commit e4f5g6h
# Applies changes to working directory but doesn't commit
# Useful: combine multiple cherry-picks into one clean commit

# === If cherry-pick causes conflict ===
# 1. Resolve the conflict in the file
# 2. git add resolved-file
# 3. git cherry-pick --continue
# OR: git cherry-pick --abort  (go back to before)

# === Real DevOps use case ===
# Bug fixed on a feature branch during development
# Production still needs the fix NOW — don't wait for the full feature
# cherry-pick the fix commit to main → deploy immediately

# === Scenario: production bug, 500 commits of history
# You know HEAD is broken. A week ago it worked.
# Which commit introduced the bug?

# Without bisect: check each commit = 500 checks worst case
# With bisect: binary search = max 9 checks for 500 commits!

# === Start bisect ===
git bisect start

git bisect bad              # HEAD is broken
git bisect good v2.1.0      # tag from 2 weeks ago was good
# Git checks out the MIDDLE commit automatically

# === Now test if the bug exists ===
# Run your tests, check the feature...
npm test                    # or any test command

git bisect good             # This commit is fine
# Git moves to the next midpoint (upper half now)

# Repeat: test → bisect good/bad → repeat
git bisect bad              # This one is broken
git bisect good             # This one is fine
# ... ~7-9 more iterations ...

# Git announces:
# a4b5c6d is the first bad commit
# commit a4b5c6d
# Author: Developer Name
# Date:   Mon Nov 4 14:22:31 2024
#     feat: refactor authentication middleware

# === Reset back to HEAD ===
git bisect reset

# === Automate: pass a test script ===
git bisect start
git bisect bad HEAD
git bisect good HEAD~50
git bisect run npm test     # Runs npm test automatically at each step!
# Git runs the script, marks good/bad automatically
# Finds the bug commit without manual testing!

# reflog = "reference log" = every move HEAD has ever made

git reflog
# HEAD@{0}: reset: moving to HEAD~3       ← oh no, hard reset!
# HEAD@{1}: commit: feat: add dashboard
# HEAD@{2}: commit: fix: handle null case
# HEAD@{3}: commit: chore: cleanup imports ← lost these 3 commits?!
# HEAD@{4}: checkout: moving from main to feat/auth
# HEAD@{5}: commit: feat: add login form

# === Recover "lost" commits after hard reset ===
git reset --hard HEAD~3     # Oops! Lost 3 commits
git reflog                  # Find the SHA before the reset
git reset --hard HEAD@{1}   # Restore to before the reset
# All 3 commits back! 🎉

# === Recover a deleted branch ===
git branch -D feat/important # Accidentally deleted!
git reflog
# HEAD@{2}: checkout: moving from feat/important to main
# Find the last commit hash on that branch
git checkout -b feat/important HEAD@{2}
# Branch restored!

# === Reflog for a specific branch ===
git reflog show feat/auth    # History of that branch's tip
git reflog show HEAD         # HEAD movements

# === Reflog expires — default 90 days ===
# git gc --prune=now removes unreferenced objects
# Act quickly if you need to recover something!

cd my-devops-app

# === Make 4 messy commits ===
git switch -c lab/rebase-practice
echo "real feature code" > feature.js
git add feature.js && git commit -m "feat: add feature code"

echo "console.log('debug')" >> feature.js
git add feature.js && git commit -m "WIP: debugging"

echo "# comment" >> feature.js
git add feature.js && git commit -m "oops: add comment"

echo "// final" >> feature.js
git add feature.js && git commit -m "fix: cleanup"

git log --oneline
# 4 messy commits visible

# === Clean with interactive rebase ===
git rebase -i HEAD~4
# In editor: change last 3 "pick" → "fixup"
# pick  abc feat: add feature code
# fixup def WIP: debugging
# fixup ghi oops: add comment
# fixup jkl fix: cleanup
# Save and close editor

git log --oneline
# Only 1 commit: "feat: add feature code" ✅

# Clean up
git switch main
git branch -D lab/rebase-practice

# === Create 10 commits, bug at commit 7 ===
git switch -c lab/bisect-test

for i in 1 2 3 4 5 6; do
  echo "commit $i" >> history.txt
  git add . && git commit -m "chore: commit $i (clean)"
done

# Commit 7 = THE BUG
echo "ERROR: bug introduced here" > bug.txt
git add . && git commit -m "feat: commit 7 (introduces bug)"

for i in 8 9 10; do
  echo "commit $i" >> history.txt
  git add . && git commit -m "chore: commit $i (clean)"
done

# === Start bisect ===
git bisect start
git bisect bad HEAD          # Current commit is broken
git bisect good HEAD~10      # 10 commits ago was fine

# Git checks out middle → test → mark good/bad
# Check if bug.txt exists:
ls bug.txt 2>/dev/null && git bisect bad || git bisect good
# Repeat until Git finds the bad commit (~3-4 times)
# Git will say: "abc123 is the first bad commit"

git bisect reset             # Back to HEAD

# Automated version:
git bisect start
git bisect bad HEAD
git bisect good HEAD~10
git bisect run bash -c "! test -f bug.txt"
# Git finds commit 7 automatically!
git bisect reset

# Morning: sync
git switch main && git pull
git switch feat/my-feature
git rebase origin/main     # keep fresh

# Working
git status && git add -p
git commit -m "feat: ..."  # commitlint enforced

# Before PR: clean history
git rebase -i HEAD~N       # squash WIP commits
git push origin feat/my-feature

# Hotfix needed
git cherry-pick SHA        # take fix from feature

# After PR merge: cleanup
git switch main && git pull
git branch -d feat/my-feature
git fetch --prune