Comment vérifier l'état des sous-modules Git dans un dépôt

GitBeginner
Pratiquer maintenant

Introduction

Les sous-modules Git sont une fonctionnalité puissante qui vous permet d'inclure des dépôts externes au sein de vos propres projets. Cette capacité est particulièrement utile lorsque votre projet dépend de bibliothèques ou de composants externes qui sont maintenus séparément. En utilisant les sous-modules, vous pouvez maintenir ces dépendances à jour et bien gérées.

Dans ce tutoriel, vous apprendrez comment vérifier l'état des sous-modules Git dans votre dépôt, comprendre les modifications qui leur ont été apportées et vous assurer qu'ils sont correctement synchronisés avec leurs dépôts sources.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 82%. Il a reçu un taux d'avis positifs de 96% de la part des apprenants.

Création d'un dépôt avec des sous-modules

Commençons par créer un exemple de dépôt avec un sous-module pour avoir un environnement pratique pour notre apprentissage.

Configuration du dépôt principal

Tout d'abord, nous allons créer un nouveau dépôt principal où nous ajouterons notre sous-module. Ouvrez votre terminal et exécutez les commandes suivantes :

cd ~/project
mkdir main-repo
cd main-repo
git init

Vous devriez voir une sortie similaire à :

Initialized empty Git repository in /home/labex/project/main-repo/.git/

Maintenant, créons un fichier simple dans notre dépôt principal :

echo "## Main Repository" > README.md
git add README.md
git commit -m "Initial commit"

La sortie devrait indiquer que vous avez créé votre premier commit :

[master (root-commit) xxxxxxx] Initial commit
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

Ajout d'un sous-module

Ajoutons maintenant un sous-module à notre dépôt principal. Pour ce tutoriel, nous utiliserons un petit dépôt public comme sous-module :

git submodule add https://github.com/libgit2/libgit2-backends.git libs/libgit2-backends

Cette commande clonera le dépôt et l'ajoutera en tant que sous-module dans le répertoire libs/libgit2-backends. Vous devriez voir une sortie similaire à :

Cloning into '/home/labex/project/main-repo/libs/libgit2-backends'...
remote: Enumerating objects: xxx, done.
remote: Counting objects: 100% (xxx/xxx), done.
remote: Compressing objects: 100% (xxx/xxx), done.
remote: Total xxx (delta xx), reused xxx (delta xx), pack-reused xxx
Receiving objects: 100% (xxx/xxx), xxx KiB | xxx KiB/s, done.
Resolving deltas: 100% (xxx/xxx), done.

Comprendre les changements

Lorsque vous ajoutez un sous-module, Git crée un fichier .gitmodules dans votre dépôt qui suit l'URL et le chemin du sous-module. Examinons ce fichier :

cat .gitmodules

Vous devriez voir un contenu similaire à :

[submodule "libs/libgit2-backends"]
	path = libs/libgit2-backends
	url = https://github.com/libgit2/libgit2-backends.git

Vérifions également l'état de notre dépôt :

git status

Vous devriez voir une sortie indiquant que le nouveau fichier .gitmodules et le répertoire du sous-module ont été ajoutés :

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   .gitmodules
        new file:   libs/libgit2-backends

Engageons ces changements pour terminer notre configuration :

git commit -m "Add libgit2-backends submodule"

Vous devriez maintenant avoir un dépôt avec un sous-module configuré avec succès.

Vérification de l'état des sous-modules

Maintenant que nous avons un dépôt avec un sous-module, apprenons à vérifier l'état du sous-module et à comprendre ce que signifie la sortie.

Vérification de l'état de base du sous-module

Git fournit une commande spécifique pour vérifier l'état des sous-modules. Exécutez la commande suivante :

cd ~/project/main-repo
git submodule status

Vous devriez voir une sortie similaire à :

+abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (v1.0.0-123-gabcdef12)

Comprenons ce que signifie cette sortie :

  1. Le premier caractère peut être l'un des suivants :

    • + : indique que le commit du sous-module extrait diffère de ce qui est enregistré dans le dépôt principal
    • (espace) : indique que le sous-module est synchronisé avec ce qui est enregistré
    • - : indique que le sous-module n'est pas initialisé
    • U : indique des conflits de fusion dans le sous-module
  2. La chaîne alphanumérique est le hash de commit du commit actuel extrait dans le sous-module.

  3. Le chemin indique où se trouve le sous-module dans votre dépôt.

  4. Le texte entre parenthèses affiche des informations supplémentaires sur le commit extrait, comme les tags ou les noms de branches.

