ripgrep — l'outil de recherche qui a changé mon workflow WSL2

Zut. J'ai tapé cette commande tellement de fois que je pourrais la taper les yeux fermés : grep -rn --include="*.php" "getUser" . | grep -v vendor. Ça marche — grep est un classique, il fait le job. Mais au fil des années, j'ai accumulé tellement de flags, tellement d'alias, tellement de contournements devenus automatiques pour les bizarreries de grep... À un moment, il faut se poser la question : est-ce qu'il existe mieux ?

Oui, il existe mieux. Ça s'appelle ripgrep, et une fois qu'on y a goûté, impossible de revenir en arrière.

Il appartient à la même famille de réécritures modernes que eza (pour ls) et delta (pour git diff).

ripgrep vs grep — comparaison côte à côte​

Laissez-moi vous montrer pourquoi ripgrep s'impose aussi vite. Voici les mêmes recherches exprimées dans les deux outils :

grep -rn --include="*.php" "getUser" . \
  | grep -v vendor

rg "getUser" --type php

grep -rn -i "TODO" . \
  --include="*.py" \
  --include="*.pyi" \
  --exclude-dir=.venv \
  --exclude-dir=dist

rg -i "TODO" --type py

grep -rn "DB_PASSWORD" . \
  --include="*.env" \
  --include="*.yml" \
  --include="*.yaml"

rg "DB_PASSWORD" -t yaml -t sh

Bien sûr, les flags de grep sont puissants une fois qu'on les connaît par cœur. Mais la syntaxe de ripgrep est tout simplement plus propre — et par défaut, il ignore déjà vendor/, node_modules/ et tout ce qui se trouve dans votre .gitignore, sans le moindre flag supplémentaire.

Qu'est-ce que ripgrep ?​

ripgrep (rg en ligne de commande) est un outil de recherche ligne par ligne écrit en Rust par Andrew Gallant (BurntSushi). La vitesse est son argument phare — les benchmarks montrent systématiquement qu'il devance grep, ag (le Silver Searcher) et ack de loin sur les gros codebases — et hyperfine vous permet de vérifier cette affirmation sur votre propre machine. Mais la vitesse brute n'est qu'une partie de l'histoire.

Ce qui rend ripgrep réellement meilleur au quotidien, ce sont ses valeurs par défaut intelligentes :

• Il respecte automatiquement les fichiers .gitignore, .ignore et .rgignore — donc vendor/, node_modules/, dist/ et .git/ sont ignorés sans aucune gymnastique à base de --exclude-dir.
• Il ignore les fichiers binaires par défaut.
• Il colorise et regroupe la sortie par nom de fichier d'office.
• Il utilise l'Unicode par défaut — fini la sortie illisible sur les noms de fichiers ou les contenus accentués.
• Il supporte la syntaxe regex moderne, y compris PCRE2 avec le flag -P.
• Il ne cherche dans les fichiers cachés que si vous le demandez explicitement (--hidden).

Ce dernier comportement d'affichage est sous-estimé. Des résultats lisibles, groupés, colorisés — immédiatement, sans la moindre configuration. Plutôt sympa, non ?

Le voir à l'œuvre avec Docker​

Avant de toucher à votre propre ~/.zshrc, essayez ripgrep dans un container jetable qui embarque déjà la config ~/.ripgreprc, les fonctions rgtodo/rgenv et un petit faux projet conçu pour mettre en valeur les valeurs par défaut intelligentes : un dossier vendor/ qui doit rester invisible, des commentaires TODO/FIXME, un DB_PASSWORD qui fuit et un appel console.log(token) qui mérite d'être signalé.

Buildez et lancez :

$ docker build -t ripgrep-demo .
[+] Building 21.3s (10/10) FINISHED
✔ exporting to image
$ docker run --rm -it ripgrep-demo
🐳 root ~/demo #

Jouez maintenant avec les scénarios décrits plus haut, en direct :

