Using interactive rebase in Git

About

An interactive rebase in Git is a process that allows you to edit a sequence of commits. This is typically used to clean up commit history before sharing changes with other members of the team.

Case study

Let’s study an example of making a clear 3-commit history out of the initial 5 commits.

Start an interactive rebase: Start an interactive rebase for the last 5 commits. If your branch has 5 commits ahead of the base branch, you can use:

Interactive rebase editor: This command will open your default text editor with a list of the last 5 commits, starting from the oldest commit to the newest. The lines will look something like this:

Edit the commits: Change the word “pick” to specify what you want to do with each commit. To squash commits into one, you can use the word “squash” or “s” for short. For example, if you want to combine commits 2, 3, and 4 into one, you would modify the list like this:

Save and close the editor: After modifying the list, save and close the editor. Git will start the rebase process.

Edit commit messages: Git will then reopen the editor to allow you to combine commit messages. You can edit the commit messages to reflect the new commits. For example, you might see something like this:

You can edit this to create a new combined commit message:

Complete the rebase: Save and close the editor. Git will complete the rebase process.

Example

Assume your commits are:

abc123 – Initial setup

def456 – Added feature A

ghi789 – Fixed bug in feature A

jkl012 – Improved feature A

mno345 – Added feature B

You want to have the following commits:

Initial setup
Feature A (including the fix and improvement)
Feature B

Your rebase edit list would look like this:

And after saving the first list, you would combine the messages of the second, third, and fourth commits into something like:

The editor used for an interactive rebase in Git is determined by your Git configuration and environment settings. By default, Git uses the default editor configured for your system, such as vi or nano on many Unix-like systems, or Notepad on Windows.

By following these steps, you can adjust your commits into three sensible commits with the desired commit messages.

Other commands for interactive rebase

During an interactive rebase in Git, several operations can be performed to modify the commit history. Here’s a short list of the key operations along with their syntax and explanations:

pick (or p):

Syntax: pick <commit-hash> <commit-message>

Explanation: Use the commit as-is. This is the default operation and is used to keep a commit unchanged.

reword (or r):

Syntax: reword <commit-hash> <commit-message>

Explanation: Use the commit, but modify the commit message.

edit (or e):

Syntax: edit <commit-hash> <commit-message>

Explanation: Pause the rebase to allow amendments to the commit. This can be used to change the content of the commit or the commit message.

squash (or s):

Syntax: squash <commit-hash> <commit-message>

Explanation: Combine the commit with the previous commit, merging their changes and allowing you to edit the commit message.

fixup (or f):

Syntax: fixup <commit-hash> <commit-message>

Explanation: Similar to squash, but discard the commit message of the commit being combined. The commit message of the previous commit is used.

exec (or x):

Syntax: exec <command>

Explanation: Execute a shell command.

drop (or d):

Syntax: drop <commit-hash> <commit-message>

Explanation: Remove the commit entirely. This can be used to delete unnecessary or undesired commits from the history.

break:

Syntax: break

Explanation: Pause the rebase at this point to allow inspection or further manual intervention. This is useful for debugging the state of the repository.

And others.

Usage example for some of the commands

Here’s an example of what the rebase instructions file might look like when you initiate an interactive rebase:

Alternatively, use the first letters to for calling each of the commands:

References

Git Tools – Rewriting History
Vim Cheat Sheet