Re-fazendo uma mesclagem revertido em Git

Question

Eu tenho que correr em um pouco de um problema aqui: eu tinha um 28s ramo específico de problemas no Git, que se fundiram no ramo geral develop. Acontece que eu tinha feito isso muito rápido, então eu usei git-revert para desfazer a mesclagem. Agora, no entanto, chegou o momento para 28s fundem em develop, mas o comando git-merge vê a fusão original, e felizmente anuncia que tudo está bem e galhos já foram mescladas. O que eu faço agora? Criar um 'Reverter 'Reverter '28s -> desenvolver''' cometer? não parece ser uma boa maneira de fazer isso, mas eu não posso imaginar qualquer outra no momento.

O que os olhares estrutura de árvore como:

Answer 1

Você tem que "reverter o revert". Depende de como você reverter isso, pode não ser tão fácil quanto parece. Olhe para o documento oficial sobre esta tópico .

---o---o---o---M---x---x---W---x---Y
              /
      ---A---B-------------------C---D

para permitir que:

---o---o---o---M---x---x-------x-------*
              /                       /
      ---A---B-------------------C---D

Mas isso tudo funciona? Claro que faz. Você pode reverter um merge, e de um ângulo puramente técnico, git fez isso com muita naturalidade e não tinha verdadeiro problemas.
Ele apenas considerou uma mudança de "estado antes da fusão" para "Estado após merge", e foi isso.
Nada complicado, nada de estranho, nada realmente perigoso. Git irá fazê-lo sem pensar mesmo sobre ele.

Assim, a partir de vista técnico, não há nada de errado com revertendo uma mesclagem, mas a partir de um ângulo de fluxo de trabalho é algo que você geralmente deve tentar evitar .

Se possível, por exemplo, se você encontrar um problema que foi fundida na árvore principal, em vez de reverter a fusão, tente realmente difícil :

• bisect o problema no ramo que se fundiram, e apenas corrigi-lo,
• ou tentar reverter o indivíduo cometer que o causou.

Sim, é mais complexo, e não, não é sempre indo para o trabalho (por vezes a resposta é: "oops, eu realmente não deveria ter fundiu-lo, porque não era ainda pronto, e eu realmente preciso desfazer todas do merge "). Então você realmente deve reverter a fusão, mas quando você quer re-fazer o merge, você agora precisa fazê-lo, revertendo a reversão.

Answer 2

Vamos supor que você tem essa história

---o---o---o---M---W---x-------x-------*
              /                      
      ---A---B

Onde A, B falhou commits e W - é revert de M

Então, antes de começar a corrigir problemas encontrados eu cherry-pick de W cometem ao meu ramo

git cherry-pick -x W

Então eu revert W cometer no meu ramo

git revert W 

Depois que eu possa continuar fixação.

A história final poderia ficar assim:

---o---o---o---M---W---x-------x-------*
              /                       /     
      ---A---B---W---W`----------C---D

Quando eu enviar um PR que vai mostra claramente que PR é desfazer revert e adiciona alguns novos commits.

Answer 3

Para reverter a reversão sem estragar seu fluxo de trabalho muito:

• Criar uma cópia de lixo local do desenvolvimento
• Reverter a reversão cometer na cópia local do desenvolvimento
• Mesclar que copiar para o seu ramo de funcionalidade, e empurrar o seu ramo de recurso para o servidor git.

O seu ramo de funcionalidade deve agora ser capaz de ser fundidos como normal quando você está pronto para isso. A única desvantagem é que você vai a ter alguns commits merge / Reverter extras em sua história.

Answer 4

Para reverter um revert em GIT:

git revert <commit-hash-of-previous-revert>

Answer 5

Em vez de usar git-revert você poderia ter usado este comando no ramo devel para jogar fora (undo) a fusão errado cometer (em vez de apenas revertendo-lo).

git checkout devel
git reset --hard COMMIT_BEFORE_WRONG_MERGE

Isso também irá ajustar o conteúdo do diretório de trabalho em conformidade. Tenha cuidado :

• Salve as alterações no ramo desenvolver (desde a fusão errado), porque eles também serão apagados pela git-reset. Todos os commits após o que você especificar como o argumento git reset será ido!
• Além disso, não fazer isso se as alterações foram já puxado de outros repositórios porque o reset vai reescrever a história.

Eu recomendo para estudar o homem páginas git-reset cuidadosamente antes de tentar isso.

Agora, após o reset pode voltar a aplicar as alterações em devel e depois fazer

git checkout devel
git merge 28s

Esta será uma mesclagem real a partir de 28s em devel como o inicial (que é agora apagado da história do git).

Answer 6

Eu só encontrei este post quando enfrenta o mesmo problema. Acho acima wayyy a assustador a que redefinir hards etc. eu vou acabar apagando algo que eu não quero, e não será capaz de recuperá-lo.

Em vez eu verifiquei a cometer eu queria o ramo de voltar a por exemplo git checkout 123466t7632723. Então convertido em um git checkout my-new-branch ramo. Eu, então, eliminado o ramo eu não quero mais. Claro que isto só irá funcionar se você é capaz de jogar fora o ramo você estragou tudo.

Answer 7

Eu sugiro que você siga os passos abaixo para reverter um revert, dizem SHA1.

git checkout develop #go to develop branch
git pull             #get the latest from remote/develop branch
git branch users/yourname/revertOfSHA1 #having HEAD referring to develop
git checkout users/yourname/revertOfSHA1 #checkout the newly created branch
git log --oneline --graph --decorate #find the SHA of the revert in the history, say SHA1
git revert SHA1
git push --set-upstream origin users/yourname/revertOfSHA1 #push the changes to remote

Agora crie PR para o users/yourname/revertOfSHA1 ramo

Answer 8

1. criar uma nova filial em cometer antes da fusão original - chamá-lo de que 'desenvolver-base'
2. realizar rebase interativo de 'desenvolver' em cima de 'desenvolver-base' (mesmo que ele já está no topo). Durante rebase interativo, você terá a oportunidade de remover o merge cometer, ea cometer esse inverteu a fusão, ou seja, remover ambos os eventos da história git

Neste ponto, você terá uma limpa 'desenvolver' ramo para o qual você pode mesclar seu brach recurso como você faz regularmente.