Informations détaillées sur le sous-module

Pour des informations plus détaillées sur vos sous-modules, vous pouvez utiliser la commande suivante :

git submodule

Cela affichera des informations similaires à la commande status, mais dans un format différent.

Utilisation de Git Status pour voir les changements du sous-module

Vous pouvez également utiliser la commande standard git status pour voir les changements dans les sous-modules :

git status

S'il n'y a pas de changements dans le sous-module, vous ne verrez aucune mention de celui-ci dans la sortie. Cependant, s'il y a des changements dans le commit extrait du sous-module ou dans les fichiers du sous-module, git status affichera ces informations.

Examen du contenu du sous-module

Examinons le contenu de notre sous-module :

cd ~/project/main-repo
ls -la libs/libgit2-backends/

Vous verrez les fichiers du dépôt libgit2-backends. Notez que le sous-module est essentiellement un dépôt Git complet au sein de votre dépôt principal. Vous pouvez le vérifier en recherchant la présence d'un répertoire .git :

ls -la libs/libgit2-backends/.git

Vous pourriez ne pas voir un répertoire .git directement, mais plutôt un fichier qui pointe vers les données réelles du dépôt Git stockées dans le répertoire .git/modules de votre dépôt principal. C'est ainsi que Git gère les sous-modules.

Comprendre la référence du sous-module

Le dépôt principal stocke une référence à un commit spécifique dans le dépôt du sous-module. Cette référence est ce que Git utilise pour savoir quelle version du sous-module doit être extraite lors du clonage de votre dépôt ou de la mise à jour du sous-module.

Voyons le commit auquel notre dépôt principal fait référence :

cd ~/project/main-repo
git ls-files --stage libs/libgit2-backends

La sortie affichera un hash de commit, qui est le commit spécifique du sous-module que le dépôt principal suit.

Mise à jour des sous-modules

Une tâche courante lorsque l'on travaille avec des sous-modules est de les maintenir à jour avec leurs dépôts distants. Apprenons à mettre à jour notre sous-module.

Initialisation et mise à jour des sous-modules

Si vous venez de cloner un dépôt qui contient des sous-modules, vous devrez les initialiser et les mettre à jour. Pour notre dépôt existant, nous pouvons démontrer ce processus avec :

cd ~/project/main-repo
git submodule init
git submodule update

La commande init initialise votre configuration des sous-modules, et la commande update récupère les données et extrait le commit spécifié dans votre dépôt principal.

Vous pouvez également combiner ces commandes :

git submodule update --init

Mise à jour des sous-modules vers la dernière version distante

Si vous souhaitez mettre à jour un sous-module vers le dernier commit de son dépôt distant, vous pouvez utiliser :

cd ~/project/main-repo
git submodule update --remote libs/libgit2-backends

Cette commande récupère les dernières modifications du dépôt distant et met à jour le sous-module. Vous devriez voir une sortie indiquant que Git récupère les modifications.

Après avoir exécuté cette commande, vérifions l'état du sous-module :

git submodule status

Vous remarquerez que la sortie affiche maintenant un signe plus (+) au début, indiquant que le commit extrait du sous-module diffère de ce qui est enregistré dans le dépôt principal :

+abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (origin/HEAD)

Pour confirmer les modifications apportées à votre dépôt principal, exécutez :

git status

Vous devriez voir une sortie indiquant que le sous-module a été modifié :

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:   libs/libgit2-backends (new commits)

Committing la référence du sous-module mise à jour

Pour enregistrer l'état mis à jour du sous-module dans votre dépôt principal, vous devez ajouter et committer les modifications :

git add libs/libgit2-backends
git commit -m "Update libgit2-backends submodule to latest version"

La sortie devrait indiquer que vous avez réussi à committer la nouvelle référence du sous-module.

Vérification de l'état mis à jour

Après avoir commité la référence du sous-module mise à jour, vérifions à nouveau l'état :

git submodule status

La sortie ne devrait plus avoir de signe plus au début, indiquant que le sous-module est maintenant synchronisé avec ce qui est enregistré dans le dépôt principal :

 abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (origin/HEAD)

Comprendre les options de mise à jour des sous-modules

