I have a repository in Git. I made a branch, then did some changes both to the master and to the branch.
Then, tens of commits later, I realized the branch is in much better state than the master, so I want the branch to "become" the master and disregard the changes on master.
I cannot merge it, because I don't want to keep the changes on master. What should I do?
Extra: In this case, the 'old' master has already been push
-ed to another repository such as GitHub. How does this change things?
This question is related to
git
If you are using eGit in Eclipse:
To add to Jefromi's answer, if you don't want to place a meaningless merge in the history of the source
branch, you can create a temporary branch for the ours
merge, then throw it away:
git checkout <source>
git checkout -b temp # temporary branch for merge
git merge -s ours <target> # create merge commit with contents of <source>
git checkout <target> # fast forward <target> to merge commit
git merge temp # ...
git branch -d temp # throw temporary branch away
That way the merge commit will only exist in the history of the target
branch.
Alternatively, if you don't want to create a merge at all, you can simply grab the contents of source
and use them for a new commit on target
:
git checkout <source> # fill index with contents of <source>
git symbolic-ref HEAD <target> # tell git we're committing on <target>
git commit -m "Setting contents to <source>" # make an ordinary commit with the contents of <source>
Edit: You didn't say you had pushed to a public repo! That makes a world of difference.
There are two ways, the "dirty" way and the "clean" way. Suppose your branch is named new-master
. This is the clean way:
git checkout new-master
git branch -m master old-master
git branch -m new-master master
# And don't do this part. Just don't. But if you want to...
# git branch -d --force old-master
This will make the config files change to match the renamed branches.
You can also do it the dirty way, which won't update the config files. This is kind of what goes on under the hood of the above...
mv -i .git/refs/new-master .git/refs/master
git checkout master
The solutions given here (renaming the branch in 'master') don't insist on the consequences for the remote (GitHub) repo:
-f --force
Usually, the command refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it. This flag disables the check. This can cause the remote repository to lose commits; use it with care.
If others have already pulled your repo, they won't be able to pull that new master history without replacing their own master with that new GitHub master branch (or dealing with lots of merges).
There are alternatives to a git push --force for public repos.
Jefromi's answer (merging the right changes back to the original master) is one of them.
For me, i wanted my devl to be back to the master after it was ahead.
While on develop:
git checkout master
git pull
git checkout develop
git pull
git reset --hard origin/master
git push -f
The following steps are performed in the Git browser powered by Atlassian (Bitbucket server)
Making {current-branch} as master
master
and name it “master-duplicate”.I found this simple method to work the best. It does not rewrite history and all previous check-ins of branch will be appended to the master. Nothing is lost, and you can clearly see what transpired in the commit log.
Objective: Make current state of "branch" the "master"
Working on a branch, commit and push your changes to make sure your local and remote repositories are up to date:
git checkout master # Set local repository to master
git reset --hard branch # Force working tree and index to branch
git push origin master # Update remote repository
After this, your master will be the exact state of your last commit of branch and your master commit log will show all check-ins of the branch.
Rename the branch to master
by:
git branch -M branch_name master
My way of doing things is the following
#Backup branch
git checkout -b master_backup
git push origin master_backup
git checkout master
#Hard Reset master branch to the last common commit
git reset --hard e8c8597
#Merge
git merge develop
From what I understand, you can branch the current branch into an existing branch. In essence, this will overwrite master
with whatever you have in the current branch:
git branch -f master HEAD
Once you've done that, you can normally push your local master
branch, possibly requiring the force parameter here as well:
git push -f origin master
No merges, no long commands. Simply branch
and push
— but, yes, this will rewrite history of the master
branch, so if you work in a team you have got to know what you're doing.
Alternatively, I found that you can push any branch to the any remote branch, so:
# This will force push the current branch to the remote master
git push -f origin HEAD:master
# Switch current branch to master
git checkout master
# Reset the local master branch to what's on the remote
git reset --hard origin/master
I don't have enough karma to comment.
I know this is not what OP wanted, but you can do this if you know you are going to have a problem similar to OP in the future.
Suppose, you know in advance that you want to create a branch which will have new awesome features and you also want that branch to be the master in the future and at the same time don't want to loose the current master branch (which will get lost if you initially make a separate branch and awesome features to it and then merge it to master). If this feels confusing, see the below diagram of the 'bad' situation.
To solve this( i.e. to stop the loss of boring) do the following Basically,
git branch boring
Replace boring with whatever name you want to keepI found the answer I wanted in the blog post Replace the master branch with another branch in git:
git checkout feature_branch
git merge -s ours --no-commit master
git commit # Add a message regarding the replacement that you just did
git checkout master
git merge feature_branch
It's essentially the same as Cascabel's answer. Except that the "option" he added below his solution is already embedded in my main code block.
It's easier to find this way.
I'm adding this as a new answer, because if I need this solution later, I want to have all the code I am going to use in one code block.
Otherwise, I may copy-paste, then read details below to see the line that I should have changed - after I already executed it.
Make sure everything is pushed up to your remote repository (GitHub):
git checkout main
Overwrite "main" with "better_branch":
git reset --hard better_branch
Force the push to your remote repository:
git push -f origin main
One can also checkout all files from the other branch into master:
git checkout master
git checkout better_branch -- .
and then commit all changes.
Source: Stackoverflow.com