Rails.vim ---> je cherche la fonctionnalit é "Find in project"

Community FR
#1

Bonjour à tous,

Je code sous Unix, et j’utilise Vim.
J’ai bien sûr custommisé Vim avec des plugins et des scripts forts
utiles.
Par contre il me manque une fonctionnalité importante : “Find in
project”
(qui existe dans Textmate).
Je demande donc si quelqu’un a déja implémenté cette fonctionnalité sur
Vim,
et comment vous avez fait ?
Le but, c’est lorsque je croise une méthode, n’importe où dans le
projet,
avoir la possibilité de trouver facilement le fichier où la méthode est
définie (ça c’est le plus important) et aussi tous les autres fichiers,
dans
lesquels la méthode est utilisée.

Merci d’avance si quelqu’un peut me renseigner.
Happy Rails à tout le monde.

#2

Coucou,

Je n’ai pas vraiment de réponse rapide à ta question, mais veux bien que
tu
fournisse une liste des plugins et des scripts que tu as utilisé pour
customiser ton vim (voir une rapide explication de ce qu’ils rajoutent).
Ca
fait un petit moment que j’utilise vim au coup par coup pour retoucher
des
scripts ruby et rails, mais je n’ai pas encore trouvé un bon tuning pour
le
rendre vraiment productif.

Merci d’avance…

Sinon, pour donner quand même un semblant de piste pour ta question, il
y a
probablement moyen de faire un script qui utilise un grep global, mais
je ne
connais pas grand chose au scripting vim…

–
Michel B.

#3

2008/9/25 Michel B. [email protected]:

Sinon, pour donner quand même un semblant de piste pour ta question, il y a
probablement moyen de faire un script qui utilise un grep global, mais je ne
connais pas grand chose au scripting vim…

Perso utilisant git comme versionning de source, j’utilise un bon
git-grep def mamethode pour la trouver.

–
Cyril M.
http://blog.shingara.fr

#4

Bonsoir,

je suis étonné, personne n’a cité le plugin Rails.vim fait par Tim Pope
: http://rails.vim.tpope.net/. Je ne connais pas bien les
fonctionnalités, mais il me semble que gf permet d’aller dans le fichier
qui correspond à la classe dont le nom est sous le marqueur, et que
:Rfind permet de faire une recherche sur le projet.

++
Bruno M.

#5

Je n’ai pas vraiment de réponse rapide à ta question, mais veux bien que
tu
fournisse une liste des plugins et des scripts que tu as utilisé pour
customiser ton vim (voir une rapide explication de ce qu’ils rajoutent).

OK
Voici la page de doc de départ :
http://wiki.rubyonrails.org/rails/pages/HowtoUseVimWithRails

Tout n’est pas bon à prendre…J’ai testé Vimmate par exemple, mais je
n’ai
pas été convaincu.
Le plus important c’est evidemment rails.vim
Aprés, celui qui vaut le détour, c’est Vim IDE dont voici la page :
http://www.vim.org/scripts/script.php?script_id=69

Ensuite c’est une histoire de personnalisation.
Exemple : Pour éviter de taper :Rproject! dans la console, un raccourci
clavier : F8, voila c’est déja plus simple.
Voila mon .vimrc :

“”""""""""""""""""""""""""""""""""""""
“”" Parametres par defaut de rails.vim
“”""""""""""""""""""""""""""""""""""""
set nocompatible " We’re running Vim, not Vi!
syntax on " Enable syntax highlighting
filetype plugin indent on " Enable filetype-specific indenting and
plugins
" Couleur de fond de l’ecran
colorscheme desert

" Load matchit (% to bounce from do to end, etc.)
runtime! macros/matchit.vim

augroup myfiletypes
" Clear old autocmds in group
autocmd!
" autoindent with two spaces, always expand tabs
autocmd FileType ruby,eruby,yaml set ai sw=2 sts=2 et
autocmd FileType php set ai sw=2 sts=2 et
augroup END

