I have two branches, email
and staging
. staging
is the latest one and I no longer need the old changes in email
branch, yet I don't want to delete them.
So I just want to dump all the contents of staging
into email
so that they both point to the same commit. Is that possible?
This question is related to
git
I tried @knittl's write-tree/commit-tree
approach.
branch-a: the kept branch
branch-b: the abandoned branch
// goto branch-a branch
$ git checkout branch-a
$ git write-tree
6fa6989240d2fc6490f8215682a20c63dac5560a // echo tree id? I guess
$ git commit-tree -p branch-a -p branch-b 6fa6989240d2fc6490f8215682a20c63dac5560a
<type some commit message end with Ctrl-d>
20bc36a2b0f2537ed11328d1aedd9c3cff2e87e9 // echo new commit id
$ git reset --hard 20bc36a2b0f2537ed11328d1aedd9c3cff2e87e9
What you want is this (actually the exact inverse of the currently accepted answer):
git checkout email
git merge --strategy-option=theirs staging
What this does is:
email
branch files will now be exactly the same as staging
branchemail
branch's history will be maintainedstaging
branch's history will be added to email
historyAs added value, if you don't want all of staging
branch's history, you can use squash
to summarize it into a single commit message.
git checkout email
git merge --squash --strategy-option=theirs staging
git commit -m "Single commit message for squash branch's history here'
So in summary, what this second version does is:
email
branch files will now be exactly the same as staging
branchemail
branch's history will be maintainedemail
branch's history. This commit will represent ALL the changes that took place in the staging
branchThis one doesn't alter the original newer branch, and gives you the opportunity to make further modifications before final commit.
git checkout new -b tmp
git merge -s ours old -m 'irrelevant'
git checkout old
git merge --squash tmp
git branch -D tmp
#do any other stuff you want
git add -A; git commit -m 'foo' #commit (or however you like)
I wanted to merge two branches so that all the contents in old_branch
to be updated with the contents from new_branch
For me this worked like a charm:
$ git checkout new_branch
$ git merge -m 'merge message' -s ours origin/old_branch
$ git checkout old_branch
$ git merge new_branch
$ git push origin old_branch
If you just want the two branches 'email' and 'staging' to be the same, you can tag the 'email' branch, then reset the 'email' branch to the 'staging' one:
$ git checkout email
$ git tag old-email-branch
$ git reset --hard staging
You can also rebase the 'staging' branch on the 'email' branch. But the result will contains the modification of the two branches.
If you're like me and you don't want to deal with merging, you can do the above steps, except use force instead of merge, because it will create a distracting log paper trail:
git checkout email
git reset --hard staging
git push origin email --force
Note: This is only if you REALLY never want to see the stuff in email again.
Other answers looked incomplete.
I have tried below in full, and it worked fine.
NOTE:
1. Make a copy of your repository before you try below, to be on safe side.
Details:
1. All development happens in dev branch
2. qa branch is just the same copy of dev
3. Time to time, dev code needs to be moved/overwrite to qa branch
so we need to overwrite qa branch, from dev branch
Part 1:
With below commands, old qa has been updated to newer dev:
git checkout dev
git merge -s ours qa
git checkout qa
git merge dev
git push
Automatic comment for last push gives below:
// Output:
// *<MYNAME> Merge branch 'qa' into dev,*
This comment looks reverse, because above sequence also looks reverse
Part 2:
Below are unexpected, new local commits in dev, the unnecessary ones
so, we need to throw away, and make dev untouched.
git checkout dev
// Output:
// Switched to branch 'dev'
// Your branch is ahead of 'origin/dev' by 15 commits.
// (use "git push" to publish your local commits)
git reset --hard origin/dev
// Now we threw away the unexpected commits
Part 3:
Verify everything is as expected:
git status
// Output:
// *On branch dev
// Your branch is up-to-date with 'origin/dev'.
// nothing to commit, working tree clean*
That's all.
1. old qa is now overwritten by new dev branch code
2. local is clean (remote origin/dev is untouched)
How about:
git branch -D email
git checkout staging
git checkout -b email
git push origin email --force-with-lease
I've seen several answers and that's the only procedure that let me fix that without any conflicts.
If you want all changes from branch_new in branch_old, then:
git checkout branch_new
git merge -s ours branch_old
git checkout branch_old
git merge branch_new
once applied those four commands you can push the branch_old without any problem
The other answers gave me the right clues, but they didn't completely help.
$ git checkout email
$ git tag old-email-branch # This is optional
$ git reset --hard staging
$
$ # Using a custom commit message for the merge below
$ git merge -m 'Merge -s our where _ours_ is the branch staging' -s ours origin/email
$ git push origin email
Without the fourth step of merging with the ours strategy, the push is considered a non-fast-forward update and will be rejected (by GitHub).
git checkout email
git merge -m "Making email same as staging disregarding any conflicts from email in the process" -s recursive -X theirs staging
WARNING: This deletes all commits on the email branch. It's like deleting the email branch and creating it anew at the head of the staging branch.
The easiest way to do it:
//the branch you want to overwrite
git checkout email
//reset to the new branch
git reset --hard origin/staging
// push to remote
git push -f
Now the email branch and the staging are the same.
Source: Stackoverflow.com