Comment vérifier si un commit Git a été annulé

Introduction

Dans ce laboratoire, vous apprendrez à identifier si un commit Git a été annulé (reverted). Nous allons explorer comment utiliser la commande git log pour trouver les commits d'annulation (revert commits) puis utiliser git show pour vérifier les détails de ces annulations. Enfin, nous examinerons les commits non annulés pour comprendre la différence dans leur historique et leur contenu. Cet exercice pratique vous guidera dans la création d'un historique de projet d'exemple, y compris un commit qui sera ensuite annulé, vous permettant de pratiquer les techniques d'identification et de vérification des commits annulés.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560064{{"Comment vérifier si un commit Git a été annulé"}} git/commit -.-> lab-560064{{"Comment vérifier si un commit Git a été annulé"}} git/diff -.-> lab-560064{{"Comment vérifier si un commit Git a été annulé"}} git/log -.-> lab-560064{{"Comment vérifier si un commit Git a été annulé"}} end

Exécuter git log pour trouver les commits d'annulation (revert commits)

Dans cette étape, nous allons apprendre à utiliser git log pour trouver les commits qui ont été annulés (reverted). Annuler un commit signifie créer un nouveau commit qui annule les modifications introduites par un commit précédent. Cela est utile lorsque vous avez fait une erreur et que vous souhaitez l'annuler facilement sans perdre l'historique du commit original.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet. Ouvrez votre terminal et accédez au répertoire my-time-machine :

cd ~/project/my-time-machine

Maintenant, créons quelques commits pour simuler l'historique d'un projet, y compris un commit que nous annulerons plus tard.

Créez le premier fichier :

echo "Initial content" > file1.txt
git add file1.txt
git commit -m "Add file1"

Vous devriez voir une sortie similaire à celle-ci :

[master (root-commit) a1b2c3d] Add file1
 1 file changed, 1 insertion(+)
 create mode 100644 file1.txt

Maintenant, ajoutons plus de contenu et faisons un autre commit :

echo "Adding more content" >> file1.txt
git add file1.txt
git commit -m "Add more content to file1"

Vous devriez voir une sortie similaire à celle-ci :

[master 4e5f6g7] Add more content to file1
 1 file changed, 1 insertion(+)

Ensuite, faisons un commit que nous annulerons plus tard :

echo "This commit will be reverted" > file2.txt
git add file2.txt
git commit -m "Add file2 (will be reverted)"

Vous devriez voir une sortie similaire à celle-ci :

[master 8h9i0j1] Add file2 (will be reverted)
 1 file changed, 1 insertion(+)
 create mode 100644 file2.txt

Maintenant, annulons le dernier commit. Nous pouvons utiliser git revert HEAD pour annuler le commit le plus récent :

git revert HEAD --no-edit

Le flag --no-edit indique à Git de créer automatiquement le message de commit d'annulation sans ouvrir un éditeur. Vous devriez voir une sortie similaire à celle-ci :

[master k2l3m4n] Revert "Add file2 (will be reverted)"
 1 file changed, 1 deletion(-)
 delete mode 100644 file2.txt

Parfait ! Nous avons maintenant créé un commit qui annule les modifications du commit "Add file2 (will be reverted)".

Maintenant, utilisons git log pour afficher l'historique de nos commits et trouver le commit d'annulation :

git log --oneline

Vous devriez voir une sortie similaire à celle-ci :

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

Remarquez le message de commit "Revert 'Add file2 (will be reverted)'". Cela indique clairement que ce commit est une annulation d'un commit précédent. Utiliser git log avec le flag --oneline est un moyen rapide de voir un résumé de l'historique de vos commits et d'identifier les commits d'annulation par leur message.

Utiliser git show pour vérifier l'annulation (revert)

Dans cette étape, nous allons utiliser la commande git show pour examiner les détails du commit d'annulation (revert commit) et vérifier qu'il a correctement annulé les modifications du commit original. La commande git show est un outil puissant pour inspecter les objets Git, y compris les commits, les tags et les blobs.

Tout d'abord, assurez-vous que vous êtes dans le répertoire ~/project/my-time-machine :

cd ~/project/my-time-machine

Maintenant, nous avons besoin du hash du commit d'annulation. Vous pouvez l'obtenir à partir de la sortie de git log --oneline de l'étape précédente. C'est le premier commit listé. Par exemple, si la sortie de votre git log --oneline était :

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

Le hash du commit d'annulation est k2l3m4n. Remarque : Votre hash de commit sera différent.

Maintenant, utilisez git show suivi du hash de votre commit d'annulation. Remplacez YOUR_REVERT_COMMIT_HASH par le véritable hash de la sortie de votre git log --oneline :