“”""""""""""""""""""""""""""""""
“”" Automatic jumping to classes
“”""""""""""""""""""""""""""""""
set path+=/home/fred/ESPACE_DE_TRAVAIL/ADN/app/**
set path+=/home/fred/ESPACE_DE_TRAVAIL/ADN/lib/**
" set path+=/path/to/your/rails-application/app/**
" set path+=/path/to/your/rails-application/lib/**
set suffixesadd=.rb
set includeexpr+=substitute(v:fname,‘s$’,’’,‘g’)
" or you can add substitution pattern s/ies$/y/g, s/ves$/f/g like this:
" set
includeexpr+=substitute(substitute(substitute(v:fname,‘s$’,’’,‘g’),‘ie$’,‘y’,‘g’),‘ve$’,‘f’,‘g’)

“”"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
“”" Activation des touches F11 et F12 (Avoiding MVC same-name clashes)
“”"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
map :set suffixesadd=.rbgf
map :set suffixesadd=.rhtmlgf

“”""""""""""""""""""""""""""""
“”" Vim 7 ruby omni completion
“”""""""""""""""""""""""""""""
autocmd FileType ruby,eruby set omnifunc=rubycomplete#Complete
autocmd FileType ruby,eruby let g:rubycomplete_buffer_loading = 1
autocmd FileType ruby,eruby let g:rubycomplete_rails = 1
autocmd FileType ruby,eruby let g:rubycomplete_classes_in_global = 1

“”"""""""""""""""""""""""""""""
“”" Raccourcis persos / Aliases
“”"""""""""""""""""""""""""""""
"Ecrit <%= %> et positionne le curseur au milieu
:map ùù ^i<%= %>
"Commente la ligne et positionne le curseur sur la ligne en dessous
:map k ^i#j
"Ecrit une balise

:map bb i

"Ouvre un projet Rails
nnoremap :Rproject!

Le résultat en screenshot…
Sinon il y a moyen d’avoir une console irb, un écran avec les logs, on
peut
faire un push sur svn,…
Il y a des tas de choses à faire avec Vim, c’est completement
hallucinant.
Mais bon, comme dirait mon chef de projet, pendant que je customise mon
IDE,
je ne code pas le projet…et ça craint !
Donc je me contente en général de lancer plusieurs terminaux, dans
lesquels
je fais les commandes à la main une fois pour toute.
(exemple, j’ai un terminal sur lequel j’ai lancé un tail -f
log/development.log, et quand j’en ai besoin, je fais ctrl+alt+F2 pour
le
visionner…)

Sinon, pour revenir à ma question, Vim est capable de retrouver une
méthode
ou une balise, à l’intérieur des autres fichiers.
La preuve c’est que c’est ce que fait, parfaitement bien, la
fonctionnalité
d’autocomplétion. (Ctrl + n)
Par contre ça me dit pas dans quel fichier elle a trouvé la balise ou la
méthode…arg
Donc si quelqu’un l’a déja fait ?

Et merci au passage pour le coup du git-grep, car c’est quand meme une
piste
plutot pas mal !
Si ça permet aussi de trouver des méthodes qui ont existé, par le passé,
ça
peut etre formidable aussi.
Genre une astuce qui marchait bien, mais qu’on a effacé parcequ’il n’y
en
avait plus besoin, et puis un jour on en a à nouveau besoin, mais on se
rappelle plus comment on avait fait…

Bon allez, je vous laisse, faut que j’aille coder…
Byebye
FJ

Le 25 septembre 2008 11:20, Cyril M. [email protected] a
écrit :

#6

Bon beh voici une solution rapide et qui marche :
Dans la console, (Ã la racine du projet) et je tape :
$ grep “def ma_methode” -r . --exclude=.svn --exclude=.log
—> Ca renvoit le fichier dans lequel la méthode est définie

Ensuite, sans le “def” :
$grep “ma_methode” -r . --exclude=.svn --exclude=.log
—> Renvoit tous les fichiers dans lesquels la méthode est utilisée

Je dirai que pour faire mieux faudrait

  • Filtrer les répertoires (pour ne pas chercher dans les .svn, le logs,
    etc…) avec un find
  • Piper la réponse vers le grep
  • Mettre le script dans le .vimrc
  • Faire un raccourci pour l’exécuter, en détectant au passage la méthode
    se
    trouve sous le curseur…
    Si je trouve le temps de m’amuser à ça, je vous partage le résultat,
    promis
    :wink:

Le 26 septembre 2008 09:26, Frédéric Jay [email protected] a écrit :

#7

je suis étonné, personne n’a cité le plugin Rails.vim fait par Tim Pope
Beh si, il est cité dans le lien que j’ai donné.

il me semble que gf permet d’aller dans le fichier
qui correspond à la classe dont le nom est sous le marqueur
Pas vraiment, en fait ça cherche un fichier qui porte le nom qui est
sous
le marqueur, et non pas le fichier qui contient la méthode qui est
sous le
marqueur.
Nuance…!

Rfind pareil, ça cherche le nom du fichier, et non pas par ce qu’il
contient…

Le 25 septembre 2008 23:14, Bruno M. [email protected] a écrit :

#8

Frédéric Jay a écrit :

Bon beh voici une solution rapide et qui marche :
Dans la console, (à la racine du projet) et je tape :
$ grep “def ma_methode” -r . --exclude=.svn --exclude=.log
—> Ca renvoit le fichier dans lequel la méthode est définie

rak (http://rak.rubyforge.org/) me semble plus approprié ici (entre autre
il
exclut automatiquement les repertoires/fichiers des scms)

#9

Sinon tu as :

$ find . -name *.rb | xargs grep “def ma_methode”

Ca te permet de ne chercher que dans les .rb

xargs prend le contenu de l’entrée standard (donc la liste des .rb
trouvés) pour le passer en paramètre du grep … très pratique !
Tu peux même rajouter l’option -l au grep pour n’avoir que la liste
des fichiers qui matchent. En jouant avec les options de grep tu peux
également avoir le numéro de ligne de chaque occurence, ou simplement
le nombre d’occurences, etc.

a+
Manu

Le 1 octobre 2008 16:19, Frédéric Jay [email protected] a écrit :

#10

$ find . -name *.rb | xargs grep “def ma_methode”

On peut rajouter l’option -H à grep qui permet de forcer à donner le nom
du
fichier, meme quand il n’y en a qu’un seul (ce sera le cas si il n’y a
qu’un
fichier .rb dans l’arborescence).

gUI

–
Pour la santé de votre ordinateur, préférez les logiciels libres.
Lire son mail : http://www.mozilla-europe.org/fr/products/thunderbird/
Browser le web : http://www.mozilla-europe.org/fr/products/firefox/
Suite bureautique : http://fr.openoffice.org/

#11

find a une option --exec

find . -name ‘*.rb’ --exec grep “def ma_methode”

2008/10/1 Guillaume B. [email protected]:

$ find . -name *.rb | xargs grep “def ma_methode”

On peut rajouter l’option -H à grep qui permet de forcer à donner le nom du
fichier, meme quand il n’y en a qu’un seul (ce sera le cas si il n’y a qu’un
fichier .rb dans l’arborescence).

donne aussi le numéro de la ligne :slight_smile:

–
Cyril M.
http://blog.shingara.fr

#12

Le 2 octobre 2008 14:12, Emmanuel B. a écrit :

C’est vrai ! Mais j’ai un petit faible pour xargs (c’est très subjectif !!!).
L’avantage c’est qu’on peut rajouter un petit “grep -v” avant xargs :

Pas que subjectif. L’option --exec va faire en sorte que find
crée un nouveau processus par fichier matché. Ce qui va se ressentir
côté performances et rapidité p/r à find + xargs.

– Jean-François.

–
ça dépend

http://twitter.com/underflow_

#13

Merci pour vos réponses.
Voila le résultat final, dans le .vimrc :

:map :call FindMethodInProject()
:map :call FindMotifInProject()

function! FindMethodInProject()
let motif = expand(’’)
split
enew
execute “normal iLa méthode est définie dans ce(s) fichier(s)
:\n”
execute “:r !find . | grep -v ‘.swp’ | grep -v ‘.svn’ | xargs
grep
-l ‘def " . motif . "’”
endfunction

function! FindMotifInProject()
let motif = expand(’’)
split
enew
execute “normal iLe motif a été trouvé dans ce(s) fichier(s)
:\n”
execute “:r !find . | grep -v ‘.swp’ | grep -v ‘.svn’ | grep -v
‘/log/’ | grep -v ‘/doc/’ | xargs grep -l '” . motif . “’”
endfunction

Usage :

  • Placer le curseur sur une méthode
  • Touche F3 renvoit, dans un ecran splitté, le ou les noms des fichiers
    où
    est définie la méthode
  • Touche F4 renvoit, dans un ecran splitté, la liste des fichiers où est
    utilisée la méthode (marche aussi pour n’importe quel motif)

Commentaires :

  • C’est rapide et ça marche bien.
  • Ca peut etre amélioré par plein d’autres trucs…Perso, ça me va comme
    ça.
  • Je confirme que l’emploi de --exec marche, mais moins vite :wink:
  • Merci à SebTheMonster qui m’a aidé à écrire le script :wink:

Questions :

  • Si quelqu’un sait comment éviter tous les | entre les grep -v, je ne
    suis
    pas arrivé à le faire en 1 seule commande.
  • Avant d’afficher le résultat, Vim me répond “Le shell a retourné 123”
    Est ce que quelqu’un peut me dire ce que ça signifie ? Et comment ne pas
    etre obligé d’appuyer sur une touche pour voir la suite ?

FJ

Le 2 octobre 2008 21:06, Jean-François Trân [email protected] a
écrit
:

#14

Le 10 octobre 2008 11:04, Frédéric Jay a écrit :

  • Si quelqu’un sait comment éviter tous les | entre les grep -v, je ne suis
    pas arrivé à le faire en 1 seule commande.

grep -E ou egrep

exemple :

grep -v -E ‘.svn|.swp’

 -- Jean-François.

–
Les 50 ans du Lisp : http://www.lisp50.org

http://twitter.com/underflow_

#15

Nikel, merci Jean-François.
Résultat :

:map :call FindMethodInProject()
:map :call FindMotifInProject()

function! FindMethodInProject()
let motif = expand(’’)
split
enew
execute “normal iLa méthode est définie dans ce(s) fichier(s)
:\n”
execute “:r !find . | egrep -v ‘.swp|.svn’ | xargs grep -l ‘def
" .
motif . "’”
endfunction

function! FindMotifInProject()
let motif = expand(’’)
split
enew
execute “normal iLe motif a été trouvé dans ce(s) fichier(s)
:\n”
execute “:r !find . | egrep -v ‘.swp|.svn|/log/|/doc/’ | xargs
grep
-l '” . motif . “’”
endfunction

FJ

Le 10 octobre 2008 11:15, Jean-François Trân [email protected] a
écrit
:

#16

C’est vrai ! Mais j’ai un petit faible pour xargs (c’est très subjectif
!!!).
L’avantage c’est qu’on peut rajouter un petit “grep -v” avant xargs :

$ find . -name *.rb | grep -v
mon_repertoire_que_je_ne_veux_pas_scanner | xargs grep “def
ma_methode”

Au passage le backslash devant le *.rb est très important car si on ne
le mets pas le * sera interprété avant le passage en argument et ca ne
donnera pas le même résultat.
Donc soit on backslashe le , soit on mets des guillemets : ".rb"

a+
Manu

Le 1 octobre 2008 22:23, Cyril M. [email protected] a écrit :