如何将3次提交与主服务器的一次合并重新定为一次提交？

Question

I always seem to stumble and completely mess up git commits when I run into this scenario. I'm hoping to avoid it this time around. Here is my scenario. I have the following 4 commits in my PR:

Commit 1: Remove unused routes for the projects controller
Commit 2: Add PR request changes and modify similar_by_tags_route
Commit 3: Merge Master and resolve git merge conflicts
Commit 4: Reinsert rubocop disablement for project.rb

I need these commits rebased into one commit. Now I can't just do a rebase -i HEAD~4 because of the pesky merge from master. Is there a way where I can simply remove commit 3 and just merge commits 1, 2, and 4? I would really like some help on this because I always seem to make a HUGE mess when it comes to tricky merges like this.

Answer 1

You can try doing an interactive rebase of your branch and just remove the line containing the merge commit. Running git rebase -i HEAD~4 should bring up a list of commits looking something like the following:

pick Commit 1: Remove unused routes for the projects controller
pick Commit 2: Add PR request changes and modify similar_by_tags_route
pick Commit 3: Merge Master and resolve git merge conflicts
pick Commit 4: Reinsert rubocop disablement for project.rb

Delete the line containing the merge commit, leaving you with this:

pick Commit 1: Remove unused routes for the projects controller
pick Commit 2: Add PR request changes and modify similar_by_tags_route
pick Commit 4: Reinsert rubocop disablement for project.rb

Now change the 2nd and 4th commit to squash , to tell Git to combine these commits into the single first commit:

pick Commit 1: Remove unused routes for the projects controller
squash Commit 2: Add PR request changes and modify similar_by_tags_route
squash Commit 4: Reinsert rubocop disablement for project.rb

Complete the rebase and you should be left with what you want. Note that rebasing like this means rewriting the history of your branch. As such, you should take precaution if this branch is publicly shared by other people.

Answer 2

If you haven't pushed to remote yet simply rebase: git rebase -i HEAD~4 then pick first commit, drop the third one and squash the others.

Here is some example I did in my console:

Note the commands that are available also, maybe you can choose something more appropriate now than you see all of them.

However, if you pushed to remote I'd suggest you just revert third commit and leave the others because rebase rewrites history and can be devastating for people that already pulled your commits so I'd rather not play with history of git.

Answer 3

Assume your 4 commits are on Branch B1 and that's the name of the branch that was used to create the PR.

1. Create a local branch B2 (identical to B1)
2. Delete local branch B1
3. Create local branch B1 from origin/master
4. Cherry-pick commits 1, 2, 4 (in order) onto branch B1 by looking at their hashes in B2.
5. Squash them (interactive rebase)
6. Force push B1 to origin
7. Delete local branch B2

Answer 4

Squash several Git commits into a single commit

This note shows how to merge an ugly feature branch with multiple dirty WIP commits back into the master as one pretty commit.

Easy mode: Reset your feature branch to the master state

The easiest way to turn multiple commits in a feature branch into a single commit is to reset the feature branch changes in the master and commit everything again.

# Switch to the master branch and make sure you are up to date.

git checkout master

git fetch # this may be necessary (depending on your git config) to receive updates on origin/master

git pull

# Merge the feature branch into the master branch.

git merge feature_branch
# Reset the master branch to origin's state.

git reset origin/master

Git now considers all changes as unstaged changes.

# We can add these changes as one commit.

# Adding . will also add untracked files.

git add --all

git commit

Note that this is not touching the feature branch at all. If you would merge the feature branch into the master again at a later stage all of its commits would reappear in the log.

You may also do it the other way round (merging master into the branch and resetting to the master state) but this will destroy your commits in the feature branch, meaning you can not push it to origin.

Hard mode: Squash commits

This method is harder than using the get reset method above. Also it doesn't work well if you merged the master into the feature branch previously (you'll need to resolve all conflicts again).

What we are describing here will destroy commit history and can go wrong. For this reason, do the squashing on a separate branch:

git checkout -b squashed_feature

This way, if you screw up, you can go back to your original branch, make another branch for squashing and try again.

To squash all commits since you branched away from master, do

git rebase -i master

Note that rebasing to the master does not work if you merged the master into your feature branch while you were working on the new feature. If you did this you will need to find the original branch point and call git rebase with a SHA1 revision.

Your editor will open with a file like

pick fda59df commit 1

pick x536897 commit 2

pick c01a668 commit 3

Each line represents a commit (in chronological order, the latest commit will be at the bottom).

To transform all these commits into a single one, change the file to this:

pick fda59df commit 1

squash x536897 commit 2

squash c01a668 commit 3

This means, you take the first commit, and squash the following onto it. If you remove a line, the corresponding commit is actually really lost. Don't bother changing the commit messages because they are ignored. After saving the squash settings, your editor will open once more to ask for a commit message for the squashed commit.

You can now merge your feature as a single commit into the master:

git checkout master

git merge squashed_feature