Comment vérifier si un commit Git est vide

Introduction

Dans ce laboratoire (lab), nous allons explorer comment déterminer si un commit Git est vide, c'est-à-dire s'il n'introduit aucune modification dans les fichiers du projet. Nous apprendrons à utiliser la commande git show pour inspecter les détails et les modifications au sein d'un commit spécifique, offrant ainsi une représentation visuelle de son contenu.

En outre, nous allons approfondir l'utilisation de la commande git diff-tree, une méthode plus directe pour vérifier de manière programmée si un commit comporte des modifications associées. Enfin, nous testerons ces techniques à la fois avec des commits normaux qui incluent des modifications et des commits vides créés intentionnellement pour consolider notre compréhension.

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/status("Check Status") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560058{{"Comment vérifier si un commit Git est vide"}} git/status -.-> lab-560058{{"Comment vérifier si un commit Git est vide"}} git/commit -.-> lab-560058{{"Comment vérifier si un commit Git est vide"}} git/diff -.-> lab-560058{{"Comment vérifier si un commit Git est vide"}} git/log -.-> lab-560058{{"Comment vérifier si un commit Git est vide"}} end

Exécuter git show pour vérifier les modifications

Dans cette étape, nous allons apprendre à inspecter les détails d'un commit spécifique en utilisant la commande git show. Cette commande est comme ouvrir une capsule temporelle pour voir exactement ce qui s'y trouvait à ce moment-là.

Tout d'abord, assurons-nous que nous sommes dans le répertoire de notre projet :

cd ~/project/my-time-machine

Maintenant, utilisons git show pour examiner notre premier commit. Nous pouvons utiliser le hash du commit (la longue chaîne de lettres et de chiffres) issu de la sortie de git log, ou simplement utiliser HEAD qui fait référence au dernier commit sur la branche actuelle.

git show HEAD

Vous devriez voir une sortie similaire à celle-ci :

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

    Send a message to the future

diff --git a/message.txt b/message.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

Décortiquons cette sortie :

La première partie est similaire à git log et montre les informations sur le commit (hash, auteur, date, message).
La section diff montre les modifications introduites par ce commit.
- diff --git a/message.txt b/message.txt : Indique une différence entre l'état avant et après le commit pour le fichier message.txt.
- new file mode 100644 : Montre que message.txt est un nouveau fichier.
- index 0000000..e69de29 : Informations internes Git sur le contenu du fichier.
- --- /dev/null : Représente l'état avant le commit (le fichier n'existait pas).
- +++ b/message.txt : Représente l'état après le commit.
- @@ -0,0 +1 @@ : C'est un "en-tête de bloc" indiquant les modifications. -0,0 signifie que zéro lignes ont été supprimées à partir de la ligne 0 dans le fichier d'origine, et +1 signifie qu'une ligne a été ajoutée à partir de la ligne 1 dans le nouveau fichier.
- +Hello, Future Me : La ligne qui a été ajoutée dans ce commit. Le signe + indique une addition.

La commande git show est incroyablement utile pour comprendre l'historique de votre projet. Vous pouvez l'utiliser pour voir exactement quelles modifications ont été apportées dans n'importe quel commit spécifique, ce qui est essentiel pour le débogage ou pour comprendre comment une fonctionnalité a été implémentée.

Appuyez sur q pour quitter la vue git show.

Utiliser git diff-tree pour vérifier si un commit est vide

Dans cette étape, nous allons explorer une autre commande, git diff-tree, qui peut être utile pour examiner les modifications au sein d'un commit, en particulier pour vérifier si un commit est "vide" (c'est-à-dire qu'il n'introduit aucune modification dans le contenu des fichiers, seulement des métadonnées comme le message de commit).

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Maintenant, utilisons git diff-tree avec les options --no-commit-id et --name-only sur notre premier commit (HEAD).

git diff-tree --no-commit-id --name-only HEAD

Vous devriez voir la sortie suivante :

message.txt

Comprenons la commande et sa sortie :

git diff-tree : Cette commande compare le contenu et le mode des objets dans un arbre Git.
--no-commit-id : Cette option supprime l'ID du commit de la sortie, la rendant plus propre.
--name-only : Cette option n'affiche que les noms des fichiers qui ont été modifiés dans le commit.
HEAD : Spécifie le commit que nous voulons examiner (notre dernier commit).

La sortie message.txt nous indique que le commit pointé par HEAD a introduit des modifications dans le fichier message.txt.

Maintenant, voyons ce qui se passe si nous exécutons la même commande sur un commit qui ne modifie aucun fichier. Comme notre premier commit est le seul, essayons un scénario hypothétique. Si nous avions un commit qui n'a fait que mettre à jour le message de commit sans modifier aucun fichier, git diff-tree --no-commit-id --name-only <commit-hash> ne produirait aucune sortie. C'est ainsi que vous pouvez utiliser git diff-tree pour vérifier si un commit est "vide" en termes de modifications de fichiers.

Alors que git show vous donne une vue détaillée des modifications, git diff-tree avec des options comme --name-only est utile pour la programmation ou pour vérifier rapidement quels fichiers ont été affectés par un commit sans voir le diff complet.

Tester avec des commits normaux

Dans cette étape, nous allons pratiquer la création de plus de commits pour construire un historique dans notre dépôt et voir comment git log et git status reflètent ces modifications. Cela simulera un flux de travail plus typique où vous effectuez plusieurs modifications et les enregistrez de manière incrémentielle.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de votre projet :

cd ~/project/my-time-machine

Maintenant, ajoutons une autre ligne à notre fichier message.txt. Nous allons utiliser la commande echo avec >> pour ajouter du texte au fichier existant.

echo "Adding another line for testing." >> message.txt

Vérifions le contenu du fichier pour confirmer la modification :

cat message.txt

Vous devriez voir :

Hello, Future Me
Adding another line for testing.

Maintenant, vérifions l'état de notre dépôt :

git status

Vous devriez voir une sortie indiquant que message.txt a été modifié :

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a")

Git identifie correctement que le fichier a été modifié depuis le dernier commit. Maintenant, préparons (stage) et validons (commit) cette modification.

git add message.txt
git commit -m "Add a second line to message.txt"

Vous devriez voir une sortie confirmant le commit :

[master a1b2c3d] Add a second line to message.txt
 1 file changed, 1 insertion(+)

Nous avons maintenant créé un deuxième commit. Affichons l'historique des commits en utilisant git log :

git log

Vous devriez maintenant voir deux entrées de commit, le dernier commit étant en haut :

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

    Add a second line to message.txt

commit f0e1d2c3b4a5968776543210fedcba9876543210
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 09:55:00 2023 +0000

    Send a message to the future

(Note : Les hashs de commit et les dates seront différents dans votre sortie).

Cela démontre le cycle de base d'effectuer des modifications, de les préparer avec git add et de les enregistrer en tant que nouveau commit avec git commit. Chaque commit représente un point distinct dans l'historique de votre projet, vous permettant de suivre l'évolution et de revenir à des états précédents si nécessaire.

Appuyez sur q pour quitter la vue du journal.

Résumé

Dans ce laboratoire, nous avons appris à inspecter les détails d'un commit Git en utilisant la commande git show. Cette commande fournit une vue complète d'un commit spécifique, y compris ses métadonnées (auteur, date, message) et les modifications exactes introduites par ce commit au format diff. Nous avons vu comment la sortie diff indique clairement les lignes ajoutées, supprimées ou modifiées, nous permettant de comprendre les modifications de contenu au sein d'un commit.

Nous continuerons à explorer des méthodes pour vérifier si un commit est vide et tester ces techniques avec différents types de commits.