J'ai un référentiel Git qui contient plusieurs sous-modules. Comment répertorier les noms de tous les sous-modules après leur git submodule initexécution?

La git submodule foreachcommande pourrait faire écho aux noms du sous-module, mais cela ne fonctionne qu'une fois qu'ils ont été extraits, ce qui ne s'est pas produit après l'étape d'initialisation. Il y a plus d'étapes dans la chaîne qui doivent se produire avant de pouvoir les extraire, et je ne veux pas avoir à câbler les noms des sous-modules dans le script.

Existe-t-il une commande Git pour obtenir les noms de tous les sous-modules actuellement enregistrés, mais pas encore extraits?

Vous pouvez utiliser le même mécanisme que git submodule initlui-même, à savoir regarder .gitmodules. Ce fichier énumère chaque chemin de sous-module et l'URL à laquelle il se réfère.

Par exemple, à partir de la racine du référentiel, cat .gitmodulesimprimera le contenu à l'écran (en supposant que vous l'ayez cat).

Les fichiers .gitmodule ayant le format de configuration Git, vous pouvez utiliser git config pour analyser ces fichiers:

git config --file .gitmodules --name-only --get-regexp path

Vous montrerait toutes les entrées de sous-module, et avec

git config --file .gitmodules --get-regexp path | awk '{ print $2 }'

vous obtiendrez uniquement le chemin du sous-module lui-même.

Vous pouvez utiliser git submodule statusou facultativement git submodule status --recursivesi vous souhaitez afficher les sous-modules imbriqués.

Depuis la documentation de Git:

Affiche l'état des sous-modules. Cela affichera le SHA-1 de la validation actuellement extraite pour chaque sous-module, ainsi que le chemin du sous-module et la sortie de git pour le SHA-1. Chaque SHA-1 sera précédé de - si le sous-module n'est pas initialisé, + si la validation du sous-module actuellement extrait ne correspond pas au SHA-1 trouvé dans l'index du référentiel contenant et U si le sous-module a des conflits de fusion.

Pour renvoyer uniquement les noms des sous-modules enregistrés, vous pouvez utiliser cette commande:

grep path .gitmodules | sed 's/.*= //'

Pensez-y comme git submodule --listqui n'existe pas.

La commande suivante répertorie les sous-modules:

git submodule--helper list

La sortie est quelque chose comme ceci:

<mode> <sha1> <stage> <location>

Remarque: il nécessite Git 2.7.0 ou supérieur.

Utilisation:

$ git submodule

Il répertoriera tous les sous-modules dans le référentiel Git spécifié.

J'utilise ceci:

git config --list|egrep ^submodule

J'ai remarqué que la commande fournie dans une réponse à cette question m'a donné les informations que je cherchais:

Aucun mappage de sous-module trouvé dans .gitmodule pour un chemin qui n'est pas un sous-module

git ls-files --stage | grep 160000

Si cela ne vous dérange pas d'opérer uniquement sur des sous-modules initialisés, vous pouvez utiliser git submodule foreachpour éviter l'analyse de texte.

git submodule foreach --quiet 'echo $name'

Vous pouvez utiliser:

git submodule | awk '{ print $2 }'

J'utilise celui-ci:

git submodule status | cut -d' ' -f3-4 

Sortie (chemin + version):

tools/deploy_utils (0.2.4)

Pour répertorier tous les sous-modules par nom:

git submodule --quiet foreach --recursive 'echo $name'

Cela a fonctionné pour moi:

git ls-files --stage | grep ^160000

Il est basé sur cet excellent article: Comprendre les sous-modules Git

Il faut lire grep ^160000.

Juste les chemins du sous - module s'il vous plaît, madame ...

git config --list | grep \^submodule | cut -f 2 -d .

Vendor/BaseModel
Vendor/ObjectMatcher
Vendor/OrderedDictionary
Vendor/_ObjC
Vendor/XCodeHelpers

👍🏼

git configpermet de spécifier un fichier de configuration.
Et .gitmodules est un fichier de configuration.

Ainsi, à l'aide de " utiliser l'espace comme délimiteur avec la commande cut ":

git config --file=.gitmodules --get-regexp ^^submodule.*\.path$ | cut -d " " -f 2

Cela ne listera que les chemins, un par sous-module déclaré.

Comme le souligne Tino dans les commentaires :

