Come trovare tutti i repository git all'interno di determinate cartelle (velocemente)

L'approccio ingenuo è find dir1 dir2 dir3 -type d -name .git | xargs -I {} dirname {} , ma è troppo lento per me, perché ho strutture di cartelle molto profonde all'interno dei repository git (almeno penso che questo sia il motivo). Ho letto che posso usare pruneper impedire a find di ricorrere nelle directory una volta che ha trovato qualcosa, ma ci sono due cose. Non sono sicuro di come prunefunzioni (voglio dire, non capisco cosa funziona nonostante abbia letto la pagina man) e il secondo non funzionerebbe nel mio caso, perché impedirebbe finddi ricorrere nella .gitcartella ma non in tutto altre cartelle.

Quindi quello di cui ho davvero bisogno è:

per tutte le sottodirectory controllare se contengono una .gitcartella e se è quindi interrompere la ricerca in questo ramo del filesystem e riportare il risultato. Sarebbe perfetto se questo escludesse anche qualsiasi directory nascosta dalla ricerca.

D'accordo, non sono ancora del tutto sicuro di come funzioni, ma l'ho provato e funziona.

.
├── a
│   ├── .git
│   └── a
│       └── .git
└── b
    └── .git

6 directories, 0 files

% find . -type d -exec test -e '{}/.git' ';' -print -prune
./a
./b

Non vedo l'ora di fare lo stesso più velocemente.

Possibile soluzione

Per GNU finde altre implementazioni che supportano -execdir:

find dir1 dir2 dir3 -type d -execdir test -d '.git' \; -print -prune

(vedi i commenti)

Roba precedentemente discussa

Soluzione se la potatura di seguito .gitè sufficiente

find dir1 dir2 dir3 -type d -path '*/.git' -print -prune | xargs -I {} dirname {}

Se -printf '%h'è supportato (come nel caso di GNU find) non abbiamo bisogno di dirname:

find dir1 dir2 dir3 -type d -path '*/.git' -printf '%h\n' -prune

Una volta che incontra una cartella .gitnel percorso corrente, la emetterà e poi smetterà di guardare più in basso nella sottostruttura.

Soluzione se è necessario eliminare l'intero albero delle cartelle una volta .gittrovato a

Usando -quitse findlo supporta:

for d in dir1 dir2 dir3; do
  find "$d" -type d -name .git -print -quit
done | xargs -I {} dirname {}

(Secondo questo post dettagliato di Stéphane Chazelas -quit è supportato in GNU e FreeBSD finde in NetBSD come -exit.)

Ancora con -printf '%h'se supportato:

for d in dir1 dir2 dir3; do
  find "$d" -type d -name .git -printf '%h\n' -quit
done

Soluzione per la potatura allo stesso livello della .gitcartella

Vedere la parte "Soluzione possibile" per la soluzione corrente per questo particolare problema.

(Oh, e ovviamente le soluzioni che usano xargspresuppongono che non ci siano nuove linee nei percorsi, altrimenti avresti bisogno di magia a byte zero.)

Idealmente, si desidera eseguire la scansione degli alberi di directory per le directory che contengono una .gitvoce e interrompere la ricerca più in basso (supponendo che non si disponga di ulteriori repository git all'interno dei repository git).

Il problema è che con lo standard find, fare questo tipo di controllo (che una directory contenga una .gitvoce) implica la generazione di un processo che esegue testun'utilità usando il -execpredicato, che sarà meno efficiente rispetto all'elenco del contenuto di alcune directory.

Un'eccezione sarebbe se si utilizza l' findintegrato della boshshell (un fork POSIXified della shell Bourne sviluppato da @schily ) che ha un -callpredicato per valutare il codice nella shell senza dover generare un nuovo interprete sh:

#! /path/to/bosh
find . -name '.?*' -prune -o \
  -type d -call '[ -e "$1/.git" ]' {} \; -prune -print

O l'uso perl's File::Find:

perl -MFile::Find -le '
  sub wanted {
    if (/^\../) {$File::Find::prune = 1; return}
    if (-d && -e "$_/.git") {
       print $File::Find::name; $File::Find::prune = 1
    }
  }; find \&wanted, @ARGV' .

Più a lungo, ma più veloce di zsh's printf '%s\n' **/.git(:h)(che scende in tutte le directory non nascoste), o GNU find' s find . -name '.?*' -prune -o -type d -exec test -e '{}/.git' \; -prune -printche corre un testcomando in un nuovo processo per ogni directory non nascoste.

Se si utilizza individuare, è possibile trovare directory con:

locate .git | grep "/.git$"

L'elenco dei risultati è veloce e anche l'elaborazione ulteriore è facile.

Uso

find ~/GIT-REPOSITORIES \( -exec test -d '{}'/.git \; \) -print -prune

timequesto, per vedere la differenza con e senza -prune.

Questo si basa su una soluzione in man find. È possibile modificare il CVSe svnse non richiesto. segue il contenuto della pagina man

find repo/ \( -exec test -d '{}'/.svn \; -or \
       -exec test -d {}/.git \; -or -exec test -d {}/CVS \; \) \
       -print -prune

Dato il seguente elenco di progetti e le relative directory amministrative SCM, eseguire una ricerca efficiente delle radici dei progetti:

repo/project1/CVS
repo/gnu/project2/.svn
repo/gnu/project3/.svn
repo/gnu/project3/src/.svn
repo/project4/.git

In questo esempio, -pruneimpedisce la discesa non necessaria nelle directory che sono già state scoperte (ad esempio, non effettuiamo ricerche project3/src, perché abbiamo già trovato project3/.svn), ma assicura project2che project3vengano trovate le directory dei fratelli ( e ).