Recap — Squash, Edit, Reorder, Drop Commits

# Squash, Edit, Reorder, Drop Commits Interactive rebase (`git rebase -i`) is the most powerful Git command for history rewriting. Use it to clean up your branch before sharing. ## The command ```bash git rebase -i HEAD~5 # interactive rebase of last 5 commits git rebase -i main # interactive rebase of commits since divergence from main git rebase -i abc123 # everything after commit abc123 ``` Opens your editor with a list of commits and actions: ``` pick abc123 Add user model pick def456 WIP: working on tests pick ghi789 Fix typo in user model pick jkl012 Add tests for user pick mno345 Refactor user fields # Commands: # p, pick = use commit # r, reword = use commit, but edit the commit message # e, edit = use commit, but stop for amending # s, squash = use commit, but meld into previous commit # f, fixup = like squash, but discard this commit's message # d, drop = remove commit ``` You edit this file to specify what to do with each commit, save, and Git executes. ## Common operations ### Squash multiple commits into one ``` pick abc123 Add user model squash def456 WIP: working on tests squash ghi789 Fix typo in user model pick jkl012 Add tests for user pick mno345 Refactor user fields ``` Result: the first 3 become ONE commit. Git asks you for the combined message. `fixup` is like squash but discards the squashed commit's messages (keeps only the parent's). Cleaner if intermediate messages aren't useful. ### Reorder commits Just rearrange the lines: ``` pick mno345 Refactor user fields pick abc123 Add user model pick jkl012 Add tests for user drop def456 WIP drop ghi789 Fix typo ``` (Drops also work here.) ### Edit a commit (change content) ``` pick abc123 Add user model edit def456 WIP ← will stop here pick ghi789 Fix typo ``` Git stops at the `edit` commit. You make changes, then: ```bash git add changed_files.py git commit --amend # modify the commit git rebase --continue ``` Useful for: forgot to include a file, want to split a commit, fix a typo in code. ### Reword a commit message ``` reword abc123 Add user model pick def456 WIP ``` Git pauses just to let you edit the message; doesn't touch the diff. ### Drop a commit ``` drop def456 WIP ``` The commit and its changes are removed from history. Or just delete the line entirely — same effect. ## Typical pre-PR cleanup workflow You've been working on a feature for a few days: ``` * mno345 (HEAD -> feature) Add docstring * jkl012 Add tests * ghi789 Fix typo * def456 WIP: trying something * abc123 Add user model * xyz789 (main) Latest main commit ``` 5 commits with "WIP" / "typo" / "docstring" — messy. Before opening a PR: ```bash git rebase -i main ``` Editor: ``` pick abc123 Add user model squash def456 WIP: trying something pick jkl012 Add tests fixup ghi789 Fix typo fixup mno345 Add docstring ``` Result: 2 clean commits: ``` * abcdef (HEAD -> feature) Add tests * 123456 Add user model ``` Open PR; reviewers see two atomic commits. ## Splitting a commit If one commit does too much: ```bash git rebase -i HEAD~3 # In editor: change `pick` to `edit` for the commit to split ``` Git stops at that commit. Reset it but keep the changes: ```bash git reset HEAD^ # un-commit, keep changes staged git restore --staged file1 # unstage file1 git commit -m "Part 1: file2 changes" git add file1 git commit -m "Part 2: file1 changes" git rebase --continue ``` One commit → two commits. ## Conflicts during interactive rebase Same as regular rebase: resolve, `git add`, `git rebase --continue`. If stuck, `git rebase --abort` returns to pre-rebase state. ## Autosquash workflow A power feature: while developing, mark commits as fixups of earlier commits: ```bash git commit --fixup=abc123 # marks as fixup of abc123 git commit --squash=abc123 # marks as squash of abc123 ``` Then before pushing: ```bash git rebase -i --autosquash main ``` Git pre-arranges your fixups/squashes next to their target commits. You just save. Beautiful for iterative cleanup. ## When to interactive rebase Use: - Cleaning up before opening a PR. - Squashing WIP commits. - Fixing commit messages. - Reordering commits to be more logical. - Splitting a too-large commit. Don't use: - On commits that have been pushed AND others are using. - On `main` or shared branches. - If you're unsure — practice on a junk branch first. ## Recovery if you mess up `git reflog` records every HEAD movement, including rebases. Even if you "lose" commits, they're recoverable: ```bash git reflog # abc123 HEAD@{0}: rebase finished: returning to refs/heads/feature # 7890ab HEAD@{1}: rebase: Add user model # 4567cd HEAD@{2}: checkout: moving from main to feature # def456 HEAD@{3}: commit: Add user model ← previous version git reset --hard def456 # restore pre-rebase state ``` So: rebase is reversible (locally) within reflog's retention window. Reflog is usually kept ~90 days. ## Common interactive-rebase mistakes