how to squash all commits in a branch

Guri Bee

3 min read

·

23-10-2024

1

0

Share

Squashing Your Commits: A Guide to Streamlining Your Git History

Ever find yourself with a branch overflowing with small, individual commits? It happens to the best of us! While granular commits are great for tracking progress and collaborating, sometimes you need to tidy things up and present a clean, concise history. Enter the art of squashing commits.

This article will explore the ins and outs of squashing, providing you with the knowledge and tools to transform your messy branch into a polished masterpiece. We'll leverage real-world examples and insights from the GitHub community to ensure you understand the process and its nuances.

Why Squash Commits?

Before diving into the mechanics, let's address the "why" behind squashing. Here are a few compelling reasons:

• Cleaner Git History: Squashing simplifies your commit history, making it easier to navigate and understand.
• Refined Pull Requests: When contributing to a project, a well-squashed branch provides a more elegant and readable view for reviewers, enhancing collaboration.
• Streamlined Rebase: Squashing allows for more efficient rebasing, especially when you're working on large features and want to combine multiple commits into a single, cohesive unit.

The Squashing Process

Squashing involves combining multiple commits into a single commit. This is achieved using the git rebase -i command. Let's break down the steps with an example:

1. Identify the Commits to Squash:

Imagine you have a branch named "feature-x" with the following commit history:

commit 1: Fix typo in the description
commit 2: Update the styling of the button
commit 3: Add a new feature
commit 4: Initial commit

You want to squash commits 1, 2, and 3 into commit 4.

2. Rebase Interactively:

Open your terminal and navigate to the "feature-x" branch:

git checkout feature-x
git rebase -i HEAD~3

This command opens an interactive rebase session, showing the last three commits.

3. Edit the Rebase Session:

You'll be presented with a text editor. The default configuration displays something like this:

pick 1234567 Fix typo in the description
pick 8765432 Update the styling of the button
pick 9876543 Add a new feature
pick 1234567 Initial commit

# Rebase 9876543..1234567 onto 9876543 (3 commands)
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = squash the commit into the previous one
# f, fixup = squash the commit into the previous one (but drop commit message)
# x, exec = run command (the rest of the line)
# d, drop = remove commit
# b, break = stop rebasing (continue later with "git rebase --continue")
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out.

4. Squash the Commits:

Replace the "pick" lines for the commits you want to squash with "squash". For example:

squash 1234567 Fix typo in the description
squash 8765432 Update the styling of the button
pick 9876543 Add a new feature
pick 1234567 Initial commit

Save and close the editor.

5. Rebase and Edit:

Git will perform the rebase, prompting you to edit the commit message for the combined commit. Edit the message as desired and save the file.

6. Push Your Changes:

Finally, push your branch with the squashed commits:

git push --force-with-lease origin feature-x

Important Note:

The --force-with-lease flag is crucial. It ensures that your rebase operation doesn't overwrite someone else's changes.

Real-World Examples and Best Practices

Example: Squashing Commits in a Pull Request

Let's say you've created a pull request with several commits, and the reviewer suggests squashing them for readability. You can follow the steps outlined above to rebase your branch, squashing the commits before pushing the updated branch.

Best Practices:

• Squash Before Pushing: Squashing commits before pushing to a shared repository minimizes potential conflicts and confusion.
• Choose Meaningful Commit Messages: Even after squashing, your final commit message should accurately reflect the changes made.
• Keep it Clean: Aim for a clear and logical commit history that tells the story of your development process.

Conclusion

Squashing commits is a powerful tool for organizing and presenting a clean Git history. By following the steps outlined in this article, you can streamline your development workflow and enhance the clarity of your work. Remember, the key is to use squashing strategically to achieve the desired outcome, whether it's simplifying a complex branch, preparing for a pull request, or maintaining a tidy repository history.

Attribution:

This article incorporates insights and examples from the GitHub community, specifically from discussions and documentation related to git rebase -i and squashing techniques.