• Cela échoue pour les sous-modules contenant des espaces .

• les chemins de sous-module peuvent contenir des sauts de ligne , comme dans

  git submodule add https://github.com/hilbix/bashy.git "sub module"
    git mv 'sub module' $'sub\nmodule'
  

Comme alternative plus robuste, Tino propose:

git config -z --file .gitmodules --get-regexp '\.path$' | \
  sed -nz 's/^[^\n]*\n//p' | \
  tr '\0' '\n' 

Pour les chemins contenant des retours à la ligne (ils peuvent être créés avec git mv), laissez le | tr '\0' '\n'et utilisez quelque chose comme ... | while IFS='' read -d '' path; do ...pour un traitement ultérieur avec bash.
Cela nécessite un bash moderne qui comprend read -d ''(n'oubliez pas l'espace entre les deux -d and '').

Dans ma version de Git ^[1] , chaque sous-module Git a un nameet un path. Ils ne doivent pas nécessairement être les mêmes ^[2] . Obtenir les deux de manière fiable, sans vérifier d'abord les sous-modules ( git update --init), est un peu délicat de la magie du shell.

Obtenez une liste des sous-modules names

Je n'ai pas trouvé de moyen pour y parvenir en utilisant git configou toute autre gitcommande. Par conséquent, nous sommes de retour à regex .gitmodules(super laid). Mais il semble être quelque peu sûr car gitlimite l'espace de code possible autorisé pour le sous-module names. De plus, comme vous souhaitez probablement utiliser cette liste pour un traitement ultérieur du shell, la solution ci-dessous sépare les entrées avec NULL-bytes ( \0).

$ sed -nre \
  's/^\[submodule \"(.*)\"]$/\1\x0/p' \
  "$(git rev-parse --show-toplevel)/.gitmodules" \
| tr -d '\n' \
| xargs -0 -n1 printf "%b\0"

Et dans votre script:

#!/usr/bin/env bash

while IFS= read -rd '' submodule_name; do
  echo submodule name: "${submodule_name}"
done < <(
  sed -nre \
    's/^\[submodule \"(.*)\"]$/\1\x0/p' \
    "$(git rev-parse --show-toplevel)/.gitmodules" \
  | tr -d '\n' \
  | xargs -0 -n1 printf "%b\0"
)

Remarque : read -rd ''nécessite bashet ne fonctionnera pas avec sh.

Obtenez une liste des sous-modules paths

Dans mon approche , j'essaie pas de traiter la sortie git config --get-regexpavec awk, tr, sed, ... mais passe plutôt un zéro octet séparé retour à git config --get. C'est pour éviter les problèmes avec les nouvelles lignes, les espaces et autres caractères spéciaux (par exemple Unicode) dans le sous-module paths. De plus, comme vous souhaitez probablement utiliser cette liste pour un traitement ultérieur du shell, la solution ci-dessous sépare les entrées avec NULL-bytes ( \0).

$ git config --null --file .gitmodules --name-only --get-regexp '\.path$' \
| xargs -0 -n1 git config --null --file .gitmodules --get

Par exemple, dans un script Bash, vous pouvez alors:

#!/usr/bin/env bash

while IFS= read -rd '' submodule_path; do
  echo submodule path: "${submodule_path}"
done < <(
  git config --null --file .gitmodules --name-only --get-regexp '\.path$' \
  | xargs -0 -n1 git config --null --file .gitmodules --get
)

Remarque : read -rd ''nécessite bashet ne fonctionnera pas avec sh.

Notes de bas de page

^[1] Version Git

$ git --version
git version 2.22.0

^[2] Sous-module avec divergence nameetpath

Configurer le référentiel de test:

$ git init test-name-path
$ cd test-name-path/
$ git checkout -b master
$ git commit --allow-empty -m 'test'
$ git submodule add ./ submodule-name
Cloning into '/tmp/test-name-path/submodule-name'...
done.
$ ls
submodule-name

$ cat .gitmodules
[submodule "submodule-name"]
    path = submodule-name
    url = ./

Déplacer le sous-module pour faire nameet pathdiverger:

$ git mv submodule-name/ submodule-path

$ ls
submodule-path

$ cat .gitmodules
[submodule "submodule-name"]
    path = submodule-path
    url = ./

$ git config --file .gitmodules --get-regexp '\.path$'
submodule.submodule-name.path submodule-path

