Ich habe ein Git-Repository, das mehrere Submodule enthält. Wie liste ich die Namen aller Submodule auf, nachdem git submodule initsie ausgeführt wurden?

Der git submodule foreachBefehl könnte die Namen des Submoduls wiedergeben, dies funktioniert jedoch nur, wenn sie ausgecheckt wurden, was nach dem Init-Schritt nicht geschehen ist. Es gibt weitere Schritte in der Kette, die ausgeführt werden müssen, bevor sie ausgecheckt werden können, und ich möchte nicht die Namen von Submodulen fest in das Skript einbinden müssen.

Gibt es also einen Git-Befehl, um die Namen aller aktuell registrierten, aber noch nicht ausgecheckten Submodule abzurufen?

Sie könnten den gleichen Mechanismus verwenden wie git submodule initsich selbst, nämlich betrachten .gitmodules. Diese Datei listet jeden Submodulpfad und die URL auf, auf die er verweist.

Beispielsweise werden vom Stammverzeichnis des Repositorys cat .gitmodulesInhalte auf dem Bildschirm gedruckt (vorausgesetzt, Sie haben dies getan cat).

Da Gitmodule-Dateien das Git-Konfigurationsformat haben, können Sie diese Dateien mit git config analysieren:

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

Würde dir alle Submoduleinträge zeigen, und mit

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

Sie würden nur den Submodulpfad selbst erhalten.

Sie können git submodule statusoder optional verwenden, git submodule status --recursivewenn Sie verschachtelte Submodule anzeigen möchten.

Aus der Git-Dokumentation:

Zeigt den Status der Submodule an. Dies druckt die SHA-1 des aktuell ausgecheckten Commits für jedes Submodul zusammen mit dem Submodulpfad und der Ausgabe von git, die für die SHA-1 beschrieben wird. Jedem SHA-1 wird ein Präfix vorangestellt - wenn das Submodul nicht initialisiert ist, + wenn das aktuell ausgecheckte Submodul-Commit nicht mit dem SHA-1 übereinstimmt, das im Index des enthaltenen Repositorys gefunden wurde, und U, wenn das Submodul Zusammenführungskonflikte aufweist.

Mit diesem Befehl können Sie nur die Namen der registrierten Submodule zurückgeben:

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

Betrachten Sie es als das, git submodule --listwas es nicht gibt.

Der folgende Befehl listet die Submodule auf:

git submodule--helper list

Die Ausgabe ist ungefähr so:

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

Hinweis: Es erfordert Git 2.7.0 oder höher.

Verwenden:

$ git submodule

Es werden alle Submodule im angegebenen Git-Repository aufgelistet.

Ich benutze das:

git config --list|egrep ^submodule

Ich bemerkte, dass der Befehl in einer Antwort auf diese Frage mir die Informationen gab, nach denen ich suchte:

In .gitmodule wurde keine Submodulzuordnung für einen Pfad gefunden, der kein Submodul ist

git ls-files --stage | grep 160000

Wenn es Ihnen nichts ausmacht, nur mit initialisierten Submodulen zu arbeiten, können Sie das git submodule foreachParsen von Text vermeiden.

git submodule foreach --quiet 'echo $name'

Sie können verwenden:

git submodule | awk '{ print $2 }'

Ich benutze dieses:

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

Ausgabe (Pfad + Version):

tools/deploy_utils (0.2.4)

So listen Sie alle Submodule nach Namen auf:

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

Das hat bei mir funktioniert:

git ls-files --stage | grep ^160000

Es basiert auf diesem großartigen Artikel: Git-Submodule verstehen

Es muss lesen grep ^160000.

Nur die Submodulpfade bitte, Ma'am ...

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

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

👍🏼

git configermöglicht die Angabe einer Konfigurationsdatei.
Und .gitmodules ist eine Konfigurationsdatei.

Also, mit Hilfe von " Leerzeichen als Trennzeichen mit Befehl cut verwenden ":

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

Dadurch werden nur die Pfade aufgelistet, einer pro deklariertem Submodul.

Wie Tino weist darauf hin , in den Kommentaren :

• Dies schlägt für Submodule mit Leerzeichen fehl .

• Submodulpfade können Zeilenumbrüche enthalten , wie in

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

Als robustere Alternative schlägt Tino vor:

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

Lassen Sie für Pfade mit Zeilenumbrüchen (mit denen sie erstellt werden können git mv) das weg | tr '\0' '\n'und verwenden Sie so etwas wie ... | while IFS='' read -d '' path; do ...für die weitere Verarbeitung mit bash.
Dies erfordert eine moderne Bash, die versteht read -d ''(vergessen Sie nicht den Raum dazwischen -d and '').

In meiner Version von Git ^[1] hat jedes Git-Submodul ein nameund ein path. Sie müssen nicht unbedingt gleich sein ^[2] . Beides auf zuverlässige Weise zu erhalten, ohne zuerst die Submodule zu überprüfen ( git update --init), ist eine schwierige Aufgabe der Shell-Zauberei.

Holen Sie sich eine Liste der Submodule names

Ich habe keinen Weg gefunden, dies mit git configeinem anderen gitBefehl zu erreichen. Deshalb sind wir wieder bei Regex .gitmodules(super hässlich). Es scheint jedoch etwas sicher zu sein, da gitder mögliche Codebereich für das Submodul begrenzt ist names. Da Sie diese Liste wahrscheinlich für die weitere Shell-Verarbeitung verwenden möchten, werden in der folgenden Lösung Einträge mit NULL-bytes ( \0) getrennt.

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

Und in Ihrem Skript:

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

Hinweis : read -rd ''erfordert bashund funktioniert nicht mit sh.

Holen Sie sich eine Liste der Submodule paths

In meinem Ansatz versuche ich nicht die Ausgabe von zu verarbeiten git config --get-regexpmit awk, tr, sed, ... , sondern gebe es einen Null - Byte wieder getrennt git config --get. Dies dient dazu, Probleme mit Zeilenumbrüchen, Leerzeichen und anderen Sonderzeichen (z. B. Unicode) im Submodul zu vermeiden paths. Da Sie diese Liste wahrscheinlich für die weitere Shell-Verarbeitung verwenden möchten, werden in der folgenden Lösung Einträge mit NULL-bytes ( \0) getrennt.

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

In einem Bash-Skript könnten Sie beispielsweise Folgendes tun:

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

Hinweis : read -rd ''erfordert bashund funktioniert nicht mit sh.

Fußnoten

^[1] Git-Version

$ git --version
git version 2.22.0

^[2] Submodul mit divergierenden nameundpath

Test-Repository einrichten:

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

Verschieben Sie das Submodul, um Folgendes zu erstellen nameund zu pathtrennen:

$ 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

Testen

Test-Repository einrichten:

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

Liste der Submodule abrufen 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

Liste der Submodule abrufen 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

Wenn keine .gitmodulesDatei vorhanden ist, aber eine Submodulkonfiguration vorhanden ist in .git/modules/:

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

Hier ist eine andere Möglichkeit, Git-Submodulnamen aus .gitmodules zu analysieren, ohne dass sed oder ausgefallene IFS-Einstellungen erforderlich sind. :-)

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