Come posso ottenere `find` per ignorare le directory .svn?

Uso spesso il findcomando per cercare nel codice sorgente, eliminare i file, qualunque cosa. Stranamente, poiché Subversion memorizza i duplicati di ogni file nelle sue .svn/text-base/directory, le mie semplici ricerche finiscono per ottenere molti risultati duplicati. Ad esempio, voglio cercare ricorsivamente uintin più messages.he messages.cppfile:

# find -name 'messages.*' -exec grep -Iw uint {} +
./messages.cpp:            Log::verbose << "Discarding out of date message: id " << uint(olderMessage.id)
./messages.cpp:    Log::verbose << "Added to send queue: " << *message << ": id " << uint(preparedMessage->id)
./messages.cpp:                Log::error << "Received message with invalid SHA-1 hash: id " << uint(incomingMessage.id)
./messages.cpp:            Log::verbose << "Received " << *message << ": id " << uint(incomingMessage.id)
./messages.cpp:            Log::verbose << "Sent message: id " << uint(preparedMessage->id)
./messages.cpp:        Log::verbose << "Discarding unsent message: id " << uint(preparedMessage->id)
./messages.cpp:        for (uint i = 0; i < 10 && !_stopThreads; ++i) {
./.svn/text-base/messages.cpp.svn-base:            Log::verbose << "Discarding out of date message: id " << uint(olderMessage.id)
./.svn/text-base/messages.cpp.svn-base:    Log::verbose << "Added to send queue: " << *message << ": id " << uint(preparedMessage->id)
./.svn/text-base/messages.cpp.svn-base:                Log::error << "Received message with invalid SHA-1 hash: id " << uint(incomingMessage.id)
./.svn/text-base/messages.cpp.svn-base:            Log::verbose << "Received " << *message << ": id " << uint(incomingMessage.id)
./.svn/text-base/messages.cpp.svn-base:            Log::verbose << "Sent message: id " << uint(preparedMessage->id)
./.svn/text-base/messages.cpp.svn-base:        Log::verbose << "Discarding unsent message: id " << uint(preparedMessage->id)
./.svn/text-base/messages.cpp.svn-base:        for (uint i = 0; i < 10 && !_stopThreads; ++i) {
./virus/messages.cpp:void VsMessageProcessor::_progress(const string &fileName, uint scanCount)
./virus/messages.cpp:ProgressMessage::ProgressMessage(const string &fileName, uint scanCount)
./virus/messages.h:    void _progress(const std::string &fileName, uint scanCount);
./virus/messages.h:    ProgressMessage(const std::string &fileName, uint scanCount);
./virus/messages.h:    uint        _scanCount;
./virus/.svn/text-base/messages.cpp.svn-base:void VsMessageProcessor::_progress(const string &fileName, uint scanCount)
./virus/.svn/text-base/messages.cpp.svn-base:ProgressMessage::ProgressMessage(const string &fileName, uint scanCount)
./virus/.svn/text-base/messages.h.svn-base:    void _progress(const std::string &fileName, uint scanCount);
./virus/.svn/text-base/messages.h.svn-base:    ProgressMessage(const std::string &fileName, uint scanCount);
./virus/.svn/text-base/messages.h.svn-base:    uint        _scanCount;

Come posso dire finddi ignorare le .svndirectory?

Aggiornamento : se aggiorni il tuo client SVN alla versione 1.7 questo non è più un problema.

Una caratteristica chiave delle modifiche introdotte in Subversion 1.7 è la centralizzazione dell'archiviazione dei metadati di copia funzionante in un'unica posizione. Invece di una .svndirectory in ogni directory nella copia di lavoro, le copie di lavoro di Subversion 1.7 hanno solo una .svndirectory nella radice della copia di lavoro. Questa directory include (tra le altre cose) un database supportato da SQLite che contiene tutti i metadati necessari a Subversion per quella copia di lavoro.

Per la ricerca, posso suggerirti di guardare ack ? È a conoscenza del codice sorgente finde come tale ignorerà automaticamente molti tipi di file, incluse le informazioni sul repository del codice sorgente come quelle sopra.

perché non solo

find . -not -iwholename '*.svn*'

Il predicato -not nega tutto ciò che ha .svn in qualsiasi punto del percorso.

Quindi nel tuo caso lo sarebbe

find -not -iwholename '*.svn*' -name 'messages.*' -exec grep -Iw uint {} + \;

Come segue:

find . -path '*/.svn*' -prune -o -print

Oppure, in base a una directory e non a un prefisso percorso:

find . -name .svn -a -type d -prune -o -print

Per ignorare .svn, .gite altre directory nascosti (che iniziano con un punto), provare:

find . -type f -not -path '*/\.*'

Tuttavia, se lo scopo dell'utilizzo findè la ricerca all'interno dei file, è possibile provare a utilizzare questi comandi:

• git grep - comando appositamente progettato per la ricerca di schemi all'interno del repository Git.
• ripgrep- che per impostazione predefinita ignora i file nascosti e i file specificati in .gitignore.

Correlati: Come posso trovare tutti i file contenenti testo specifico su Linux?

Ecco cosa farei nel tuo caso:

find . -path .svn -prune -o -name messages.* -exec grep -Iw uint {} +

Il rgrepcomando integrato di Emacs ignora la .svndirectory e molti altri file che probabilmente non ti interessano quando esegui un file find | grep. Ecco cosa utilizza per impostazione predefinita:

find . \( -path \*/SCCS -o -path \*/RCS -o -path \*/CVS -o -path \*/MCVS \
          -o -path \*/.svn -o -path \*/.git -o -path \*/.hg -o -path \*/.bzr \
          -o -path \*/_MTN -o -path \*/_darcs -o -path \*/\{arch\} \) \
     -prune -o \
       \( -name .\#\* -o -name \*.o -o -name \*\~ -o -name \*.bin -o -name \*.lbin \
          -o -name \*.so -o -name \*.a -o -name \*.ln -o -name \*.blg \
          -o -name \*.bbl -o -name \*.elc -o -name \*.lof -o -name \*.glo \
          -o -name \*.idx -o -name \*.lot -o -name \*.fmt -o -name \*.tfm \
          -o -name \*.class -o -name \*.fas -o -name \*.lib -o -name \*.mem \
          -o -name \*.x86f -o -name \*.sparcf -o -name \*.fasl -o -name \*.ufsl \
          -o -name \*.fsl -o -name \*.dxl -o -name \*.pfsl -o -name \*.dfsl \
          -o -name \*.p64fsl -o -name \*.d64fsl -o -name \*.dx64fsl -o -name \*.lo \
          -o -name \*.la -o -name \*.gmo -o -name \*.mo -o -name \*.toc \
          -o -name \*.aux -o -name \*.cp -o -name \*.fn -o -name \*.ky \
          -o -name \*.pg -o -name \*.tp -o -name \*.vr -o -name \*.cps \
          -o -name \*.fns -o -name \*.kys -o -name \*.pgs -o -name \*.tps \
          -o -name \*.vrs -o -name \*.pyc -o -name \*.pyo \) \
     -prune -o \
     -type f \( -name pattern \) -print0 \
     | xargs -0 -e grep -i -nH -e regex

Ignora le directory create dalla maggior parte dei sistemi di controllo della versione, nonché i file generati per molti linguaggi di programmazione. È possibile creare un alias che richiama questo comando e sostituire finde grepschemi per i problemi specifici.

GNU find

find .  ! -regex ".*[/]\.svn[/]?.*"

Uso grep per questo scopo. Metti questo nel tuo ~ / .bashrc

export GREP_OPTIONS="--binary-files=without-match --color=auto --devices=skip --exclude-dir=CVS --exclude-dir=.libs --exclude-dir=.deps --exclude-dir=.svn"

grep utilizza automaticamente queste opzioni durante l'invocazione

find . | grep -v \.svn

Perché non convogliare il tuo comando con grep che è facilmente comprensibile:

your find command| grep -v '\.svn'

Crea uno script chiamato ~/bin/svnfind:

#!/bin/bash
#
# Attempts to behave identically to a plain `find' command while ignoring .svn/
# directories.

OPTIONS=()
PATHS=()
EXPR=()

while [[ $1 =~ ^-[HLP]+ ]]; do
    OPTIONS+=("$1")
    shift
done

while [[ $# -gt 0 ]] && ! [[ $1 =~ '^[-(),!]' ]]; do
    PATHS+=("$1")
    shift
done

# If user's expression contains no action then we'll add the normally-implied
# `-print'.
ACTION=-print

while [[ $# -gt 0 ]]; do
    case "$1" in
       -delete|-exec|-execdir|-fls|-fprint|-fprint0|-fprintf|-ok|-print|-okdir|-print0|-printf|-prune|-quit|-ls)
            ACTION=;;
    esac

    EXPR+=("$1")
    shift
done

if [[ ${#EXPR} -eq 0 ]]; then
    EXPR=(-true)
fi

exec -a "$(basename "$0")" find "${OPTIONS[@]}" "${PATHS[@]}" -name .svn -type d -prune -o '(' "${EXPR[@]}" ')' $ACTION

Questo script si comporta in modo identico a un semplice findcomando ma elimina le .svndirectory. Altrimenti il ​​comportamento è identico.

Esempio:

# svnfind -name 'messages.*' -exec grep -Iw uint {} +
./messages.cpp:            Log::verbose << "Discarding out of date message: id " << uint(olderMessage.id)
./messages.cpp:    Log::verbose << "Added to send queue: " << *message << ": id " << uint(preparedMessage->id)
./messages.cpp:                Log::error << "Received message with invalid SHA-1 hash: id " << uint(incomingMessage.id)
./messages.cpp:            Log::verbose << "Received " << *message << ": id " << uint(incomingMessage.id)
./messages.cpp:            Log::verbose << "Sent message: id " << uint(preparedMessage->id)
./messages.cpp:        Log::verbose << "Discarding unsent message: id " << uint(preparedMessage->id)
./messages.cpp:        for (uint i = 0; i < 10 && !_stopThreads; ++i) {
./virus/messages.cpp:void VsMessageProcessor::_progress(const string &fileName, uint scanCount)
./virus/messages.cpp:ProgressMessage::ProgressMessage(const string &fileName, uint scanCount)
./virus/messages.h:    void _progress(const std::string &fileName, uint scanCount);
./virus/messages.h:    ProgressMessage(const std::string &fileName, uint scanCount);
./virus/messages.h:    uint        _scanCount;

Ho solo pensato di aggiungere una semplice alternativa ai post di Kaleb e di altri (che descrivevano in dettaglio l'uso find -prunedell'opzione ack, dei repofindcomandi , ecc.) Che è particolarmente applicabile all'uso che hai descritto nella domanda (e a qualsiasi altro utilizzo simile):

1. Per le prestazioni, dovresti sempre provare a usare find ... -exec grep ... +(grazie Kenji per averlo sottolineato) o find ... | xargs egrep ...(portatile) o find ... -print0 | xargs -0 egrep ...(GNU; funziona su nomi di file contenenti spazi) invece di find ... -exec grep ... \;.

   Il form find ... -exec ... +e find | xargsnon si biforca egrepper ogni file, ma piuttosto per un mucchio di file alla volta, con conseguente esecuzione molto più veloce .

2. Quando si utilizza il find | xargsmodulo è inoltre possibile utilizzare grepper potare facilmente e rapidamente .svn(o qualsiasi directory o espressione regolare), vale a dire find ... -print0 | grep -v '/\.svn' | xargs -0 egrep ...(utile quando è necessario qualcosa di rapido e non si può disturbare a ricordare come impostare findla -prunelogica.)

   L' find | grep | xargsapproccio è simile a GNU finds' -regexopzione (vedighostdog74 ' s post), ma è più portabile (funziona anche su piattaforme in cui GNU findnon è disponibile.)

In un repository di codice sorgente, generalmente voglio fare cose solo con i file di testo.

La prima riga contiene tutti i file, esclusi i file di repository CVS, SVN e GIT.

La seconda riga esclude tutti i file binari.

find . -not \( -name .svn -prune -o -name .git -prune -o -name CVS -prune \) -type f -print0 | \
xargs -0 file -n | grep -v binary | cut -d ":" -f1

Uso find con le opzioni -not -path. Non ho avuto fortuna con la prugna.

find .  -name "*.groovy" -not -path "./target/*" -print

troverà i file groovy non nel percorso della directory di destinazione.

Per risolvere questo problema, puoi semplicemente usare questa condizione di ricerca:

find \( -name 'messages.*' ! -path "*/.svn/*" \) -exec grep -Iw uint {} +

Puoi aggiungere altre restrizioni come questa:

find \( -name 'messages.*' ! -path "*/.svn/*" ! -path "*/CVS/*" \) -exec grep -Iw uint {} +

Ulteriori informazioni al riguardo sono disponibili nella sezione della pagina man "Operatori": http://unixhelp.ed.ac.uk/CGI/man-cgi?find

Nota che se lo fai

find . -type f -name 'messages.*'

allora -printè implicito quando l'intera espressione ( -type f -name 'messages.*') è vera, perché non c'è 'azione' (come -exec).

Mentre, per smettere di scendere in certe directory, dovresti usare tutto ciò che corrisponde a quelle directory e seguirlo -prune(che intende smettere di scendere in directory); così:

find . -type d -name '.svn' -prune

Questo vale su True per le directory .svn e possiamo usare un cortocircuito booleano seguendo questo da -o(OR), dopodiché ciò che segue dopo -oviene verificato solo quando la prima parte è False, quindi non è una directory .svn. In altre parole, quanto segue:

find . -type d -name '.svn' -prune -o -name 'message.*' -exec grep -Iw uint {}

valuterà solo ciò che è giusto -o, vale a dire -name 'message.*' -exec grep -Iw uint {}, per i file NON all'interno delle directory .svn.

Si noti che poiché .svnè probabilmente sempre una directory (e non ad esempio un file), e in questo caso certamente non corrisponde al nome 'message. *', Si potrebbe anche tralasciare -type de fare:

find . -name '.svn' -prune -o -name 'message.*' -exec grep -Iw uint {}

Infine, nota che se ometti qualsiasi azione ( -execè un'azione), dì così:

find . -name '.svn' -prune -o -name 'message.*'

allora l' -printazione è implicita ma si applicherà all'intera espressione, inclusa la -name '.svn' -prune -oparte e quindi stampa tutte le directory .svn così come i file 'message. *', che probabilmente non è quello che vuoi. Pertanto, quando si utilizza -prunein questo modo, è sempre necessario utilizzare un '"azione" nella parte destra dell'espressione booleana . E quando quell'azione sta stampando devi aggiungerla esplicitamente, in questo modo:

find . -name '.svn' -prune -o -name 'message.*' -print

Prova findrepo che è un semplice wrapper per find / grep e molto più veloce di ack. In questo caso lo useresti come:

findrepo uint 'messages.*'

wcfind è uno script find wrapper che uso per rimuovere automagicamente le directory .svn.

Questo funziona per me nel prompt di Unix

gfind. \ (-not -wholename '* \. svn *' \) -type f -name 'messaggi. *' -exec grep -Iw uint {} +

Il comando sopra elencherà i FILE che non sono con .svn e eseguiranno il grep che hai citato.

di solito installo l'output attraverso grep ancora una volta rimuovendo .svn, nel mio uso non è molto più lento. esempio tipico:

find -name 'messages.*' -exec grep -Iw uint {} + | grep -Ev '.svn|.git|.anythingElseIwannaIgnore'

O

find . -type f -print0 | xargs -0 egrep messages. | grep -Ev '.svn|.git|.anythingElseIwannaIgnore'