J'ai un dépôt git qui ressemble à ceci:

A -> B -> C -> D -> HEAD

Je veux que le chef de la branche pointe vers A, c'est-à-dire que je veux que B, C, D et HEAD disparaissent et je veux que head soit synonyme de A.

Il semble que je puisse soit essayer de rebaser (ne s'applique pas, car j'ai poussé les changements entre les deux), soit revenir en arrière. Mais comment annuler plusieurs validations? Dois-je revenir un à la fois? La commande est-elle importante?

Développer ce que j'ai écrit dans un commentaire

La règle générale est que vous ne devez pas réécrire (modifier) ​​l'historique que vous avez publié, car quelqu'un a peut-être basé son travail dessus. Si vous réécrivez (modifiez) l'historique, vous rencontrez des problèmes avec la fusion de leurs modifications et leur mise à jour.

La solution consiste donc à créer un nouveau commit qui annule les modifications dont vous souhaitez vous débarrasser. Vous pouvez le faire en utilisant la commande git revert .

Vous avez la situation suivante:

A <- B <- C <- D <- master <- HEAD

(les flèches se réfèrent ici à la direction du pointeur: la référence "parent" dans le cas des validations, la validation supérieure dans le cas de la tête de branche (référence de branche) et le nom de la branche dans le cas de la référence HEAD).

Ce que vous devez créer est le suivant:

A <- B <- C <- D <- [(BCD) ^ - 1] <- master <- HEAD

où "[(BCD) ^ - 1]" signifie le commit qui annule les changements dans les commits B, C, D. Les mathématiques nous disent que (BCD) ^ - 1 = D ^ -1 C ^ -1 B ^ -1, donc vous pouvez obtenir la situation requise en utilisant les commandes suivantes:

$ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "the commit message"

Une autre solution consisterait à extraire le contenu du commit A et à valider cet état:

$ git checkout -f A -- .
$ git commit -a

Vous auriez alors la situation suivante:

A <- B <- C <- D <- A '<- master <- HEAD

Le commit A 'a le même contenu que le commit A, mais est un commit différent (message de commit, parents, date de commit).

La solution de Jeff Ferland, modifiée par Charles Bailey s'appuie sur la même idée, mais utilise git reset :

$ git reset --hard A
$ git reset --soft @{1}  # (or ORIG_HEAD), which is D
$ git commit

Voie propre que j'ai trouvée utile

git revert --no-commit HEAD~3..

Cette commande annule les 3 dernières validations avec une seule validation.

Ne réécrit pas non plus l'historique.

Pour ce faire, il vous suffit d'utiliser la commande revert , en spécifiant la plage de validations que vous souhaitez annuler.

En tenant compte de votre exemple, vous devriez le faire (en supposant que vous êtes sur la branche «maître»):

git revert master~3..master

