web-dev-qa-db-fra.com

Quel est l'intérêt de 'git submodule init'?

Contexte

Pour remplir les sous-modules d'un référentiel, un généralement invoque :

git submodule init
git submodule update

Dans cet usage, git submodule init semble ne faire qu’une chose: peupler .git/config avec des informations déjà présentes dans .gitmodules.

Quel est le but de ça?

Ne pouvait pas git submodule update utilisez simplement les informations de .gitmodules? Cela éviterait à la fois:

  • une commande inutile (git submodule init); et
  • une duplication inutile de données (.gitmodules contenu dans .git/config).

Question

Soit:

  • il y a des cas d'utilisation pour git submodule init que je ne sais pas (dans ce cas, veuillez m'éclairer!); ou sinon
  • git submodule init est un fichier crue qui pourrait être déconseillé dans Git sans aucun dommage.

Lequel de ces est vrai?

gitgit-submodulesrationale
35
sampablokuper

Lire le git submoduledocumentation , il est un cas d'utilisation qui justifie apparemment l'existence de git submodule init en tant que commande autonome.

Si un utilisateur qui a cloné un référentiel souhaite utiliser pour un sous-module une URL différente de celle spécifiée par le référentiel en amont, cet utilisateur peut:

git submodule init
vim .git/config # Alter submodule URL as desired, without changing .gitmodules
                # or polluting history.
git submodule update
14
sampablokuper

Imaginez que le référentiel comporte 10 sous-modules et vous ne vous intéressez qu'à deux sous-modules de ceux-ci. Dans ce cas, vous souhaiterez peut-être obtenir des mises à jour uniquement de ces deux sous-modules à partir du référentiel distant de temps à autre. git init fonctionne bien pour cela, car une fois que vous exécutez la commande git init pour ces deux sous-modules, git submodule update --remote ne s'applique qu'à eux.

Ajout de deux démos de flux de travail.

Workflow1: Les sous-modules sont des bibliothèques utilisées par plusieurs projets.

Je pense que c'est l'un des cas d'utilisation courants.

Vous venez de cloner "mon projet".

git clone https://example.com/demo/my-project

Et la surface de sa structure est comme ci-dessous.

Enter image description here

Le contenu de .gitmodules

[submodule "lib1"]
    path = lib1
    url = https://example.com/demo/lib1
[submodule "lib2"]
    path = lib2
    url = https://example.com/demo/lib2
[submodule "lib3"]
    path = lib3
    url = https://example.com/demo/lib3
[submodule "lib4"]
    path = lib4
    url = https://example.com/demo/lib4

Vous voulez refactoriser le code code1.js qui fait référence à lib1 et lib2, ce qui signifie que vous n'avez pas besoin de cloner et d'extraire lib3 et lib4. Donc, vous venez d'exécuter la commande ci-dessous.

git submodule init lib1 lib2

Voyons maintenant le contenu de .git/config

...
[submodule "lib1"]
    active = true
    url = https://example.com/demo/lib1
[submodule "lib2"]
    active = true
    url = https://example.com/demo/lib2

Cela signifie quelque chose comme "Prêt à mettre à jour lib1 et lib2 à partir d'exemple.com/demo".

À ce stade, les répertoires lib1 et lib2 sont vides. Vous pouvez cloner et récupérer lib1 et lib2 avec une seule commande:

git submodule update

Maintenant vous êtes capable de refactoriser code1.js sans erreur d'importation.

Les sous-modules ne sont que des références à certains commits. Ainsi, lorsque vous souhaitez mettre à jour des bibliothèques vers de nouvelles versions, vous devez mettre à jour les références. Vous pouvez le faire avec la commande ci-dessous.

git submodule update --remote

Vous pouvez maintenant voir à quel point il est utile d’initialiser uniquement les sous-modules dont vous avez besoin.

Workflow 2: Chaque sous-module est un projet et un grand projet les inclut.

Je suis fan de ça.

Vous clonez "projet principal".

git clone https://example.com/demo/main-project

Et la surface de sa structure est comme ci-dessous.

Enter image description here

Vous pouvez voir un répertoire nommé "partagé". Il existe une règle dans ce flux de travaux: si vous souhaitez utiliser des codes partagés de projet principal dans votre projet, vous devez créer le projet en tant que sous-module de projet principal.

J'aime mettre des classes d'entités dans un répertoire partagé comme ci-dessous.

Enter image description here

De retour au workflow de sous-module, le contenu de .gitmodules est le suivant.

[submodule "sub-project1"]
    path = sub-project1
    url = https://example.com/demo/sub-project1
[submodule "sub-project2"]
    path = sub-project2
    url = https://example.com/demo/sub-project2
[submodule "sub-project3"]
    path = sub-project3
    url = https://example.com/demo/sub-project3
[submodule "sub-project4"]
    path = sub-project4
    url = https://example.com/demo/sub-project4

Cette fois, vous voulez refactoriser du code dans le répertoire partagé du projet principal et vous savez que seuls les sous-projets1 et 2 du projet partagent le code partagé, ce qui signifie que vous n'avez pas besoin de cloner et d'extraire les sous-projets3 et les sous-projets. project4. Donc, vous venez d'exécuter la commande ci-dessous.

git submodule init sub-project1 sub-project2

Et comme je l'ai mentionné dans workflow1, vous devez exécuter la commande ci-dessous pour les cloner et les extraire.

git submodule update

Est-ce que je ferais git submodule update --remote dans ce cas? Ou dois-je même initier et mettre à jour des sous-modules pour refactoriser le code dans le répertoire partagé? Oui, car vous devez exécuter des tests dans les sous-modules après avoir refactoré le code partagé et si une mise à jour de ces sous-modules est validée et poussée dans le référentiel distant pendant le refactoring, vous devez l'obtenir par git submodule update --remote.

35
Nigiri