Essai

Configurer le référentiel de test:

$ git init test
$ cd test/
$ git checkout -b master
$ git commit --allow-empty -m 'test'
$
$ git submodule add ./ simplename
Cloning into '/tmp/test/simplename'...
done.
$
$ git submodule add ./ 'name with spaces'
Cloning into '/tmp/test/name with spaces'...
done.
$
$ git submodule add ./ 'future-name-with-newlines'
Cloning into '/tmp/test/future-name-with-newlines'...
done.
$ git mv future-name-with-newlines/ 'name
> with
> newlines'
$
$ git submodule add ./ 'name-with-unicode-💩'
Cloning into '/tmp/test/name-with-unicode-💩'...
done.
$
$ git submodule add ./ sub/folder/submodule
Cloning into '/tmp/test/sub/folder/submodule'...
done.
$
$ git submodule add ./ name.with.dots
Cloning into '/tmp/test/name.with.dots'...
done.
$
$ git submodule add ./ 'name"with"double"quotes'
Cloning into '/tmp/test/name"with"double"quotes'...
done.
$
$ git submodule add ./ "name'with'single'quotes"
Cloning into '/tmp/test/name'with'single'quotes''...
done.
$ git submodule add ./ 'name]with[brackets'
Cloning into '/tmp/test/name]with[brackets'...
done.
$ git submodule add ./ 'name-with-.path'
Cloning into '/tmp/test/name-with-.path'...
done.

.gitmodules:

[submodule "simplename"]
    path = simplename
    url = ./
[submodule "name with spaces"]
    path = name with spaces
    url = ./
[submodule "future-name-with-newlines"]
    path = name\nwith\nnewlines
    url = ./
[submodule "name-with-unicode-💩"]
    path = name-with-unicode-💩
    url = ./
[submodule "sub/folder/submodule"]
    path = sub/folder/submodule
    url = ./
[submodule "name.with.dots"]
    path = name.with.dots
    url = ./
[submodule "name\"with\"double\"quotes"]
    path = name\"with\"double\"quotes
    url = ./
[submodule "name'with'single'quotes"]
    path = name'with'single'quotes
    url = ./
[submodule "name]with[brackets"]
    path = name]with[brackets
    url = ./
[submodule "name-with-.path"]
    path = name-with-.path
    url = ./

Obtenir la liste des sous-modules names

$ sed -nre \
  's/^\[submodule \"(.*)\"]$/\1\x0/p' \
  "$(git rev-parse --show-toplevel)/.gitmodules" \
| tr -d '\n' \
| xargs -0 -n1 printf "%b\0" \
| xargs -0 -n1 echo submodule name:
submodule name: simplename
submodule name: name with spaces
submodule name: future-name-with-newlines
submodule name: name-with-unicode-💩
submodule name: sub/folder/submodule
submodule name: name.with.dots
submodule name: name"with"double"quotes
submodule name: name'with'single'quotes
submodule name: name]with[brackets
submodule name: name-with-.path

Obtenir la liste des sous-modules paths

$ git config --null --file .gitmodules --name-only --get-regexp '\.path$' \
| xargs -0 -n1 git config --null --file .gitmodules --get \
| xargs -0 -n1 echo submodule path:
submodule path: simplename
submodule path: name with spaces
submodule path: name
with
newlines
submodule path: name-with-unicode-💩
submodule path: sub/folder/submodule
submodule path: name.with.dots
submodule path: name"with"double"quotes
submodule path: name'with'single'quotes
submodule path: name]with[brackets
submodule path: name-with-.path

S'il n'y a pas de .gitmodulesfichier, mais une configuration de sous-modules existe dans .git/modules/:

find .git/modules/ -name config -exec grep url {} \;

Voici une autre façon d'analyser les noms de sous-modules Git à partir de .gitmodules sans avoir besoin de paramètres IFS sed ou fantaisie. :-)

#!/bin/env bash

function stripStartAndEndQuotes {
  temp="${1%\"}"
  temp="${temp#\"}"
  echo "$temp"
}

function getSubmoduleNames {
  line=$1
  len=${#line} # Get line length
  stripStartAndEndQuotes "${line::len-1}" # Remove last character
}

while read line; do
  getSubmoduleNames "$line"
done < <(cat .gitmodules | grep "\[submodule.*\]" | cut -d ' ' -f 2-)