¿Cómo puedo obtener 'find' para ignorar los directorios .svn?

A menudo uso el findcomando para buscar a través del código fuente, eliminar archivos, lo que sea. Molesto, debido a que Subversion almacena duplicados de cada archivo en sus .svn/text-base/directorios, mis búsquedas simples terminan obteniendo muchos resultados duplicados. Por ejemplo, quiero buscar recursivamente uinten múltiples messages.hy messages.cpparchivos:

# 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;

¿Cómo puedo decir findque ignore los .svndirectorios?

Actualización : si actualiza su cliente SVN a la versión 1.7, esto ya no es un problema.

Una característica clave de los cambios introducidos en Subversion 1.7 es la centralización del almacenamiento de metadatos de la copia de trabajo en una sola ubicación. En lugar de un .svndirectorio en cada directorio de la copia de trabajo, las copias de trabajo de Subversion 1.7 tienen un solo .svndirectorio, en la raíz de la copia de trabajo. Este directorio incluye (entre otras cosas) una base de datos respaldada por SQLite que contiene todas las necesidades de Subversion de metadatos para esa copia de trabajo.

Para buscar, ¿puedo sugerirle que mire ack ? Es consciente del código fuente y find, como tal, ignorará automáticamente muchos tipos de archivos, incluida la información del repositorio de código fuente, como la anterior.

por qué no solo

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

El predicado -not niega todo lo que tiene .svn en cualquier parte de la ruta.

Entonces en tu caso sería

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

Como sigue:

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

O, alternativamente, basado en un directorio y no en un prefijo de ruta:

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

Para ignorar .svn, .gity otros directorios ocultos (comenzando con un punto), intente:

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

Sin embargo, si el propósito de usar findes buscar dentro de los archivos, puede intentar usar estos comandos:

• git grep - comando especialmente diseñado para buscar patrones dentro del repositorio de Git.
• ripgrep- que por defecto ignora los archivos ocultos y los archivos especificados en .gitignore.

Relacionado: ¿Cómo encuentro todos los archivos que contienen texto específico en Linux?

Esto es lo que haría en su caso:

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

El rgrepcomando incorporado de Emacs ignora el .svndirectorio, y muchos más archivos que probablemente no le interesen al realizar un find | grep. Esto es lo que usa por defecto:

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 los directorios creados por la mayoría de los sistemas de control de versiones, así como los archivos generados para muchos lenguajes de programación. Puede crear un alias que invoque este comando y reemplazar findy greppatrones para sus problemas específicos.

GNU encontrar

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

Yo uso grep para este propósito. Pon esto en tu ~ / .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 usa automáticamente estas opciones en la invocación

find . | grep -v \.svn

¿Por qué no canaliza su comando con grep, que es fácilmente comprensible?

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

Crea un script llamado ~/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

Este script se comporta de manera idéntica a un findcomando simple pero elimina .svndirectorios. De lo contrario, el comportamiento es idéntico.

Ejemplo:

# 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;

Solo pensé que agregaría una alternativa simple a las publicaciones de Kaleb y de otros (que detalla el uso de la find -pruneopción ack, repofindcomandos , etc.) que es particularmente aplicable al uso que ha descrito en la pregunta (y cualquier otro uso similar):

1. Para el rendimiento, siempre debe intentar usar find ... -exec grep ... +(gracias Kenji por señalar esto) o find ... | xargs egrep ...(portátil) o find ... -print0 | xargs -0 egrep ...(GNU; funciona en nombres de archivos que contienen espacios) en lugar de find ... -exec grep ... \;.

   El formulario find ... -exec ... +y find | xargsno se bifurca egreppara cada archivo, sino para un montón de archivos a la vez, lo que resulta en una ejecución mucho más rápida .

2. Al usar el find | xargsformulario, también puede usarlo greppara podar fácil y rápidamente .svn(o cualquier directorio o expresión regular), es decir find ... -print0 | grep -v '/\.svn' | xargs -0 egrep ...(útil cuando necesita algo rápido y no puede molestarse en recordar cómo configurar findla -prunelógica).

   El find | grep | xargsenfoque es similar a findla -regexopción de GNU (vea ghostdog74la publicación de), pero es más portátil (también funcionará en plataformas donde GNU findno está disponible).

En un repositorio de código fuente, generalmente quiero hacer cosas solo con los archivos de texto.

La primera línea son todos los archivos, excepto los archivos de repositorio CVS, SVN y GIT.

La segunda línea excluye todos los archivos binarios.

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

Yo uso find con las opciones -not -path. No he tenido buena suerte con la ciruela pasa.

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

encontrará los archivos geniales que no están en la ruta del directorio de destino.

Para resolver este problema, simplemente puede usar esta condición de búsqueda:

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

Puede agregar más restricciones como esta:

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

Puede encontrar más información sobre esto en la sección de la página de manual "Operadores": http://unixhelp.ed.ac.uk/CGI/man-cgi?find

Tenga en cuenta que si lo hace

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

entonces -printestá implícito cuando toda la expresión ( -type f -name 'messages.*') es verdadera, porque no hay 'acción' (como -exec).

Mientras que, para dejar de descender a ciertos directorios, debe usar cualquier cosa que coincida con esos directorios y seguirlo -prune(que tiene la intención de dejar de descender a directorios); al igual que:

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

Esto se evalúa como Verdadero para los directorios .svn, y podemos usar un cortocircuito booleano siguiendo esto por -o(OR), después de lo cual lo que sigue después de -oque solo se verifica cuando la primera parte es Falso, por lo tanto, no es un directorio .svn. En otras palabras, lo siguiente:

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

solo evaluará lo que es correcto de -o, es decir -name 'message.*' -exec grep -Iw uint {}, para archivos que NO estén dentro de directorios .svn.

Tenga en cuenta que debido a que .svnes probable que siempre sea un directorio (y no, por ejemplo, un archivo), y en este caso ciertamente no coincide con el nombre 'mensaje. *', También podría omitir el -type dy hacer:

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

Finalmente, tenga en cuenta que si omite alguna acción ( -execes una acción), diga así:

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

entonces la -printacción está implícita pero se aplicará a la expresión ENTERA, incluida la -name '.svn' -prune -oparte, y así imprimirá todos los directorios .svn, así como los archivos 'mensaje. *', que probablemente no sea lo que desea. Por lo tanto, siempre debe usar una 'acción' en el lado derecho de la expresión booleana cuando se usa -prunede esta manera. Y cuando se imprime esa acción, debe agregarla explícitamente, así:

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

Pruebe findrepo, que es un contenedor simple alrededor de find / grep y mucho más rápido que ack. Lo usaría en este caso como:

findrepo uint 'messages.*'

wcfind es un script de derivador de búsqueda que uso para eliminar automáticamente directorios .svn.

Esto funciona para mí en el indicador de Unix

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

El comando anterior enumerará ARCHIVOS que no están con .svn y hará el grep que mencionó.

Por lo general, canalizo la salida a través de grep una vez más eliminando .svn, en mi uso no es mucho más lento. ejemplo típico:

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'