Consolidating Commits with Git: Squashing Techniques

In Git, squashing commits refers to the process of combining multiple commits into a single commit. This is often desirable to create a cleaner project history, especially before merging feature branches into a main branch like main or master. A cleaner history improves readability and simplifies future debugging. This tutorial will explore various methods to achieve this.

Understanding the Need for Squashing

Throughout the development process, it’s common to make numerous small commits as you incrementally build features or fix bugs. While these granular commits are excellent for personal tracking and collaboration within a feature branch, they can clutter the main project history when merged. Squashing allows you to present a concise, logical change set, making it easier to understand the overall evolution of the project.

Method 1: Interactive Rebase

The most common and flexible method for squashing commits is using git rebase -i. This opens an interactive rebase session, allowing you to choose which commits to combine.

Initiate Interactive Rebase: Navigate to your feature branch and run the following command. Replace <base_branch> with the branch you originally branched from (typically main or master).
```
git rebase -i <base_branch>
```
This command will open a text editor displaying a list of commits on your branch.
Edit the Commit List: In the editor, you’ll see a list of commits, each preceded by a command (usually pick). To squash commits, change the command for all commits except the first one to squash (or s). This tells Git to combine those commits into the previous commit.

For example, if you have the following list:
```
pick a1b2c3d Commit message 1
pick e4f5g6h Commit message 2
pick i7j8k9l Commit message 3
```
Change it to:
```
pick a1b2c3d Commit message 1
squash e4f5g6h Commit message 2
squash i7j8k9l Commit message 3
```
Save and Close: Save the file and close the editor. Git will then execute the rebase operation, combining the specified commits. You’ll be prompted to edit a combined commit message. Carefully craft a clear and concise message that accurately describes the overall change.

Method 2: Resetting with Soft Reset and Commit

This method is useful if you want to completely consolidate all commits on a branch into a single commit.

Checkout Your Branch: Navigate to the branch you want to squash.
```
git checkout your_branch
```
Soft Reset: Reset your branch to the base branch (e.g., main) using a soft reset. A soft reset moves the branch pointer but keeps the changes in your working directory and staging area.
```
git reset --soft main
```
Stage and Commit: Add all the changes to the staging area and then create a single commit with a descriptive message.
```
git add .
git commit -m "Consolidated all commits into one"
```

Method 3: Merging with Squash

This approach leverages the --squash option during a merge. It’s beneficial when you want to apply the changes from one branch to another but avoid creating a merge commit.

Checkout the Target Branch: Switch to the branch you want to apply the changes to (e.g., main).
```
git checkout main
```
Merge with Squash: Merge your feature branch using the --squash option. This will stage all the changes from your feature branch without creating a commit.
```
git merge --squash your_branch
```
Commit the Changes: Finally, create a single commit with a descriptive message summarizing the changes.
```
git commit -m "Squashed changes from your_branch"
```

Important Considerations

Force Push: After squashing commits, you’ll likely need to force push your changes to the remote repository. This is because you’ve rewritten the commit history. Use caution when force pushing, as it can disrupt collaboration if others have based their work on the old history. Consider using the --force-with-lease option, which is a safer alternative to --force.
```
git push --force-with-lease origin your_branch
```
Collaboration: If you’re working on a shared branch, discuss squashing commits with your team to avoid disrupting their workflow.
Rewriting History: Remember that squashing commits alters the project’s history. While often desirable for clean presentation, it’s crucial to understand the implications and communicate changes appropriately.

By mastering these techniques, you can effectively manage commit history in Git, ensuring a cleaner, more readable, and maintainable codebase.