Refaire une fusion inversée dans Git

J'ai rencontré un petit problème ici: j'avais une branche spécifique au problème 28sdans Git, que j'ai fusionnée dans la developbranche générale . Il s'avère que je l'avais fait trop vite, j'ai donc utilisé git-revert pour annuler la fusion. Maintenant, cependant, le temps est venu de fusionner 28sen develop, mais la commande git-fusion voit la fusion d' origine, et annonce joyeusement que tout va bien et les branches ont déjà été fusionnées. Qu'est-ce que je fais maintenant? Créer un 'Revert "Revert" 28s -> develop ""' commit? Cela ne semble pas être un bon moyen de le faire, mais je ne peux en imaginer aucun autre pour le moment.

À quoi ressemble la structure arborescente:

Vous devez "revenir en arrière". Selon vous, comment l'original est-il revenu, cela peut ne pas être aussi simple qu'il y paraît. Regardez le document officiel sur ce sujet .

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

autoriser:

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

Mais tout fonctionne-t-il? Bien sûr. Vous pouvez annuler une fusion, et d'un point de vue purement technique, git l'a fait très naturellement et n'a eu aucun vrai problème.
Il a simplement considéré que c'était un changement de "l'état avant la fusion" à "l'état après la fusion", et c'était tout.
Rien de compliqué, rien d'étrange, rien de vraiment dangereux. Git le fera sans même y penser.

Donc, d'un point de vue technique, il n'y a rien de mal à annuler une fusion, mais sous l'angle du flux de travail, c'est quelque chose que vous devriez généralement essayer d'éviter .

Si possible, par exemple, si vous trouvez un problème qui a été fusionné dans l'arborescence principale, plutôt que d'annuler la fusion, essayez vraiment de :

• bissectez le problème dans la branche que vous avez fusionnée et corrigez-le,
• ou essayez d'annuler le commit individuel qui l'a provoqué.

Oui, c'est plus complexe, et non, ça ne marchera pas toujours (parfois la réponse est: "oups, je n'aurais vraiment pas dû le fusionner, car il n'était pas encore prêt, et j'ai vraiment besoin de défaire tous les fusionner"). Donc, vous devez vraiment annuler la fusion, mais lorsque vous souhaitez refaire la fusion, vous devez maintenant le faire en annulant la restauration.

Supposons que vous ayez une telle histoire

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

Où A, B ont échoué et W - revient à M

Donc, avant de commencer à corriger les problèmes détectés, je sélectionne W pour m'engager dans ma branche

git cherry-pick -x W

Puis je reviens W commit sur ma branche

git revert W 

Après je peux continuer à réparer.

L'histoire finale pourrait ressembler à:

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

Lorsque j'envoie un PR, cela montre clairement que le PR est annulé et ajoute de nouveaux commits.

Pour annuler le retour sans trop gâcher votre flux de travail:

• Créer une copie de corbeille locale de develop
• Annuler la validation de la restauration sur la copie locale de develop
• Fusionnez cette copie dans votre branche de fonctionnalités et envoyez votre branche de fonctionnalités à votre serveur git.

Votre branche de fonctionnalité devrait maintenant pouvoir être fusionnée normalement lorsque vous y êtes prêt. Le seul inconvénient ici est que vous aurez quelques commits de fusion / restauration supplémentaires dans votre historique.

Pour annuler une restauration dans GIT:

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

Au lieu d'utiliser, git-revertvous auriez pu utiliser cette commande dans la develbranche pour supprimer (annuler) le mauvais commit de fusion (au lieu de simplement le rétablir).

git checkout devel
git reset --hard COMMIT_BEFORE_WRONG_MERGE

Cela ajustera également le contenu du répertoire de travail en conséquence. Attention :

• Enregistrez vos modifications dans la branche develop (car la mauvaise fusion) car elles aussi seront effacées par le git-reset. Tous les commits après celui que vous spécifiez car l' git resetargument aura disparu!
• De plus, ne le faites pas si vos modifications ont déjà été extraites d'autres référentiels car la réinitialisation réécrira l'historique.

Je recommande d'étudier git-resetattentivement la page de manuel avant d'essayer.

Maintenant, après la réinitialisation, vous pouvez réappliquer vos modifications devel, puis faire

git checkout devel
git merge 28s

Ce sera une véritable fusion d' 28sen develcomme la première (qui est maintenant effacée de l'histoire de git).

Je viens de trouver ce message face au même problème. Je trouve ci-dessus un moyen effrayant de réinitialiser les disques durs, etc. Je finirai par supprimer quelque chose que je ne veux pas et je ne pourrai pas le récupérer.

Au lieu de cela, j'ai vérifié le commit auquel je voulais que la branche revienne, par exemple git checkout 123466t7632723. Puis converti en branche git checkout my-new-branch. J'ai ensuite supprimé la branche dont je ne voulais plus. Bien sûr, cela ne fonctionnera que si vous êtes capable de jeter la branche que vous avez gâchée.

Je vous suggère de suivre les étapes ci-dessous pour annuler un retour, par exemple 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

Créez maintenant PR pour la branche users/yourname/revertOfSHA1

1. créer une nouvelle branche lors de la validation avant la fusion d'origine - appelez-la 'develop-base'
2. effectuer un rebase interactif de «develop» au-dessus de «develop-base» (même s'il est déjà au dessus). Pendant le rebase interactif, vous aurez la possibilité de supprimer à la fois le commit de fusion et le commit qui a inversé la fusion, c'est-à-dire supprimer les deux événements de l'historique git

À ce stade, vous aurez une branche de développement propre à laquelle vous pourrez fusionner votre fonctionnalité comme vous le faites régulièrement.