Eu tenho um repositório Git que possui vários submódulos. Como listar os nomes de todos os submódulos após a git submodule initexecução?

O git submodule foreachcomando poderia ecoar os nomes do submódulo, mas isso só funciona depois que eles foram retirados, o que não aconteceu após a etapa init. Há mais etapas na cadeia que precisam acontecer antes que possam ser verificadas, e não quero ter que conectar os nomes dos submódulos ao script.

Existe um comando Git para obter os nomes de todos os submódulos registrados atualmente, mas ainda não verificados?

Você pode usar o mesmo mecanismo que o git submodule initpróprio usa, ou seja, observe .gitmodules. Esses arquivos enumeram cada caminho do sub-módulo e a URL a que se refere.

Por exemplo, a partir da raiz do repositório, cat .gitmodulesimprimirá o conteúdo na tela (supondo que você tenha cat).

Como os arquivos .gitmodule têm o formato de configuração Git, você pode usar o git config para analisar esses arquivos:

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

Mostraria todas as entradas do submódulo e com

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

você apenas obteria o próprio caminho do submódulo.

Você pode usar git submodule statusou, opcionalmente, git submodule status --recursivese desejar mostrar submódulos aninhados.

Na documentação do Git:

Mostrar o status dos submódulos. Isso imprimirá o SHA-1 da confirmação atualmente registrada para cada submódulo, junto com o caminho do submódulo e a saída do git description para o SHA-1. Cada SHA-1 será prefixado com - se o submódulo não for inicializado, + se a confirmação do submódulo com check-out atualmente não corresponder ao SHA-1 encontrado no índice do repositório que contém e U se o submódulo tiver conflitos de mesclagem.

Para retornar apenas os nomes dos submódulos registrados, você pode usar este comando:

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

Pense nisso como o git submodule --listque não existe.

O comando a seguir listará os submódulos:

git submodule--helper list

A saída é algo como isto:

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

Nota: Requer Git 2.7.0 ou superior.

Usar:

$ git submodule

Ele listará todos os submódulos no repositório Git especificado.

Eu uso isso:

git config --list|egrep ^submodule

Percebi que o comando fornecido em resposta a esta pergunta me deu as informações que eu estava procurando:

Nenhum mapeamento de submódulo encontrado no .gitmodule para um caminho que não é um submódulo

git ls-files --stage | grep 160000

Se você não se importa de operar apenas em submódulos inicializados, pode usar git submodule foreachpara evitar a análise de texto.

git submodule foreach --quiet 'echo $name'

Você pode usar:

git submodule | awk '{ print $2 }'

Eu uso este:

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

Saída (caminho + versão):

tools/deploy_utils (0.2.4)

Para listar todos os submódulos por nome:

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

Isso funcionou para mim:

git ls-files --stage | grep ^160000

Ele é baseado neste excelente artigo: Entendendo os submódulos do Git

Deve ler grep ^160000.

Apenas os caminhos do submódulo, por favor, senhora ...

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

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

👍🏼

git configpermite especificar um arquivo de configuração.
E .gitmodules é um arquivo de configuração.

Portanto, com a ajuda de " use o espaço como um delimitador com o comando cut ":

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

Isso listará apenas os caminhos, um por sub-módulo declarado.

Como Tino aponta nos comentários :

• Isso falha para submódulos com espaços nele.

• caminhos do submódulo podem conter novas linhas , como em

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

Como uma alternativa mais robusta, Tino propõe:

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

Para caminhos com novas linhas (eles podem ser criados com git mv), deixe o | tr '\0' '\n'e use algo como ... | while IFS='' read -d '' path; do ...para processamento adicional com o bash.
Isso precisa de uma festança moderna que entenda read -d ''(não esqueça o espaço entre elas -d and '').

Na minha versão do Git ^[1] , todo submódulo do Git possui a namee a path. Eles não precisam necessariamente ser os mesmos ^[2] . Obter os dois de maneira confiável, sem verificar primeiro os submódulos ( git update --init), é um pouco complicado de assistente de shell.

Obter uma lista do submódulo names

Não encontrei uma maneira de conseguir isso usando git configou qualquer outro gitcomando. Portanto, estamos de volta à regex em .gitmodules(super feia). Mas parece ser um pouco seguro, pois gitlimita o possível espaço de código permitido para o submódulo names. Além disso, como você provavelmente deseja usar esta lista para processamento de shell adicional, a solução abaixo separa as entradas com 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"

E no seu 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"
)

Nota : read -rd ''requer bashe não funcionará sh.

Obter uma lista do submódulo paths

Na minha abordagem que eu tente não para processar a saída git config --get-regexpcom awk, tr, sed, ... mas em vez passá-lo a zero bytes separados de volta para git config --get. Isso é para evitar problemas com novas linhas, espaços e outros caracteres especiais (por exemplo, Unicode) no submódulo paths. Além disso, como você provavelmente deseja usar esta lista para processamento de shell adicional, a solução abaixo separa as entradas com NULL-bytes ( \0).

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

Por exemplo, em um script Bash, você pode:

#!/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 ''requer bashe não funcionará sh.

Notas de rodapé

^[1] versão Git

$ git --version
git version 2.22.0

^[2] Submódulo com divergentes nameepath

Configure o repositório de teste:

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

Mova o submódulo para criar namee 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

Teste

Configure o repositório de teste:

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

Obter 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

Obter 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

Se não houver nenhum .gitmodulesarquivo, mas existir uma configuração de submódulos em .git/modules/:

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

Aqui está outra maneira de analisar nomes de submodulos Git de .gitmodules sem a necessidade de configurações IFS sed ou sofisticadas. :-)

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