Como posso o `find` ignorar os diretórios .svn?

Costumo usar o findcomando para pesquisar no código fonte, excluir arquivos, o que for. Irritantemente, porque o Subversion armazena duplicatas de cada arquivo em seus .svn/text-base/diretórios, minhas pesquisas simples acabam obtendo muitos resultados duplicados. Por exemplo, desejo pesquisar recursivamente uintem vários arquivos messages.he messages.cpp:

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

Como posso dizer findpara ignorar os .svndiretórios?

Atualização : se você atualizar o seu cliente SVN para a versão 1.7, isso não será mais um problema.

Um recurso importante das alterações introduzidas no Subversion 1.7 é a centralização do armazenamento de metadados da cópia de trabalho em um único local. Em vez de um .svndiretório em todos os diretórios da cópia de trabalho, as cópias de trabalho do Subversion 1.7 têm apenas um .svndiretório - na raiz da cópia de trabalho. Este diretório inclui (entre outras coisas) um banco de dados baseado em SQLite que contém todos os metadados que o Subversion precisa para essa cópia de trabalho.

Para pesquisar, posso sugerir que você olhe para ack ? É compatível com o código-fonte e find, como tal, ignorará automaticamente muitos tipos de arquivos, incluindo informações sobre o repositório do código-fonte, como o descrito acima.

porque não apenas

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

O predicado -not nega tudo o que tem .svn em qualquer lugar do caminho.

Então, no seu caso, seria

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

Do seguinte modo:

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

Ou, alternativamente, com base em um diretório e não em um prefixo de caminho:

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

Para ignorar .svn, .gite outros diretórios ocultos (que começam com um ponto), tente:

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

No entanto, se o objetivo de usar findestiver pesquisando nos arquivos, você pode tentar usar estes comandos:

• git grep - comando especialmente projetado para pesquisar padrões no repositório Git.
• ripgrep- que por padrão ignora arquivos ocultos e arquivos especificados em .gitignore.

Relacionado: Como encontro todos os arquivos que contêm texto específico no Linux?

Aqui está o que eu faria no seu caso:

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

O rgrepcomando interno do Emacs ignora o .svndiretório e muitos outros arquivos nos quais você provavelmente não está interessado ao executar um find | grep. Aqui está o que ele usa por padrão:

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

Ele ignora os diretórios criados pela maioria dos sistemas de controle de versão, além de gerar arquivos para muitas linguagens de programação. Você pode criar um alias que chama esse comando e substituir finde greppadrões para seus problemas específicos.

Localização GNU

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

Eu uso grep para esse fim. Coloque isso no seu ~ / .bashrc

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

O grep usa automaticamente essas opções na invocação

find . | grep -v \.svn

Por que você não canaliza seu comando com grep, que é facilmente compreensível:

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

Crie um script chamado ~/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

Esse script se comporta de maneira idêntica a um findcomando simples, mas remove os .svndiretórios. Caso contrário, o comportamento é idêntico.

Exemplo:

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

Apenas pensei em adicionar uma alternativa simples às postagens de Kaleb e de outras pessoas (que detalham o uso da find -pruneopção ack, repofindcomandos , etc.), que é particularmente aplicável ao uso que você descreveu na pergunta (e qualquer outro uso semelhante):

1. Para desempenho, você deve sempre tentar usar find ... -exec grep ... +(obrigado Kenji por apontar isso) ou find ... | xargs egrep ...(portátil) ou find ... -print0 | xargs -0 egrep ...(GNU; funciona em nomes de arquivos contendo espaços) em vez de find ... -exec grep ... \;.

   O formulário find ... -exec ... +e find | xargsnão bifurca egreppara cada arquivo, mas para vários arquivos por vez, resultando em uma execução muito mais rápida .

2. Ao utilizar o find | xargsformulário que você também pode usar grepa facilidade e rapidez de ameixa .svn(ou quaisquer diretórios ou expressão regular), ou seja, find ... -print0 | grep -v '/\.svn' | xargs -0 egrep ...(útil quando você precisa de algo rápido e não pode ser incomodado para lembrar como configurar find's -prunelógica.)

   A find | grep | xargsabordagem é semelhante GNU para find's -regexopção (ver ghostdog74' s post), mas é mais portátil (também funcionará em plataformas onde GNU findnão está disponível.)

Em um repositório de código-fonte, geralmente quero fazer as coisas apenas com os arquivos de texto.

A primeira linha são todos os arquivos, excluindo os arquivos de repositório CVS, SVN e GIT.

A segunda linha exclui todos os arquivos binários.

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

Eu uso find com as opções -not -path. Não tive boa sorte com ameixa.

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

encontrará os arquivos groovy que não estão no caminho do diretório de destino.

Para resolver esse problema, você pode simplesmente usar esta condição de localização:

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

Você pode adicionar mais restrições como esta:

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

Você pode encontrar mais informações sobre isso na seção "Operadores" da página de manual: http://unixhelp.ed.ac.uk/CGI/man-cgi?find

Observe que se você fizer

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

então -printé implícito quando toda a expressão ( -type f -name 'messages.*') é verdadeira, porque não há 'ação' (como -exec).

Enquanto, para parar de descer para determinados diretórios, você deve usar qualquer coisa que corresponda a esses diretórios e segui-lo -prune(que se destina a parar de descer para diretórios); igual a:

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

Isso é avaliado como True para os diretórios .svn, e podemos usar um curto-circuito booleano seguindo isto por -o(OR), após o qual o que se segue após o -oé verificado apenas quando a primeira parte é False, portanto, não é um diretório .svn. Em outras palavras, o seguinte:

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

só evalute o que é certo do -o, ou seja -name 'message.*' -exec grep -Iw uint {}, para arquivos não dentro diretórios .svn.

Observe que, como .svnprovavelmente sempre é um diretório (e não, por exemplo, um arquivo), e, nesse caso, certamente não corresponde ao nome 'message. *', Você também pode deixar de lado o seguinte -type dcomando:

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

Por fim, observe que, se você omitir qualquer ação ( -execé uma ação), diga o seguinte:

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

a -printação é implícita, mas será aplicada à expressão WHOLE, incluindo a -name '.svn' -prune -oparte e, assim, imprima todos os diretórios .svn, bem como os arquivos 'message. *', o que provavelmente não é o que você deseja. Portanto, você sempre deve usar uma 'ação' no lado direito da expressão booleana ao usá -prune-lo dessa maneira. E quando essa ação está sendo impressa, você deve adicioná-la explicitamente, assim:

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

Tente findrepo, que é um invólucro simples em torno de find / grep e muito mais rápido que o ack. Você usaria neste caso como:

findrepo uint 'messages.*'

wcfind é um script de wrapper de localização que eu uso para remover automaticamente diretórios .svn.

Isso funciona para mim no prompt do Unix

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

O comando acima listará FILES que não estão com .svn e executará o grep que você mencionou.

Eu normalmente canalizo a saída através do grep mais uma vez removendo .svn, no meu uso, não é muito mais lento. exemplo típico:

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

OU

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