Comment puis-je obtenir `find` pour ignorer les répertoires .svn?

J'utilise souvent la findcommande pour rechercher dans le code source, supprimer des fichiers, peu importe. Chose ennuyeuse, parce que Subversion stocke des doublons de chaque fichier dans ses .svn/text-base/répertoires, mes recherches simples finissent par obtenir de nombreux résultats en double. Par exemple, je veux rechercher récursivement uintdans plusieurs fichiers messages.het 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;

Comment puis-je dire findd'ignorer les .svnrépertoires?

Mise à jour : si vous mettez à niveau votre client SVN vers la version 1.7, ce n'est plus un problème.

Une caractéristique clé des changements introduits dans Subversion 1.7 est la centralisation du stockage des métadonnées de copie de travail en un seul emplacement. Au lieu d'un .svnrépertoire dans chaque répertoire de la copie de travail, les copies de travail de Subversion 1.7 n'ont qu'un seul .svnrépertoire, à la racine de la copie de travail. Ce répertoire comprend (entre autres) une base de données SQLite-soutenue qui contient tous les besoins de Subversion de métadonnées pour cette copie de travail.

Pour la recherche, puis-je vous suggérer de regarder ack ? Il s'agit d'un code source find, et en tant que tel, il ignorera automatiquement de nombreux types de fichiers, y compris les informations de référentiel de code source telles que celles ci-dessus.

pourquoi pas

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

Le prédicat -not annule tout ce qui contient .svn n'importe où dans le chemin.

Donc, dans votre cas, ce serait

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

Comme suit:

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

Ou bien, basé sur un répertoire et non sur un préfixe de chemin:

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

Pour ignorer .svn, .gitet d'autres répertoires cachés (commençant par un point), essayez:

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

Cependant, si le but de l'utilisation findest la recherche dans les fichiers, vous pouvez essayer d'utiliser ces commandes:

• git grep - commande spécialement conçue pour rechercher des modèles dans le référentiel Git.
• ripgrep- qui ignore par défaut les fichiers cachés et les fichiers spécifiés dans .gitignore.

Connexes: Comment trouver tous les fichiers contenant du texte spécifique sur Linux?

Voici ce que je ferais dans votre cas:

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

La rgrepcommande intégrée d' Emacs ignore le .svnrépertoire et bien d'autres fichiers qui ne vous intéressent probablement pas lors de l'exécution d'un find | grep. Voici ce qu'il utilise par défaut:

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

Il ignore les répertoires créés par la plupart des systèmes de contrôle de version, ainsi que les fichiers générés pour de nombreux langages de programmation. Vous pouvez créer un alias qui invoque cette commande et remplacer findet des grepmodèles pour vos problèmes spécifiques.

GNU find

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

J'utilise grep à cet effet. Mettez ceci dans votre ~ / .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 utilise automatiquement ces options lors de l'invocation

find . | grep -v \.svn

Pourquoi ne dirigez-vous pas votre commande avec grep qui est facilement compréhensible:

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

Créez un script appelé ~/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

Ce script se comporte de manière identique à une findcommande ordinaire mais il élague les .svnrépertoires. Sinon, le comportement est identique.

Exemple:

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

Je pensais juste ajouter une alternative simple à de Kaleb et les messages des autres (qui expose en détail l'utilisation de l' find -pruneoption ack, des repofindcommandes , etc.) qui est particulièrement applicable à l'utilisation que vous avez décrite dans la question (et toutes les autres usages similaires):

1. Pour des performances, vous devez toujours essayer d'utiliser find ... -exec grep ... + (merci Kenji pour l'avoir signalé) ou find ... | xargs egrep ...(portable) ou find ... -print0 | xargs -0 egrep ...(GNU; fonctionne sur les noms de fichiers contenant des espaces) au lieu de find ... -exec grep ... \;.

   le find ... -exec ... +find | xargs formulaire et ne se déroule pas egreppour chaque fichier, mais plutôt pour un groupe de fichiers à la fois, ce qui entraîne une exécution beaucoup plus rapide .