Cela va créer un nouveau commit dans votre local avec le commit inverse de B, C et D (ce qui signifie qu'il annulera les changements introduits par ces commits):

A <- B <- C <- D <- BCD' <- HEAD

Semblable à la réponse de Jakub, cela vous permet de sélectionner facilement des validations consécutives à annuler.

# revert all commits from B to HEAD, inclusively
$ git revert --no-commit B..HEAD  
$ git commit -m 'message'

git reset --hard a
git reset --mixed d
git commit

Cela agira comme un retour pour tous à la fois. Donnez un bon message de validation.

Assurez-vous d'abord que votre copie de travail n'est pas modifiée. Alors:

git diff HEAD commit_sha_you_want_to_revert_to | git apply

et puis juste engager. N'oubliez pas de documenter la raison du retour.

Je suis tellement frustré de ne pas pouvoir répondre à cette question. Toutes les autres questions concernent la manière de revenir correctement et de préserver l'histoire. Cette question dit "Je veux que le chef de la branche pointe vers A, c'est-à-dire que je veux que B, C, D et HEAD disparaissent et je veux que head soit synonyme de A."

git checkout <branch_name>
git reset --hard <commit Hash for A>
git push -f

J'ai beaucoup appris en lisant le post de Jakub, mais un gars de l'entreprise (avec accès pour pousser à notre branche "testing" sans Pull-Request) a poussé comme 5 mauvais commits essayant de corriger et de corriger et de corriger une erreur qu'il a faite il y a 5 commits. Non seulement cela, mais une ou deux demandes d'appel ont été acceptées, ce qui était maintenant mauvais. Alors oubliez ça, j'ai trouvé le dernier bon commit (abc1234) et je viens d'exécuter le script de base:

git checkout testing
git reset --hard abc1234
git push -f

J'ai dit aux 5 autres gars travaillant dans ce repo qu'ils feraient mieux de noter leurs changements pour les dernières heures et Wipe / Re-Branch des derniers tests. Fin de l'histoire.

Il s'agit d'une extension d'une des solutions fournies dans la réponse de Jakub

J'étais confronté à une situation où les validations dont j'avais besoin pour revenir en arrière étaient quelque peu complexes, plusieurs des validations étant des validations de fusion, et je devais éviter de réécrire l'historique. Je n'ai pas pu utiliser une série de git revertcommandes car j'ai finalement rencontré des conflits entre les modifications de réversion ajoutées. J'ai fini par utiliser les étapes suivantes.

Tout d'abord, vérifiez le contenu de la validation cible tout en laissant HEAD à la pointe de la branche:

$ git checkout -f <target-commit> -- .

(Le - s'assure <target-commit>est interprété comme un commit plutôt que comme un fichier; le. Fait référence au répertoire courant.)

Ensuite, déterminez quels fichiers ont été ajoutés dans les validations annulées et doivent donc être supprimés:

$ git diff --name-status --cached <target-commit>

Les fichiers qui ont été ajoutés doivent apparaître avec un "A" au début de la ligne, et il ne doit pas y avoir d'autres différences. Maintenant, si des fichiers doivent être supprimés, procédez à leur suppression:

$ git rm <filespec>[ <filespec> ...]

Enfin, validez la réversion:

$ git commit -m 'revert to <target-commit>'

Si vous le souhaitez, assurez-vous que nous sommes de retour à l'état souhaité:

$git diff <target-commit> <current-commit>

Il ne devrait pas y avoir de différences.

Le moyen facile de rétablir un groupe de validations sur un référentiel partagé (que les gens utilisent et que vous souhaitez conserver l'historique) est d'utiliser git reverten conjonction avec git rev-list. Ce dernier vous fournira une liste de commits, le premier effectuera le retour lui-même.

Il y a deux façons de procéder. Si vous souhaitez annuler plusieurs validations en une seule utilisation:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert -n $i; done

cela annulera un groupe de validations dont vous avez besoin, mais laissez toutes les modifications dans votre arborescence de travail, vous devez toutes les valider comme d'habitude.

Une autre option consiste à avoir un seul commit par modification annulée:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert --no-edit -s $i; done

Par exemple, si vous avez un arbre de validation comme

 o---o---o---o---o---o--->    
fff eee ddd ccc bbb aaa

pour annuler les modifications de eee à bbb , exécutez

for i in `git rev-list eee^..bbb`; do git revert --no-edit -s $i; done

Aucun de ceux-ci ne fonctionnait pour moi, j'ai donc eu trois commits à annuler (les trois derniers commits), alors j'ai fait:

git revert HEAD
git revert HEAD~2
git revert HEAD~4
git rebase -i HEAD~3 # pick, squash, squash

A fonctionné comme un charme :)

À mon avis, un moyen très simple et propre pourrait être:

retourner à A

git checkout -f A

diriger la tête du maître vers l'état actuel

git symbolic-ref HEAD refs/heads/master

enregistrer

git commit

Si vous souhaitez annuler temporairement les validations d'une fonction, vous pouvez utiliser la série de commandes suivantes.

Voici comment ça marche

git log --pretty = en ligne | grep 'nom_fonction' | coupe -d '' -f1 | xargs -n1 git revert --no-edit