Mastering Git Commits: How to Squash and Simplify Your History

Photo by @andrewtneel

When working with Git and having a branch with a large number of commits that you want to merge into a target branch, you may want to consider squashing the commits before creating a pull request. This can help keep your commit history clean and organized, making understanding and reviewing all the changes easier. One of the simple methods I describe below.

Here is the template I’m using:

git checkout {target}
git pull
git checkout {custom_branch}
git checkout -b {custom_branch}_backup
git checkout {custom_branch}
git reset --hard {target}
git merge --squash {custom_branch}_backup

Placeholders for replacement are:
{target} — target branch for the PR
{custom_branch }— the branch with a huge count of commits

Let's go step by step:

1. git checkout {target}: This command switches your working directory to the branch named {target}. This is typically done to ensure that you're starting from the most up-to-date version of the code.
2. git pull: This command fetches the latest changes from the remote repository and merges them into your local branch.
3. git checkout {custom_branch}: This command switches your working directory to the branch named {custom_branch}. This is the branch that you want to merge changes into. Nothing special for now.
4. git checkout -b {custom_branch}_backup: This command creates a new branch named {custom_branch}_backup and switches your working directory to that branch. This is done to create a backup of your {custom_branch} branch in case something goes wrong during the merge process.
5. git checkout {custom_branch}: This command switches your working directory back to the {custom_branch} branch.
6. git reset --hard {target}: Here become interesting. This command resets your working directory to the state of the {target} branch. This effectively discards all of the changes you made in {custom_branch}.
7. git merge --squash {custom_branch}_backup: This command merges the changes in {custom_branch}_backup into your working directory, but does not create a new commit. Instead, it prepares the changes to be committed in a single commit using the git commit command. The --squash flag ensures that the changes from {custom_branch}_backup are merged as a single commit rather than individual commits.

After all commands, you should get all changes that you have done in the branch which are not committed, so you are left to commit them and push. Essentially, all changes will go as one commits in your push.

Example of usage

Suppose you have many commits in branch feature/story_1 and must prepare a pull request with one commit to the release/dev branch. For that, use a temporary branch to the backup and make changes.

git checkout release/dev
git pull
git checkout feature/story_1
git checkout -b feature/story_1_backup
git checkout feature/story_1
git reset --hard release/dev
git merge --squash feature/story_1_backup

All changes would be in your files but NOT committed.