How to Use Git Rebase to Squash Commits

Overview

Git is a powerful version control system that allows developers to manage and collaborate on projects efficiently. One of the features that can help maintain a clean and understandable commit history is the ability to squash commits. Squashing commits involves combining multiple commits into a single commit, which can make your project's history easier to read and understand.

In this post, we will explore:

1. What is Git squashing and why it's useful?
2. How to squash commits using git rebase.
3. A step-by-step guide for squashing commits interactively.
4. Best practices for using commit squashing in your workflow.

By the end of this post, you will have a clear understanding of how to use git rebase to squash commits and why it is an essential tool for maintaining a clean Git history.

1. What is Git Squashing and Why It's Useful?

Understanding Commit Squashing

When you work on a feature or bug fix, you might make several commits to your local branch. These commits could include small changes, fixes for mistakes, or experiments that may not be relevant to the final implementation. While these commits are important for your development process, they can clutter your project's commit history.

Squashing commits allows you to take these multiple commits and combine them into a single, cohesive commit. This practice provides several benefits:

• Cleaner History: A cleaner commit history makes it easier for team members and future contributors to understand the evolution of the codebase.
• Logical Grouping: Squashing commits allows you to group related changes into a single commit, reflecting the work done on a particular feature or fix.
• Reduced Noise: By removing intermediate commits, you reduce noise in the Git history, which can make debugging and code reviews simpler.

When to Squash Commits

Squashing commits is most beneficial in the following scenarios:

• Feature Development: When completing a feature branch that consists of multiple small commits, squashing can summarize the changes before merging into the main branch.
• Fixing Mistakes: If you made several small commits to fix issues, you might want to squash them into one commit that describes the final state.
• Cleanup Before Merging: Before merging a long-lived branch back into the main branch, squashing can help ensure the history remains understandable.

2. How to Squash Commits Using git rebase

The most common way to squash commits in Git is by using the git rebase command in interactive mode. This allows you to modify the commit history of your branch.

Basic Syntax for Squashing Commits

git rebase -i <base>

Where <base> is the commit hash or branch name from which you want to start the rebase. This command opens an interactive interface that lets you choose which commits to squash.

3. Step-by-Step Guide for Squashing Commits Interactively

Let’s walk through a detailed step-by-step guide on how to squash commits using git rebase.

Step 1: Check Your Commit History

First, check your current commit history to see the commits you want to squash. Use the following command to view your commit history:

git log --oneline

This command shows a concise list of your commits with their hashes.

Example output:

f3b2d7a Add feature A
b0a3e5d Fix bug in feature A
c5a1e3b Update documentation for feature A
3e2d9c1 Initial commit

Step 2: Start an Interactive Rebase

Next, initiate an interactive rebase. You need to specify the commit before the first commit you want to squash. In this case, if you want to squash the last three commits into one, you would run:

git rebase -i HEAD~3

This command tells Git to start a rebase that includes the last three commits.

Step 3: Choose Commits to Squash

After running the above command, an editor will open displaying a list of commits:

pick f3b2d7a Add feature A
pick b0a3e5d Fix bug in feature A
pick c5a1e3b Update documentation for feature A

To squash commits, replace the word pick with squash (or simply s) for the commits you want to combine with the previous commit. The first commit remains as pick.

Here’s how it should look if you want to squash the last two commits into the first one:

pick f3b2d7a Add feature A
squash b0a3e5d Fix bug in feature A
squash c5a1e3b Update documentation for feature A

Step 4: Save and Exit the Editor

After editing the commit list, save the file and exit the editor. This will start the rebase process.

Step 5: Edit the Commit Message

Once you save and exit, Git will prompt you to edit the commit message for the squashed commit. The editor will display a default message combining the commit messages of the squashed commits. You can edit this message to create a meaningful summary of the changes.

Example:

Add feature A

- Fix bug in feature A
- Update documentation for feature A

Edit the message as needed, then save and exit the editor.

Step 6: Finish the Rebase

If everything goes smoothly, Git will complete the rebase, and your commit history will now reflect the squashed commit.

Step 7: Check Your Commit History Again

You can verify that your commits were successfully squashed by running:

git log --oneline

You should see a single commit representing the changes you made.

4. Best Practices for Using Commit Squashing in Your Workflow

Here are some best practices to keep in mind when squashing commits in your Git workflow:

1. Squash Before Merging

Always squash your commits before merging feature branches into the main branch. This helps maintain a clean and concise history in the main repository.

2. Use Meaningful Commit Messages

When squashing commits, make sure to write meaningful commit messages that clearly describe the overall change. This helps future developers (including yourself) understand the purpose of the changes.

3. Communicate with Your Team

If you’re working in a team, communicate with your team members about your squashing practices. Agree on how and when to squash commits to ensure consistency.

4. Avoid Squashing Public Commits

Be cautious when squashing commits that have already been shared with others, as it rewrites history. Squashing should typically be done on local branches before pushing to shared repositories.

5. Use Git Aliases for Squashing

Consider setting up Git aliases for common squash operations to simplify your workflow. For example, you can create an alias for squashing the last N commits:

git config --global alias.squash-commits '!f() { git rebase -i HEAD~$1; }; f'

Then, you can simply run:

git squash-commits 3

Conclusion

Squashing commits using git rebase is a powerful technique to clean up your commit history, making it more manageable and readable. By combining multiple related commits into a single commit, you improve the overall organization of your Git repository.

Key Takeaways:

1. Git squashing allows you to combine multiple commits into one, resulting in a cleaner commit history.
2. You can use git rebase -i to interactively choose which commits to squash.
3. It’s essential to write meaningful commit messages when squashing commits to maintain clarity in your project history.
4. Communicate squashing practices with your team to ensure consistency in your workflow.

With these tools and practices, you'll be able to manage your commit history more effectively and maintain a well-organized codebase.