Tengo un repositorio de Git que tiene varios submódulos. ¿Cómo enumero los nombres de todos los submódulos después de que git submodule initse haya ejecutado?

El git submodule foreachcomando podría hacer eco de los nombres del submódulo, pero eso solo funciona una vez que se han desprotegido, lo que no sucedió después del paso de inicio. Hay más pasos en la cadena que deben suceder antes de que se puedan verificar, y no quiero tener que conectar los nombres de submódulos al script.

Entonces, ¿hay un comando Git para obtener los nombres de todos los submódulos actualmente registrados, pero aún no desprotegidos?

Podrías usar el mismo mecanismo que se git submodule initusa, es decir, mirar .gitmodules. Estos archivos enumeran cada ruta de submódulo y la URL a la que se refiere.

Por ejemplo, desde la raíz del repositorio, cat .gitmodulesimprimirá el contenido en la pantalla (suponiendo que lo haya hecho cat).

Debido a que los archivos .gitmodule tienen el formato de configuración Git, puede usar git config para analizar esos archivos:

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

Le mostraría todas las entradas de submódulos y con

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

solo obtendría la ruta del submódulo en sí.

Puede usar git submodule statusu opcionalmente git submodule status --recursivesi desea mostrar submódulos anidados.

De la documentación de Git:

Mostrar el estado de los submódulos. Esto imprimirá el SHA-1 del commit actualmente desprotegido para cada submódulo, junto con la ruta del submódulo y la salida de git describe para el SHA-1. Cada SHA-1 tendrá como prefijo: si el submódulo no se inicializa, + si la confirmación del submódulo actualmente desprotegido no coincide con el SHA-1 encontrado en el índice del repositorio que contiene y U si el submódulo tiene conflictos de fusión.

Para devolver solo los nombres de los submódulos registrados, puede usar este comando:

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

Piense en ello como git submodule --listsi no existiera.

El siguiente comando enumerará los submódulos:

git submodule--helper list

El resultado es algo como esto:

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

Nota: Requiere Git 2.7.0 o superior.

Utilizar:

$ git submodule

Enumerará todos los submódulos en el repositorio Git especificado.

Yo uso esto:

git config --list|egrep ^submodule

Noté que el comando proporcionado en una respuesta a esta pregunta me dio la información que estaba buscando:

No se encontró asignación de submódulo en .gitmodule para una ruta que no sea un submódulo

git ls-files --stage | grep 160000

Si no le importa operar solo en submódulos inicializados, puede usar git submodule foreachpara evitar el análisis de texto.

git submodule foreach --quiet 'echo $name'

Puedes usar:

git submodule | awk '{ print $2 }'

Yo uso este:

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

Salida (ruta + versión):

tools/deploy_utils (0.2.4)

Para enumerar todos los submódulos por nombre:

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

Esto funcionó para mí:

git ls-files --stage | grep ^160000

Se basa en este gran artículo: Comprender los submódulos de Git

Se debe leer grep ^160000.

Solo los submódulos, por favor, señora ...

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

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

👍🏼

git configpermite especificar un archivo de configuración.
Y .gitmodules es un archivo de configuración.

Entonces, con la ayuda de " usar el espacio como delimitador con comando de corte ":

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

Eso enumerará solo las rutas, una por submódulo declarado.

Como Tino señala en los comentarios :

• Esto falla para submódulos con espacios en él.

• las rutas de submódulos pueden contener nuevas líneas , como en

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

Como una alternativa más robusta, Tino propone:

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

Para rutas con nuevas líneas en ellas (se pueden crear con git mv), deje de lado | tr '\0' '\n'y use algo como ... | while IFS='' read -d '' path; do ...para un mayor procesamiento con bash.
Esto necesita una fiesta moderna que comprenda read -d ''(no olvide el espacio entre -d and '').

En mi versión de Git ^[1] , cada submódulo Git tiene a namey a path. No necesariamente tienen que ser iguales ^[2] . Obtener ambos de una manera confiable, sin consultar primero los submódulos ( git update --init), es un poco complicado de hechicería.

Obtenga una lista de submódulos names

No encontré una manera de lograr esto usando git configo cualquier otro gitcomando. Por lo tanto, volvemos a regex on .gitmodules(super feo). Pero parece ser algo seguro ya que gitlimita el posible espacio de código permitido para el submódulo names. Además, dado que probablemente desee utilizar esta lista para el procesamiento posterior del shell, la solución debajo de las entradas separadas con 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"

Y en tu guión:

#!/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"
)

Nota : read -rd ''requiere bashy no funcionará con sh.

Obtenga una lista de submódulos paths

En mi enfoque Intento no para procesar la salida de git config --get-regexpla awk, tr, sed, ... sino que lo pase un byte cero separó de nuevo a git config --get. Esto es para evitar problemas con las nuevas líneas, espacios y otros caracteres especiales (por ejemplo, Unicode) en el submódulo paths. Además, dado que probablemente desee utilizar esta lista para el procesamiento posterior del shell, la solución debajo de las entradas separadas con NULL-bytes ( \0).

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

Por ejemplo, en una secuencia de comandos Bash, podría:

#!/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
)

Nota : read -rd ''requiere bashy no funcionará con sh.

Notas al pie

^[1] Versión Git

$ git --version
git version 2.22.0

^[2] Submódulo con divergencia nameypath

Configurar el repositorio de prueba:

$ 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 = ./

Mueva el submódulo para crear namey pathdivergir:

$ 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

Pruebas

Configurar el repositorio de prueba:

$ 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 = ./

Obtener lista de submódulo 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

Obtener lista de submódulo 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

Si no hay ningún .gitmodulesarchivo, pero existe una configuración de submódulos en .git/modules/:

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

Aquí hay otra forma de analizar los nombres de submódulos Git desde .gitmodules sin la necesidad de configuraciones sed o sofisticadas de IFS. :-)

#!/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-)