Advanced Git Concepts (Rebase & Cherry-Pick)

TL;DR

You'll learn two powerful Git commands, rebase and cherry-pick, which help you keep your commit history clean and move specific changes between branches. Mastering these tools improves collaboration and makes your project's history easier to understand. Be cautious, as both commands rewrite history and can be destructive if not used carefully.

1. The Mental Model

Think of your Git commit history as a story. Rebase lets you rewrite parts of that story by moving a whole chapter (branch) to start from a different point. Cherry-pick lets you copy a single paragraph (commit) from one part of the story to another.

2. The Core Material

Understanding Rebase

Photo by Youn Seung Jin on Pexels

Git rebase is used to integrate changes from one branch onto another by moving or combining entire sequences of commits. Instead of merging two branches and creating a new merge commit, rebase effectively "replays" your branch's commits on top of the target branch, keeping a linear history.

It's useful for:
* Keeping your feature branch up-to-date with the main branch.
* Squashing multiple small commits into one clean commit before merging.
* Cleaning up messy commit histories.

How it works:
1. Git finds the common ancestor between your current branch and the target branch.
2. It saves your branch's commits temporarily.
3. It resets your branch to the same point as the target branch.
4. It then applies your saved commits one by one on top of the target branch's latest commit.

graph TD
    A["Initial Commit (Master)"] --> B["Feature Commit 1 (mine)"]
    A --> C["Team Commit 1 (master)"]
    B --> D["Feature Commit 2 (mine)"]
    C --> E["Team Commit 2 (master)"]
    subgraph Before Rebase
        Master(Master Branch)
        Feature(Feature Branch)
        Master --- C
        Master --- E
        Feature --- B
        Feature --- D
    end

    E -.-> F["Rebase Feature branch onto Master"]
    subgraph After Rebase
        Master_New(Master Branch)
        Feature_New(Feature Branch)
        A --- C_Rebased(C')
        A --- E_Rebased(E')
        E_Rebased --- B_Rebased(B'' - B replayed)
        B_Rebased --- D_Rebased(D'' - D replayed)
        Master_New --- C_Rebased
        Master_New --- E_Rebased
        Feature_New --- B_Rebased
        Feature_New --- D_Rebased
    end

Common rebase commands:
* git checkout my-feature-branch
* git rebase master (rebase your feature branch onto master)
* git rebase -i HEAD~N (interactive rebase for the last N commits on your current branch)

Understanding Cherry-Pick

Photo by Vlad Vasnetsov on Pexels

Git cherry-pick allows you to select specific commits from one branch and apply them to another branch. Unlike rebase, which moves a whole sequence, cherry-pick lets you pick and choose individual commits.

It's useful for:
* Backporting hotfixes from a main branch to an older release branch.
* Taking a single, isolated commit from a feature branch into main without merging the entire feature.
* Moving a small change you accidentally committed to the wrong branch.

How it works:
1. You identify the SHA-1 hash of the commit you want to copy.
2. Git creates a new commit on your current branch with the exact same changes as the chosen commit.

Common cherry-pick commands:
* git checkout target-branch
* git cherry-pick <commit-hash> (apply the single commit to the current branch)
* git cherry-pick <commit-hash-1> <commit-hash-2> (pick multiple commits)

Dealing with Conflicts

Photo by Alex Green on Pexels

Both rebase and cherry-pick can lead to merge conflicts, especially if the same lines of code have been changed in different ways. You resolve these conflicts just like a regular merge:
1. Edit the conflicting files.
2. git add the resolved files.
3. For rebase: git rebase --continue
4. For cherry-pick: git commit (it's a new commit you're creating)

Important Note: Both rebase and cherry-pick rewrite commit history. Never rebase or cherry-pick commits that have already been pushed to a shared remote repository if other people are working on them, as this can cause major problems for collaborators. Only use these on your local, unpushed branches, or on shared branches where you've explicitly coordinated with your team.

3. Worked Example

Let's say you're on a feature branch, my-feature, and have made two commits. Meanwhile, the main branch has progressed. You want to update your my-feature branch with the latest main changes while keeping a clean, linear history.

# 1. Start on your feature branch
git checkout my-feature

# (Imagine main has new commits you don't have locally yet)
# 2. Fetch latest changes from the remote
git fetch origin

# 3. Rebase your feature branch onto the latest 'main' from origin
#    This will effectively move your feature branch commits to the end of main's history.
git rebase origin/main

# If conflicts occur:
#    - Edit files to resolve conflicts
#    - git add <conflicted-file>
#    - git rebase --continue

# If you need to stop the rebase:
#    - git rebase --abort

# After successful rebase, your feature branch now starts from
# the latest state of 'main', followed by your feature commits.

# Now, imagine you have a critical bugfix commit on your 'my-feature' branch (let's say its hash is 'abcde123').
# You realize this fix is urgent and needs to go into 'main' right away,
# without waiting for the entire 'my-feature' to be ready.

# 1. Switch to the target branch (main)
git checkout main

# 2. Cherry-pick the specific bugfix commit
git cherry-pick abcde123

# If conflicts occur:
#    - Edit files to resolve conflicts
#    - git add <conflicted-file>
#    - git commit -m "Cherry-picked: Fixed critical bug from my-feature"

# Now, the bugfix commit is a new commit on your 'main' branch.

4. Key Takeaways

• Rebase moves a series of commits from your current branch to start on top of another branch, creating a linear history.
• Cherry-pick copies a single, standalone commit from one branch and applies it as a new commit on your current branch.
• Both rebase and cherry-pick rewrite commit history, so avoid using them on publicly shared branches.
• Use rebase to keep your feature branch up-to-date with main or to clean up your commit history before merging.
• Use cherry-pick for backporting hotfixes or moving isolated changes between branches.
• You'll likely encounter merge conflicts; resolve them carefully and continue the operation.
• Always git fetch before rebasing onto a remote branch like origin/main to ensure you have the latest state.

5. Now Try It

Create a new Git repository (or use an existing practice one). Create a main branch and a feature-a branch. Make 2-3 different commits on main. Then, switch to feature-a, make 2-3 commits there, and then rebase feature-a onto main. After that, selectively cherry-pick one of your feature-a commits back into main. Verify your commit history with git log --oneline --graph. Success looks like a clean, linear history on feature-a (after rebase) and the cherry-picked commit appearing distinctly on main.
```