Choisir entre revert et réécriture locale

Un commit erroné vient d’être identifié dans le dépôt du site. La bonne réparation dépend d’abord d’une question concrète : ce commit a-t-il déjà été publié sur une branche que d’autres personnes utilisent ? Vous allez choisir entre produire un nouveau commit correctif et déplacer une branche locale.

Annuler sans réécrire l’historique partagé

Lorsqu’un commit est déjà présent sur `main`, ou qu’il a été poussé et récupéré par des collègues, ne déplacez pas la branche pour le faire disparaître. Utilisez `git revert` : cette commande crée un nouveau commit qui applique l’effet inverse du commit ciblé. Le commit initial reste visible dans l’historique, et la réparation devient elle aussi consultable.

Supposons que le commit erroné soit actuellement le dernier commit de `main`. Après avoir identifié ce cas et vous être placés sur `main`, vous pouvez lancer la commande suivante. Elle ouvre éventuellement l’éditeur configuré pour confirmer le message du nouveau commit ; enregistrez le message proposé ou adaptez-le pour préciser la raison de l’annulation.

git switch main
git revert HEAD

[main abc1234] Revert « Corriger les liens de navigation »
 1 file changed, 1 insertion(+), 1 deletion(-)

Ici, `HEAD` désigne le commit courant : le scénario suppose donc que le commit à annuler est bien le dernier de `main`. Si le commit erroné est plus ancien, ciblez son identifiant à la place de `HEAD`, après avoir confirmé le bon commit. Le résultat est un nouveau commit d’annulation ; vous pouvez le constater dans le journal, où le commit d’origine et son inverse apparaissent tous deux.

git log -2 --oneline

abc1234 Revert « Corriger les liens de navigation »
789def0 Corriger les liens de navigation

Cette méthode convient aussi à une branche partagée autre que `main` : elle ajoute une annulation dans son historique, sans imposer aux autres de reconstruire leurs branches. Elle respecte donc la règle du projet : une erreur publiée se corrige par un changement supplémentaire, et non en faisant comme si le commit partagé n’avait jamais existé.

Réécrire une branche locale non publiée

Si les commits erronés se trouvent uniquement sur votre branche locale de travail et n’ont pas été publiés, vous pouvez déplacer cette branche avec `git reset`. Par exemple, sur `feature/navigation`, la commande ci-dessous retire les deux derniers commits de la pointe de la branche et la replace sur son parent d’il y a deux commits. Le contenu de ces commits n’est alors plus dans l’historique de cette branche.

git switch feature/navigation
git reset --hard HEAD~2

HEAD est maintenant à 456abcd Ajouter la section de navigation

La différence n’est pas seulement technique. Si vous réécrivez une branche déjà publiée avec `reset`, son nouvel historique diverge de celui que les collègues ont récupéré. Ils peuvent conserver les anciens commits et rencontrer des doublons ou des divergences lorsqu’ils synchronisent leur travail. Le fait de pousser ensuite avec une mise à jour forcée ne résout pas cette coordination : il peut remplacer la référence distante et rendre le travail concurrent plus difficile à retrouver.

Pour une branche partagée, préférez donc `revert`, même si l’annulation crée un commit supplémentaire. Réservez la réécriture à votre branche locale tant que personne ne dépend de ses commits. En cas de doute sur la publication ou sur l’usage de la branche, ne lancez pas `reset` : vérifiez la situation avec l’équipe avant toute opération qui déplace la référence.

À retenir

• Pour annuler un commit partagé, utilisez `git revert` : l’historique conserve le commit initial et ajoute un commit d’annulation.
• `git reset` déplace la branche ; réservez-le aux commits d’une branche locale non publiée.
• `git reset --hard` peut écraser des changements locaux : vérifiez ce que vous devez conserver avant de l’utiliser.
• Une réécriture publiée crée une divergence pour les collègues ; en cas de doute, coordonnez-vous avant d’agir.

Dans la prochaine leçon, vous réparerez un incident en préservant le travail concurrent et en coordonnant l’intervention sur une branche partagée.