2. Lorsque vous utilisez le find | xargs formulaire, vous pouvez également utiliser greppour tailler facilement et rapidement .svn(ou tout répertoire ou expression régulière), c'est-à-dire find ... -print0 | grep -v '/\.svn' | xargs -0 egrep ...(utile lorsque vous avez besoin de quelque chose de rapide et que vous ne pouvez pas vous soucier de savoir comment configurer findla -prunelogique.)

   L' find | grep | xargsapproche est similaire à findl' -regexoption de GNU (voir ghostdog74l'article), mais est plus portable (fonctionnera également sur les plates-formes où GNU findn'est pas disponible.)

Dans un référentiel de code source, je veux généralement faire des choses uniquement avec les fichiers texte.

La première ligne comprend tous les fichiers, à l'exception des fichiers de référentiel CVS, SVN et GIT.

La deuxième ligne exclut tous les fichiers binaires.

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

J'utilise find avec les options -not -path. Je n'ai pas eu de chance avec le pruneau.

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

trouvera les fichiers groovy pas dans le chemin du répertoire cible.

Pour résoudre ce problème, vous pouvez simplement utiliser cette condition de recherche:

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

Vous pouvez ajouter plus de restrictions comme ceci:

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

Vous pouvez trouver plus d'informations à ce sujet dans la section de la page de manuel "Opérateurs": http://unixhelp.ed.ac.uk/CGI/man-cgi?find

Notez que si vous le faites

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

-printest alors implicite lorsque toute l'expression ( -type f -name 'messages.*') est vraie, car il n'y a pas d '«action» (comme-exec ).

Tandis que, pour arrêter de descendre dans certains répertoires, vous devez utiliser tout ce qui correspond à ces répertoires et le suivre -prune(qui est destiné à arrêter la descente dans les répertoires); ainsi:

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

Cela équivaut à True pour les répertoires .svn, et nous pouvons utiliser un court-circuit booléen en suivant ceci par -o(OR), après quoi ce qui suit après le -on'est vérifié que lorsque la première partie est False, il ne s'agit donc pas d' un répertoire .svn. En d'autres termes, ce qui suit:

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

ne fera que evalute ce qui est juste de -o, à savoir-name 'message.*' -exec grep -Iw uint {} , pour les fichiers NON à l'intérieur des répertoires .svn.

Notez que parce qu'il .svns'agit probablement toujours d'un répertoire (et non par exemple d'un fichier), et dans ce cas ne correspond certainement pas au nom 'message. *', Vous pouvez aussi bien laisser de côté le -type det faire:

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

Enfin, notez que si vous omettez une action ( -execest une action), dites comme ceci:

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

alors l' -printaction est implicite mais s'appliquera à l'expression WHOLE, y compris la -name '.svn' -prune -opartie et affichera ainsi tous les répertoires .svn ainsi que les fichiers 'message. *', ce qui n'est probablement pas ce que vous voulez. Par conséquent, vous devez toujours utiliser une «action» dans le côté droit de l'expression booléenne lorsque vous utilisez -prunede cette manière. Et lorsque cette action s'imprime, vous devez l'ajouter explicitement, comme ceci:

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

Essayez findrepo qui est un simple wrapper autour de find / grep et beaucoup plus rapide que ack Vous l'utiliseriez dans ce cas comme:

findrepo uint 'messages.*'

wcfind est un script de wrapper de recherche que j'utilise pour supprimer automatiquement les répertoires .svn.

Cela fonctionne pour moi dans l'invite Unix

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

La commande ci-dessus listera les FICHIERS qui ne sont pas avec .svn et fera le grep que vous avez mentionné.

Je dirige généralement la sortie via grep une fois de plus en supprimant .svn, dans mon utilisation, ce n'est pas beaucoup plus lent. exemple typique:

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'

Si vous dites à find de rechercher dans '*', alors il sautera tous les "fichiers dot" à la racine:

find *

ou avec chemin

find /path/*

Ce n'est pas une solution exacte / parfaite à la question. Cependant, peu de solutions sont plus simples que celle-ci. Les performances sont également excellentes, car elles n'entrent même pas dans les répertoires cachés.

lacunes:

• il ne gère pas les "fichiers dot" imbriqués.
• tous les "fichiers dot" sont ignorés, pas seulement ".git" et ".svn".

Donc, dans votre exemple, l'ajout d'une étoile est la seule modification dont vous auriez besoin:

find * -name 'messages.*' -exec grep -Iw uint {} +