Eu tenho dois galhos emailestaging . stagingé a mais recente e não preciso mais das alterações antigas no emailramo, mas não quero excluí-las.

Então, eu só quero despejar todo o conteúdo stagingem emailmodo que ambos apontam para o mesmo cometeu. Isso é possível?

Você pode usar a estratégia de mesclagem 'nossa':

$ git checkout staging
$ git merge -s ours email # Merge branches, but use our branch head

Se você deseja que os dois ramos 'email' e 'teste' sejam iguais, é possível marcar o ramo 'email' e redefinir o ramo 'email' para o 'teste':

$ git checkout email
$ git tag old-email-branch
$ git reset --hard staging

Você também pode refazer a ramificação 'teste' na ramificação 'email'. Mas o resultado conterá a modificação dos dois ramos.

Eu já vi várias respostas e esse é o único procedimento que me permite corrigir isso sem nenhum conflito.

Se você deseja todas as alterações de branch_new em branch_old, então:

git checkout branch_new
git merge -s ours branch_old
git checkout branch_old
git merge branch_new

Uma vez aplicados esses quatro comandos, você pode enviar o branch_old sem nenhum problema

As outras respostas me deram as pistas certas, mas não ajudaram completamente.

Aqui está o que funcionou para mim:

$ 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

Sem a quarta etapa da fusão com a nossa estratégia, o push é considerado uma atualização sem avanço rápido e será rejeitado (pelo GitHub).

Se você é como eu e não deseja lidar com a mesclagem, pode executar as etapas acima, exceto usar força em vez de mesclar, porque isso criará uma trilha de papel de registro que distrai:

git checkout email
git reset --hard staging
git push origin email --force

Nota: Isso é apenas se você REALMENTE nunca quiser ver o material novamente por e-mail.

Eu queria mesclar duas ramificações para que todo o conteúdo old_branchfosse atualizado com o conteúdo denew_branch

Para mim, isso funcionou como um encanto:

$ 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

E se:

git branch -D email
git checkout staging
git checkout -b email
git push origin email --force-with-lease

Outras respostas pareciam incompletas.
Eu tentei abaixo na íntegra, e funcionou bem.

NOTA:
1. Faça uma cópia do seu repositório antes de tentar abaixo, por segurança.

Detalhes:
1. Todo o desenvolvimento acontece no ramo de desenvolvimento
2. qa ramo é apenas a mesma cópia do desenvolvimento
3. De tempos em tempos, o código de desenvolvimento precisa ser movido / sobrescrito no ramo qa

então precisamos sobrescrever qa branch, do dev branch

Parte 1:
Com os comandos abaixo, o antigo qa foi atualizado para o desenvolvedor mais recente:

git checkout dev
git merge -s ours qa
git checkout qa
git merge dev
git push

O comentário automático para o último push é apresentado abaixo:

// Output:
//  *<MYNAME> Merge branch 'qa' into dev,*  

Este comentário parece reverso, porque a sequência acima também parece reversa

Parte 2:

Abaixo estão inesperados, novos commits locais no dev, os desnecessários,
então precisamos jogar fora e tornar o dev intocado.

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

Parte 3:
Verifique se tudo está como o esperado:

git status  

// Output:
//  *On branch dev  
//  Your branch is up-to-date with 'origin/dev'.  
//  nothing to commit, working tree clean*  

Isso é tudo.
1. qa antigo agora é sobrescrito pelo novo código de ramificação do desenvolvedor
2. o local está limpo (origem remota / dev é intocado)

A maneira mais fácil de fazer isso:

//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

Agora, o ramo de email e a preparação são os mesmos.

git checkout email
git merge -m "Making email same as staging disregarding any conflicts from email in the process" -s recursive -X theirs staging

Este não altera a ramificação mais recente original e oferece a oportunidade de fazer outras modificações antes da confirmação final.

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)