La commande git submodule update possède plusieurs options qui contrôlent la manière dont les mises à jour sont effectuées :

  • --remote : Mettre à jour vers le dernier commit sur la branche de suivi distante
  • --merge : Fusionner les modifications si la branche actuelle est en retard par rapport à la distante
  • --rebase : Rebaser les modifications si la branche actuelle est en retard par rapport à la distante
  • --recursive : Mettre à jour également les sous-modules imbriqués

Pour la plupart des cas d'utilisation de base, git submodule update --remote est suffisant.

Travailler avec les modifications des sous-modules

Parfois, vous devez travailler avec des modifications à l'intérieur d'un sous-module. Dans cette étape, nous allons apprendre à effectuer et à gérer les modifications au sein des sous-modules.

Pour travailler avec un sous-module, vous devez naviguer dans son répertoire :

cd ~/project/main-repo/libs/libgit2-backends

À partir d'ici, vous pouvez utiliser les commandes Git standard pour afficher des informations sur le dépôt du sous-module :

git status
git log -3 --oneline

La commande git status affiche l'état actuel du dépôt du sous-module, et git log affiche les commits récents.

Effectuer des modifications dans un sous-module

Faisons une simple modification à un fichier dans le sous-module. Tout d'abord, créons un nouveau fichier :

echo "## My notes on libgit2-backends" > NOTES.md

Maintenant, vérifions l'état de notre modification :

git status

Vous devriez voir une sortie indiquant que vous avez un fichier non suivi :

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        NOTES.md

Ajoutons et committons cette modification dans le sous-module :

git add NOTES.md
git commit -m "Add notes file"

Vous devriez voir une sortie confirmant votre commit dans le sous-module.

Vérification de l'état depuis le dépôt principal

Maintenant, revenons au dépôt principal et vérifions l'état :

cd ~/project/main-repo
git status

Vous devriez voir une sortie indiquant que le sous-module a été modifié :

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:   libs/libgit2-backends (new commits)

Committing les modifications du sous-module dans le dépôt principal

Pour enregistrer le nouvel état du sous-module dans votre dépôt principal, vous devez ajouter et committer les modifications :

git add libs/libgit2-backends
git commit -m "Update libgit2-backends with notes file"

La sortie devrait indiquer que vous avez réussi à committer la nouvelle référence du sous-module.

Affichage des modifications détaillées du sous-module

Pour voir des informations plus détaillées sur les modifications dans les sous-modules, vous pouvez utiliser :

git diff --submodule

Cette commande affiche la plage de commits qui ont été ajoutés ou supprimés dans chaque sous-module modifié.

Résumé du travail avec les modifications des sous-modules

Lorsque vous travaillez avec des modifications dans un sous-module, souvenez-vous de ce flux de travail :

  1. Naviguez dans le répertoire du sous-module
  2. Effectuez et committez les modifications dans le sous-module
  3. Revenez au dépôt principal
  4. Ajoutez et committez la référence du sous-module mise à jour

Ce processus de commit en deux étapes (d'abord dans le sous-module, puis dans le dépôt principal) est essentiel pour suivre correctement les modifications apportées aux sous-modules.

Résumé

Dans ce tutoriel, vous avez appris à travailler avec les sous-modules Git, en vous concentrant sur la vérification de leur état et la réalisation de mises à jour. Voici ce que vous avez accompli :

  1. Création d'un dépôt principal et ajout d'un sous-module à celui-ci
  2. Apprentissage de la vérification de l'état des sous-modules à l'aide de diverses commandes Git
  3. Mise à jour d'un sous-module vers la dernière version de son dépôt distant
  4. Effectuation de modifications au sein d'un sous-module et suivi correct de ces modifications dans le dépôt principal

Les sous-modules Git offrent un moyen puissant d'inclure des dépôts externes dans vos projets, vous permettant de gérer les dépendances efficacement. En comprenant comment vérifier leur état et gérer les mises à jour, vous pouvez vous assurer que votre projet reste correctement synchronisé avec ses dépendances.

Commandes clés à retenir :

  • git submodule status - Vérifier l'état actuel des sous-modules
  • git submodule update --remote - Mettre à jour les sous-modules vers leurs dernières versions
  • git add <submodule-path> - Préparer les modifications de la référence d'un sous-module
  • git diff --submodule - Afficher les modifications détaillées dans les sous-modules

Grâce à ces compétences, vous pouvez gérer efficacement les dépôts Git qui incorporent du code externe via des sous-modules.