Tornar o ramo Git atual um ramo mestre

Eu tenho um repositório no Git. Fiz uma ramificação, depois fiz algumas alterações no mestre e na ramificação.

Então, dezenas de confirmações depois, percebi que o ramo está em um estado muito melhor que o mestre, então quero que o ramo "se torne" o mestre e desconsidere as alterações no mestre.

Não posso mesclar, porque não quero manter as alterações no mestre. O que devo fazer?

Extra : Nesse caso, o mestre 'antigo' já foi pushenviado para outro repositório como o GitHub. Como isso muda as coisas?

O problema com as outras duas respostas é que o novo mestre não tem o antigo mestre como ancestral; portanto, quando você pressiona, todo mundo fica bagunçado. Isto é o que você quer fazer:

git checkout better_branch
git merge --strategy=ours master    # keep the content of this branch, but record a merge
git checkout master
git merge better_branch             # fast-forward master up to the merge

Se você quiser que seu histórico seja um pouco mais claro, recomendo adicionar algumas informações à mensagem de confirmação de mesclagem para deixar claro o que você fez. Mude a segunda linha para:

git merge --strategy=ours --no-commit master
git commit          # add information to the template merge message

Verifique se tudo foi enviado ao seu repositório remoto (GitHub):

git checkout master

Substitua "master" por "better_branch":

git reset --hard better_branch

Force o envio ao seu repositório remoto:

git push -f origin master

Edit: Você não disse que tinha empurrado para um repo público! Isso faz um mundo de diferença.

Existem duas maneiras, a maneira "suja" e a maneira "limpa". Suponha que seu ramo seja nomeado new-master. Esta é a maneira limpa:

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

Isso fará com que os arquivos de configuração sejam alterados para corresponder aos ramos renomeados.

Você também pode fazê-lo da maneira suja, o que não atualizará os arquivos de configuração. É o que se passa sob o capô do que foi dito acima ...

mv -i .git/refs/new-master .git/refs/master
git checkout master

Renomeie a ramificação para master:

git branch -M branch_name master

Pelo que entendi, você pode ramificar a ramificação atual em uma ramificação existente. Em essência, isso substituirá o masterque você tiver no ramo atual:

git branch -f master HEAD

Depois de fazer isso, normalmente você pode enviar sua masterfilial local , possivelmente exigindo o parâmetro force aqui também:

git push -f origin master

Sem mesclagens, sem comandos longos. Simplesmente branche push- mas, sim, isso vai reescrever a história do masterramo, por isso, se você trabalha em uma equipe que você tem que saber o que está fazendo.

Como alternativa, descobri que você pode enviar qualquer ramo para qualquer ramo remoto, portanto:

# 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

Encontrei a resposta que queria na postagem do blog Substitua o ramo principal por outro ramo no 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

É essencialmente o mesmo que a resposta de Cascabel . Exceto que a "opção" que ele adicionou abaixo de sua solução já está incorporada no meu bloco de código principal.

É mais fácil encontrar esse caminho.

Estou adicionando isso como uma nova resposta, porque se precisar dessa solução mais tarde, quero ter todo o código que vou usar em um bloco de código.

Caso contrário, posso copiar e colar e ler os detalhes abaixo para ver a linha que eu deveria ter alterado - depois de executá-la.

As soluções fornecidas aqui (renomeando a ramificação em 'master') não insistem nas consequências para o repositório remoto (GitHub):

• se você não pressionou nada desde a criação desse ramo, pode renomeá-lo e enviá-lo sem nenhum problema.
• se você tinha o push master no GitHub, precisará 'git push -f' a nova ramificação: não é mais possível fazer o push no modo de avanço rápido .

    -f
    --força

Normalmente, o comando se recusa a atualizar uma ref remota que não é um ancestral da ref local usada para substituí-la. Este sinalizador desativa a verificação. Isso pode fazer com que o repositório remoto perca confirmações; use-o com cuidado.

Se outras pessoas já realizaram seu repo, elas não poderão obter esse novo histórico mestre sem substituir o próprio mestre por esse novo ramo mestre do GitHub (ou lidar com muitas mesclagens).
Existem alternativas para uma força de empurrar git para repositórios públicos .
A resposta de Jefromi (mesclando as alterações certas de volta ao mestre original) é uma delas.

Encontrei esse método simples para funcionar da melhor maneira. Ele não reescreve o histórico e todos os check-ins anteriores da ramificação serão anexados ao mestre. Nada está perdido, e você pode ver claramente o que ocorreu no log de confirmação.

Objetivo: Tornar o estado atual da "ramificação" o "mestre"

Trabalhando em uma ramificação, confirme e envie suas alterações para garantir que seus repositórios locais e remotos estejam atualizados:

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

Depois disso, seu mestre será o estado exato do seu último commit da filial e seu log de confirmação principal mostrará todos os check-ins da filial.

Também é possível fazer o checkout de todos os arquivos da outra ramificação no master:

git checkout master
git checkout better_branch -- .

e depois confirme todas as alterações.

Para adicionar à resposta de Jefromi, se você não deseja colocar uma mesclagem sem sentido no histórico da sourceramificação, é possível criar uma ramificação temporária para a oursmesclagem e jogá-la fora:

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

Dessa forma, a consolidação de mesclagem só existirá no histórico da targetramificação.

Como alternativa, se você não deseja criar uma mesclagem, basta pegar o conteúdo sourcee usá-lo para um novo commit em 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>

Para mim, eu queria que meu demônio estivesse de volta ao mestre depois que estivesse à frente.

Enquanto estiver desenvolvendo:

git checkout master
git pull

git checkout develop
git pull

git reset --hard origin/master
git push -f

Minha maneira de fazer as coisas é a seguinte

#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

Se você estiver usando o eGit no Eclipse :

• Clique com o botão direito do mouse no nó do projeto.
• Escolha Equipe → Avançado → Renomear Filial
• Em seguida, expanda a pasta de rastreamento remoto .
• Escolha a ramificação com o nome errado, clique no botão renomear e renomeie para qualquer que seja o novo nome.
• Escolha o novo mestre e renomeie-o para mestre.

As etapas a seguir são executadas no navegador Git, desenvolvido pela Atlassian (servidor Bitbucket)

Fazendo {ramo atual} como master

1. Faça uma ramificação mastere nomeie-a como duplicada principal.
2. Faça uma ramificação de {current-branch} e nomeie-o como “{current-branch} -copy”.
3. Na configuração do repositório (Bitbucket), altere "Ramificação padrão" para apontar para "duplicação mestre" (sem esta etapa, você não poderá excluir o mestre - "Na próxima etapa").
4. Excluir ramificação “master” - fiz esta etapa na árvore de origem (você pode fazê-lo no navegador CLI ou Git)
5. Renomeie “{current-branch}” para “master” e pressione push para o repositório (isso criará um novo branch “master” ainda que “{current-branch}” exista).
6. Nas configurações do repositório, altere "Ramificação padrão" para apontar para "mestre".