$ rg "getUser"
src/UserController.php
2:function getUser($id) {

src/legacy.php
4:function getAllUsers() {

$ rgtodo
src/legacy.php:2:// TODO: cache this lookup
src/legacy.php:3:// FIXME: N+1 query below

$ rgenv DB_PASSWORD
.env
1:DB_PASSWORD=demo-secret

$ rg -C 2 "console.log"
src/app.js
2-function refreshToken(token) {
3:  console.log(token);
4-}
7-  for (const item of cart) {
8:    console.log(item);
9-  }
▋

Remarquez que vendor/legacy/User.php — qui définit lui aussi getUser, exprès — n'apparaît jamais dans aucune de ces recherches : le .gitignore et l'entrée de configuration --glob=!vendor/* l'excluent tous les deux, exactement comme décrit plus haut. Essayez rg --no-ignore "getUser" pour le voir réapparaître.

Installation sur Ubuntu / WSL2​

ripgrep est présent dans les dépôts de paquets par défaut d'Ubuntu, donc l'installer tient en une ligne :

$ sudo apt update && sudo apt install ripgrep -y

Reading package lists... Done
Building dependency tree... Done
0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.▋

$ rg --version

ripgrep 14.1.0
-rev 0 (rev 4649aa9700 2024-03-30)
features: +SIMD +AVX (compiled), +SIMD +AVX (runtime)▋

Configuration — ~/.ripgreprc​

Comme la plupart des outils Unix, ripgrep se configure via un fichier dédié. Vous le désignez avec la variable d'environnement RIPGREP_CONFIG_PATH. Voici un exemple de fichier ~/.ripgreprc :

--colors=match:fg:red?
--colors=match:style:bold?
--colors=path:fg:blue
--follow?
--glob=!.cache/*
--glob=!.git/*
--glob=!.output/*
--glob=!.yarn/*
--glob=!build/*
--glob=!dist/*
--glob=!node_modules/*
--glob=!vendor/*
--hidden?
--max-filesize=10M?
--smart-case?

Chaque ligne est un flag appliqué par défaut à chaque invocation de rg. Quelques points méritent une explication :

• --hidden fait chercher ripgrep à l'intérieur des fichiers et dossiers cachés (tout ce qui commence par un point). Combiné à l'exclusion --glob=!.git/*, cela veut dire que vous pouvez chercher dans les fichiers .env, .zshrc, .gitignore et consorts sans ouvrir toute la plomberie interne de .git/.
• --max-filesize=10M ignore silencieusement les très gros fichiers (dumps de logs, assets générés) qui noieraient sinon vos résultats.
• --smart-case est probablement le réglage le plus impactant : les recherches sont insensibles à la casse par défaut, mais dès que votre motif contient une majuscule, ripgrep bascule en correspondance exacte de casse — exactement le comportement que je veux 95 % du temps.

Configuration du shell — ~/.zshrc ou ~/.bashrc​

Une fois le fichier de config en place, j'ajoute la variable d'environnement, le chargeur de fonctions et une poignée d'alias par type de fichier dans le fichier rc de mon shell. Le contenu est identique pour zsh et bash, sauf la boucle de chargement :

export RIPGREP_CONFIG_PATH="$HOME/.ripgreprc"?

# If you don't already have such loop...
# Load custom ZSH functions from ~/.zsh/fns/
for fn_file in ~/.zsh/fns/*.zsh; do?
    source "${fn_file}"?
done

# Type-specific shortcuts
alias rgp='rg --type php'
alias rgj='rg --type js'
alias rgt='rg --type ts'
alias rgm='rg --type md'
alias rgy='rg --type yaml'
alias rgb='rg --type sh'
alias rgd='rg --glob "Dockerfile*" --glob "*.dockerfile"'

export RIPGREP_CONFIG_PATH="$HOME/.ripgreprc"?

# If you don't already have such loop...
# Load custom bash functions from ~/.bash/fns/
for fn_file in ~/.bash/fns/*.sh; do?
    [[ -r "${fn_file}" ]] && source "${fn_file}"?
done

# Type-specific shortcuts
alias rgp='rg --type php'
alias rgj='rg --type js'
alias rgt='rg --type ts'
alias rgm='rg --type md'
alias rgy='rg --type yaml'
alias rgb='rg --type sh'
alias rgd='rg --glob "Dockerfile*" --glob "*.dockerfile"'

La boucle for fn_file source automatiquement chaque fichier de fonction présent dans ce répertoire — ajouter une nouvelle fonction revient donc simplement à y déposer un nouveau fichier, sans avoir à retoucher votre fichier rc.

Les alias par type (rgp pour PHP, rgt pour TypeScript, rgm pour Markdown, etc.) font gagner des frappes quand vous savez exactement dans quel type de fichier vous cherchez. J'utilise rgp "getUser" ou rgm "## Installation" des dizaines de fois par jour.

Fonctions shell — ~/.zsh/fns/ ou ~/.bash/fns/​

C'est ici que ça devient amusant. Voici trois fonctions que j'ai installées dans mon répertoire ~/.zsh/fns/, chacune résolvant un vrai problème.

rgf — recherche interactive avec fzf​

J'ai détaillé cette combinaison dans un article dédié : FZF + ripgrep : recherche de code interactive avec aperçu en direct. En résumé : envoyez rg dans fzf avec un panneau de prévisualisation bat et vous obtenez un chercheur flou interactif qui cherche dans le contenu des fichiers, prévisualise les correspondances avec coloration syntaxique et ouvre votre éditeur exactement à la ligne trouvée. Si vous n'avez pas encore lu cet article, le détour en vaut la peine.

rgtodo — faire remonter toute la dette technique d'un coup​

Chaque codebase en est truffé dans ses commentaires : TODO, FIXME, HACK, NOTE, XXX. Cette fonction les fait tous remonter à la surface :

Lancez rgtodo à la racine de n'importe quel projet et vous obtenez une liste triée et colorisée de chaque marqueur de commentaire. Lancez rgtodo src/ pour la restreindre à un dossier précis. Révélateur sur des codebases qui ont quelques années au compteur.

$ rgtodo src/

src/Api/UserController.php:47:    // TODO: replace with a proper permission check
src/Api/UserController.php:112:   // FIXME: this bypasses rate limiting on retry
src/Services/MailService.php:23:  // HACK: temporary workaround for #4521
▋

rgenv — traquer l'usage des variables d'environnement​

Dans les projets très orientés Docker, les variables d'environnement finissent éparpillées entre des fichiers .env, compose.yml, des bootstraps PHP et des configs Python. Cette fonction cherche dans tous ces fichiers d'un seul coup :

rgenv DB_PASSWORD montre instantanément chaque fichier qui référence cette variable — qu'il la définisse, la consomme ou la passe comme secret Docker. Inestimable pour déboguer les dérives de configuration dans les setups multi-containers complexes.

$ rgenv DB_PASSWORD

.env:3:DB_PASSWORD=supersecret
compose.yml:18:      - DB_PASSWORD=${DB_PASSWORD}
src/Config/database.php:14:    'password' => env('DB_PASSWORD'),
▋

Installer rgtodo et rgenv​

Les deux fonctions sont du code shell pur : les mêmes fichiers fonctionnent en zsh et en bash, seul le dossier change. La boucle de chargement est déjà dans votre fichier rc depuis la section précédente.

Vérifiez que le shell les connaît : type rgtodo rgenv doit répondre deux fois … is a shell function.

Cas d'usage réels​

Passons en revue les recherches que je lance le plus souvent dans mon workflow WSL2 quotidien.

Trouver la définition d'une fonction dans un projet PHP​

rg "function getUser" --type php

Sans ripgrep : il faut ajouter --include="*.php", --exclude-dir=vendor, -rn. Avec ripgrep : tapez-le, point. Le répertoire vendor/ est déjà exclu parce qu'il est dans le .gitignore.

Chercher une référence d'image dans tous les fichiers Docker Compose​

rgy "image:"

C'est notre alias rgy (rg --type yaml). Pratique pour auditer un repository à la recherche de références d'images obsolètes, ou pour trouver tous les services qui partagent une image de base.

Lignes de contexte — comprendre le code autour d'une correspondance​

Le flag -C N affiche N lignes de contexte autour de chaque correspondance — une fonctionnalité que j'utilise en permanence :

$ rg "DB_HOST" -C 3 --type php

src/Config/Database.php
15-  'driver'   => 'mysql',
16:  'host'     => env('DB_HOST', '127.0.0.1'),
17-  'database' => env('DB_DATABASE', 'forge'),
18-  'username' => env('DB_USERNAME', 'forge'),
19-  'password' => env('DB_PASSWORD', ''),
▋

Vous pouvez aussi utiliser -A N (après) et -B N (avant) séparément, exactement comme avec grep.

Un scénario plus courant : un collègue laisse des appels console.log() dans du JavaScript avant de pousser en production. Sans contexte, vous ne voyez que la ligne elle-même — vous savez qu'elle existe, mais pas à quel point c'est grave. Avec -C 2 :

$ rg "console\.log" -C 2 --type js

src/auth/login.js
40-  const authToken = generateToken(user)
41-  const refreshToken = generateRefresh(user)
42:  console.log("token:", authToken)
43-  return { authToken, refreshToken }

src/payment/checkout.js
85-  for (const item of cartItems) {
86-    const price = calculatePrice(item)
87:    console.log("debug")
88-    total += price
▋

Là, vous pouvez faire la différence. La première correspondance logue un token JWT en clair — c'est un problème de sécurité, pas juste du bruit. La seconde se trouve dans une boucle for sur un panier : un seul passage en caisse inonderait la console de centaines de lignes. Le contexte transforme une liste de correspondances en information exploitable.

Compter les occurrences par fichier​

rg -c "console.log" --type js

Ceci affiche le nombre de correspondances par fichier — parfait pour identifier quels fichiers sources contiennent encore des instructions de debug avant une release.

Renommage en masse avec rg + sed​

ripgrep est volontairement en lecture seule (pas de mode -i d'édition sur place), mais il se marie très bien avec sed pour du refactoring en masse :

$ rg -l "oldFunctionName" --type php | xargs sed -i 's/oldFunctionName/newFunctionName/g'▋

rg -l ne liste que les noms de fichiers qui contiennent des correspondances. L'envoyer dans xargs sed -i réécrit exactement ces fichiers — ni plus, ni moins. Bien plus sûr qu'un find | xargs sed brut qui n'a aucune idée des fichiers réellement concernés.

Chercher dans plusieurs types de fichiers à la fois​

rg "API_KEY" -t php -t yaml -t sh

Plusieurs flags -t se combinent — ripgrep cherche dans tous les types correspondants en une seule passe, avec une sortie colorisée unifiée.

Limiter la profondeur de recherche​

rg "FROM" --glob "Dockerfile*" --max-depth 3

--max-depth est idéal quand vous voulez rester près du répertoire courant sans plonger dans chaque sous-répertoire imbriqué.

À retenir​

Conclusion​

Au début de cet article, je disais avoir tapé cette commande grep -rn --include="*.php" ... | grep -v vendor tellement de fois qu'elle était devenue un réflexe. Aujourd'hui, chaque fois que j'ouvre un terminal dans WSL2, je tape rg sans même y penser. L'exclusion de vendor/ est automatique, la sortie est lisible sans aucun flag et la recherche est réellement plus rapide sur les gros codebases. Entre la configuration ~/.ripgreprc, les alias de type dans ~/.zshrc, des fonctions comme rgtodo et rgenv dans ~/.zsh/fns/, et la recherche interactive rgf couverte dans un article dédié, ripgrep a cessé d'être un outil que je choisis consciemment pour devenir la colonne vertébrale invisible de ma façon de naviguer dans le code au quotidien. Si vous en êtes encore à grep nu dans votre environnement WSL2, accordez-vous vingt minutes avec ripgrep — c'est tout ce qu'il faut.