git show YOUR_REVERT_COMMIT_HASH

Par exemple, en utilisant le hash d'exemple k2l3m4n :

git show k2l3m4n

Vous devriez voir une sortie similaire à celle-ci :

commit k2l3m4n (HEAD -> master)
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:05:00 2023 +0000

    Revert "Add file2 (will be reverted)"

    This reverts commit 8h9i0j1.

diff --git a/file2.txt b/file2.txt
deleted file mode 100644
index 8b1a99c..0000000
--- a/file2.txt
+++ /dev/null
@@ -1 +0,0 @@
-This commit will be reverted

Décortiquons cette sortie :

La première partie montre les détails du commit : le hash du commit, l'auteur, la date et le message de commit. Remarquez que le message indique explicitement qu'il annule un commit spécifique (identifié par son hash).
La section diff montre les modifications introduites par ce commit. Dans ce cas, elle montre que file2.txt a été supprimé (deleted file mode 100644). Cela confirme que le commit d'annulation a réussi à annuler la création de file2.txt.

L'utilisation de git show vous permet d'inspecter les modifications exactes introduites par n'importe quel commit de votre historique. Cela est incroyablement utile pour comprendre l'historique de votre projet et vérifier que les annulations ou autres modifications ont été appliquées correctement.

Tester les commits non annulés (non-reverted)

Dans les étapes précédentes, nous avons créé plusieurs commits puis annulé l'un d'eux. Nous avons utilisé git log pour voir l'historique et git show pour inspecter le commit d'annulation. Maintenant, vérifions que les commits qui n'ont pas été annulés existent toujours et contiennent les modifications attendues.

Tout d'abord, assurez-vous que vous êtes dans le répertoire ~/project/my-time-machine :

cd ~/project/my-time-machine

Rappelons-nous l'historique de nos commits obtenu avec git log --oneline :

k2l3m4n (HEAD -> master) Revert "Add file2 (will be reverted)"
8h9i0j1 Add file2 (will be reverted)
4e5f6g7 Add more content to file1
a1b2c3d Add file1

Les commits "Add file1" et "Add more content to file1" n'ont pas été annulés. Utilisons git show pour inspecter le commit "Add more content to file1" et voir ses modifications.

Trouvez le hash du commit "Add more content to file1" dans la sortie de votre git log --oneline. Dans l'exemple ci-dessus, c'est 4e5f6g7. N'oubliez pas d'utiliser votre véritable hash de commit.

Maintenant, utilisez git show avec ce hash de commit :

git show YOUR_MORE_CONTENT_COMMIT_HASH

Par exemple, en utilisant le hash d'exemple 4e5f6g7 :

git show 4e5f6g7

Vous devriez voir une sortie similaire à celle-ci :

commit 4e5f6g7
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:02:00 2023 +0000

    Add more content to file1

diff --git a/file1.txt b/file1.txt
index 8b1a99c..a1b2c3d 100644
--- a/file1.txt
+++ b/file1.txt
@@ -1 +1,2 @@
 Initial content
+Adding more content

Cette sortie montre les détails du commit et la section diff indique clairement qu'une ligne "Adding more content" a été ajoutée à file1.txt. Cela confirme que ce commit et ses modifications font toujours partie de l'historique du projet, même si un commit ultérieur a été annulé.

Cela démontre un aspect clé de Git : annuler un commit crée un nouveau commit qui annule les modifications. Il n'efface pas le commit original de l'historique. Cela est important car il conserve un enregistrement complet de toutes les modifications, vous permettant de comprendre l'évolution complète de votre projet.

Vous pouvez de la même manière utiliser git show avec le hash du commit "Add file1" (a1b2c3d dans l'exemple) pour voir la création initiale de file1.txt.

En utilisant git log pour voir l'historique et git show pour inspecter les commits individuels, vous pouvez naviguer efficacement et comprendre la chronologie de votre projet, même lorsque des commits ont été annulés.

Résumé

Dans ce laboratoire (lab), nous avons appris à identifier les commits annulés (reverted commits) dans un dépôt Git. Nous avons commencé par créer un historique de projet avec plusieurs commits, dont l'un était spécifiquement destiné à être annulé. Nous avons ensuite utilisé la commande git revert HEAD --no-edit pour créer un nouveau commit qui annule les modifications du commit précédent. Ce processus a démontré que l'annulation d'un commit ajoute un nouveau commit à l'historique plutôt que de supprimer l'original.

Nous continuerons à explorer comment utiliser git log pour trouver ces commits d'annulation et git show pour vérifier leur contenu, en les distinguant des commits non annulés.