Vim fr:Éditeur Pour Programmeurs

Introduction

Vim est fortement utilisé par les programmeurs. Les fonctionnalités, la facilité d'utilisation et la flexibilité de Vim en font un bon choix pour les personnes qui écrivent beaucoup de code. Cela n'est pas étonnant vu qu'écrire du code implique beaucoup d'édition.

Laissez-moi insister sur le fait que les capacités à saisir sont très importantes pour un programmeur. Si la discussion précédente ne vous a pas convaincus, j'espère que cet article de Jeff Atwood sur 'We Are Typists First, Programmers Second' arrivera à vous convaincre.

Si vous n'avez pas d'expérience en programmation, vous pouvez sauter ce chapitre.

Pour ceux qui adorent programmer, allons-y et voyons comment Vim peut vous aider dans l'écriture de code.

Des choses simples

La fonctionnalité la plus simple de Vim que vous pouvez utiliser pour vous aider est la coloration syntaxique. Cela vous permet de visualiser, c'est à dire "voir" votre code, ce qui vous aide à écrire et lire votre code plus vite et aussi vous permet d'éviter des erreurs grossières.

Coloration syntaxique

Supposons que vous éditez un fichier de syntaxe de Vim, lancez :set filetype=vim et voyez comment Vim ajoute de la couleur. De la même manière, si vous éditez un fichier Python, lancez :set filetype=python.

Pour voir la liste des langages disponibles types, consultez lle répertoire $VIMRUNTIME/syntax/.

Astuce

Si vous voulez voir la puissance de la coloration syntaxique pour n'importe quel shell Unix, pipez-le dans Vim, par exemple svn diff | vim -R -. Notez le tiret à la fin, qui indique à Vim de lire le texte à partir de son entrée standard.

Indentation intelligente

Le code d'un programmeur expérimenté est en général indenté proprement, ce qui rend le code "uniforme" et la structure du code visuellement plus apparente. Vim peut vous aider en faisant l'indentation pour vous, et ainsi vous pouvez vous concentrer sur votre code.

Si vous indentez une ligne particulière et voulez que les lignes suivantes soient indentées au même niveau, vous pouvez utiliser la commande:set autoindent.

Si vous démarrez un nouveau bloc de code, et que vous voulez que la prochaine ligne soit automatiquement indentée au niveau suivant, vous pouvez utiliser le réglage :set smartindent. Notez que le comportement de ce réglage dépend du langage de programmation utilisé.

Rebond

Si votre langage de programmation utilise des accolades pour délimiter des lignes de code, placez votre curseur sur l'une des accolades, et tapez % pour aller à l'autre accolade. Cette clé de rebond vous permet de vous déplacer rapidement entre le début et la fin d'un bloc.

Les commandes du Shell

Vous pouvez lancer une commande du shell à l'intérieur de Vim en utilisant :!.

Par exemple, si la commande date est disponible sur votre système, lancez :!date et vous devriez voir la date et heure s'afficher.

Cela est utile quand vous voulez vérifier quelque chose parmi vos fichiers, par exemple, vérifier quels fichiers sont dans votre répertoire courant, en utilisant :!ls ou :!dir et ainsi de suite.

Si vous voulez accéder un shell à part entière, lancez :sh.

Nous pouvons utiliser cela pour lancer des filtres externes sur le texte édité. Par exemple, si vous avez des lignes à trier, vous pouvez lancer :%!sort, cela envoie le texte courant à la commande sort dans le shell et le résultat de cette commande remplace le contenu actuel du fichier.

Se déplacer

Il y a de nombreuses façons de se déplacer dans le code.

• Positionnez le curseur sur un nom de fichier dans le code et tapez gf pour ouvrir le fichier.
• Positionnez le curseur sur un nom de variable et tapez gd pour aller sur la définition locale du nom de vriable. gD fait la même chose en commençant à chercher à partir du début du fichier.
• Utilisez ]] pour aller au { suivant dans la première colonne. Il y a beaucoup de déplacements similaires - voyez :help object-motions pour les détails.
• Voyez :help 29.3, :help 29.4, et :help 29.5 pour de telles commandes. Par exemple, [I va afficher toutes les lignes qui contiennet le mot-clé qui est sous le curseur !

Se déplacer dans des parties du code

Le système de fichiers

Utilisez :Vex ou :Sex pour naviguer dans vos fichiers avec Vim et ouvrir les fichiers voulus.

ctags

Nous avons vu comment réaliser des simples déplacements à l'intérieur d'un fichier, mais comment se déplacer entre différents fichiers et avoir des références croisées entre ces fichiers ? Nous allons utiliser des tags pour accomplir cela.

Pour une navigation simple à l'intérieur du fichier, nous pouvons utiliser le plugin taglist.vim.

Taglist in action

1. Installez le programme Exuberant ctags .
2. Installez le plugin taglist.vim. Consultez les détails d'installation sur la page du script.
3. Lancez :TlistToggle pour ouvrir la fenêtre taglist. Voila, vous pouvez naviguer à travers des parties de votre programme comme des macros, typedefs, variables et fonctions.
4. Vous pouvez utiliser :tag foo pour aller à la définition de foo.
5. Placez votre curseur sur n'importe quel symbole et appuyez sur ctrl-] pour aller à la définition de ce symbole.
   • Tapez ctrl-t pour revenir au code précédent que vous lisiez.
6. Utilisez ctrl-w ] pour aller à la définition du symbole dans une fenêtre.
7. Utilisez :tnext, :tprev, :tfirst, :tlast pour vous déplacer entre les tags correspondants.

Notez que Ctags supporte 33 langages de programmation au moment de la rédaction de cet article, et peut facilement être étendu pour d'autres langages.

Voyez :help taglist-intro pour les détails.

cscope

Pour pouvoir se déplacer dans les définitions à travers les fichiers, nous avons besoin d'un programe comme cscope. Cependant, comme le nom le laisse penser, ce programme fonctionne seulement pour le langage C.

cscope in action

1. Installez cscope. Consultez :help cscope-info et :help cscope-win32 pour l'installation.
2. Copiez cscope_maps.vim dans votre répertoire ~/.vim/plugin/.
3. Revenez dans le répertoire de votre code source et lancez cscope -R -b pour reconstruire (b pour 'b'uild) la base de données de manière 'r'écursive pour tous les sous-répertoires.
4. Redémarrez Vim et ouvrez un fichier source.
5. Lancez :cscope show pour confirmer qu'il y a une connection cscope créée.
6. Lancez :cscope find symbol foo pour trouver le symbole foo. Vous pouvez abréger cette commande à :cs f s foo.

Vous pouvez aussi :

• Trouver cette définition - :cs f g
• Trouver les fonctions appelées par cette fonction - :cs f d
• Trouver les fonctions appelant cette fonction - :cs f c
• Trouver cette chaîne de caractères - :cs f t
• Trouver ce motif egrep - :cs f e

Voyez :help cscope-suggestions pour des suggestions sur l'usage de cscope avec Vim.

Aussi, le Source Code Obedience plugin est digne d'intérêt car il fournit des raccourcis au-dessus de cscope/ctags.

Tant que nous parlons du langage C, le plugin c.vim peut être très pratique.

Compilateur

Nous avons déjà vu cela dans le chapitre précédent concernant :make pour les programmes que nous écrivons, donc nous ne nous répèterons pas ici.

Ecriture facile

Omnicomplétion

L'une des fonctionnalités les plus demandées qui a été ajoutée dans la version 7 de Vim est l'"omnicomplétion", quand le texte peut être auto-complété en fonction du contexte courant.

Par exemple, si vous utilisez un nom de variable long, et que vous utilisez ce nom de manière répétitive, vous pouvez utiliser un raccourci clavier pour demander à Vim de s'auto-compléter et il fera le reste.

Vim fait cela avec des ftplugins, en particulier ceux avec le nom ftplugin/<language>complete.vim comme pythoncomplete.vim.

Prenons un exemple avec un programme Python simple:

def hello():
    print 'hello world'
 
def helpme():
    print 'help yourself'

Omni-completion in action

Après avoir écrit ce programme, ouvrez une nouvelle ligne dans ce fichier, tapez 'he' puis ctrl-x ctrl-o qui vous montrera les suggestions pour l'autocomplétion.

Si vous obtenez une erreur du type E764: Option 'omnifunc' is not set, alors lancez :runtime! autoload/pythoncomplete.vim pour charger le plugin d'omnicomplétion.

Pour éviter de le faire à chaque fois, vous pouvez ajouter la ligne suivante dans votre fichier ~/.vimrc:

autocmd FileType python runtime! autoload/pythoncomplete.vim

Vim utilisera automatiquement la première suggestion, vous pouvez aller à la sélection précédente ou suivante avec ctrl-n et ctrl-p respectivement.

Si vous vouler arrêter d'utiliser l'omnicomplétion, appuyez simplement sur esc.

Consultez :help new-omni-completion pour les détails sur les autres langages supportés (C, HTML, JavaScript, PHP, Python, Ruby, SQL, XML, ...) et comment créer vos propres scripts d'omnicomplétion.

Note

Si vous êtes plus à l'aise avec les touches fléches en haut et fléche en bas pour choisir dans la liste d' omnicomplétion, voyez Vim Tip 1228 pour valider cela.

Je préfère utiliser un simple ctrl-space au lieu de la combinaison peu pratique ctrl-x ctrl-o. Pour obtenir ce résultat, placez dans votre vimrc:

imap <c-space> <c-x><c-o>

A ce sujet, le plugin PySmell peut aider les utilisteurs de Vim qui codent en Python.

Utiliser des Snippets

Les snippets sont des fragments de code que vous avez tendance à écrire de manière répétitive. Comme tout bon programmeur paresseux, vous pouvez utiliser un plugin pour vous aider à faire cela. Dans ce cas, nous utilisons le très étonnant plugin SnippetsEmu.

1. Téléchargez le plugin snippetsEmu.
2. Créez votre répertoire ~/.vim/after/ s'il n'existe pas déjà.
3. Démarrez Vim en ajoutant ce nom de plugin à la ligne de commande. Par exemple, démarrez Vim en tant que vim snippy_bundles.vba
4. Lancez :source %. Le 'vimball' va maintenant se décompresser et copier de nombreux fichiers dans les répertoires prévus.
5. Faites de même pour snippy_plugin.vba

Maintenant, essayons d'utiliser ce plugin.

1. Ouvrez un nouveau fichier appelé, par exemple, test.py.

2. Tapez d, e, f et ensuite <tab>.

3. Voila! Regardez comment snippetsEmu a créé une structure à partir de votre fonction. Vous devez maintenant voir cela dans votre fichier :

def <{fname}>(<{args}>):
    """
    <{}>
    <{args}>"""
    <{pass}>
    <{}>

Note

Au cas où vous voyez def<tab> et rien ne se passe, alors peut-être que le snippets plugin n'est pas chargé. Lancez :runtime! ftplugin/python_snippets.vim et voyez si c'est mieux.

4. Votre curseur est maintenant sur le nom de la fonction, par exemple fname.

5. Tapez le nom de la fonction, par exemple test.

6. Tapez <tab> et le curseur va automatiquement aller aux arguments. Appuyez à nouveau sur Tab pour aller à l'item suivant à remplir.

7. Maintenant saisissez un commentaire: Just say Hi

8. Tab à nouveau et tapez print 'Hello World'

9. Appuyez sur tab

10. Votre programme est terminé !

Vous devriez voir :

def test():
    """
    Just say Hi
    """
    print 'Hello World'

La meilleure chose est que SnippetsEmu valide une convention standard à suivre et que personne dans l'équipe ne l' 'oublie'.

Créer des Snippets

Voyons comment créer nos propres snippets.

Considérons le cas où j'écris de manière répétitive ce genre de code en ActionScript3:

private var _foo:Object;
 
public function get foo():Object
{
    return _foo;
}
 
public function set foo(value:Object)
{
    _foo = value;
}

Cela est une simple combinaison getter/setter en utilisant une variable de support (backing variable). Le problème est qu'il y a beaucoup de code à écrire de manière répétitive. Voyons comment automatiser cela.

Le langage SnippetsEmu attend st comme tag de départ et et comme tag de fin - ce sont les mêmes symboles de type flèche entre lesquels nous avons saisi notre code.

Commençons avec une exemple simple.

exec "Snippet pubfun public function ".st.et.":".st.et."<CR>{<CR>".st.et."<CR>}<CR>"

Ajoutez la ligne du dessus à votre ~/.vim/after/ftplugin/actionscript_snippets.vim.

Maintenant ouvrez un nouveau fichier, disons, test.as et tapez pubfun puis <tab> et voyez l'expansion :

public function <{}>:<{}>
{
 
}

Le curseur va se positionner sur le nom de la fonction, tab pour saisir le return type de la fonction, tab à nouveau pour saisir le corps de la fonction.

Revenons à notre problème initial, voilà ce à quoi je suis arrivé :

exec "Snippet getset private var _".st."name".et.";<CR><CR>public function get ".st."name".et."():".st."type".et."<CR>{<CR><tab>return _".st."name".et.";<CR>}<CR><CR>public function set ".st."name".et."(value:".st."type".et.")<CR>{<CR><tab>_".st."name".et." = value;<CR>}<CR>"

Note

Tous les snippets pour ce plugin doivent être saisis sur une seule ligne. C'est une limitation technique.

Suivez la même procédure vue du précédemment pour utiliser ce nouveau snippet:

1. Ajoutez cette ligne à votre ~/.vim/after/ftplugin/actionscript_snippets.vim.

2. Ouvrez un nouveau fichier comme test.as.

3. Tapez getset puis <tab> et vous verrez ceci :

private var _<{name}>;
 
public function get <{name}>():<{type}>
{
        return _<{name}>;
}
 
public function set <{name}>(value:<{type}>)
{
        _<{name}> = value;
}

4. Tapez color and puis <tab>. Notez que le nom de variable color est remplacé de partout.

5. Tapez Number puis <tab>. Le code doit maintenant ressembler à :

private var _color;
 
public function get color():Number
{
        return _color;
}
 
public function set color(value:Number)
{
        _color = value;
}

Notez comme nous avons réduit le nombre de touches à saisir ! Nous avons remplacé environ 11 lignes de code répétitif par un simple script Vim.

Nous pouvons continuer à ajouter de tels snippets pour rendre le code plus paresseux, cela nous aidera à nous concentrer sur le véritable travail d'un programmeur.

Voyez :help snippets_emu.txt pour plus de détails (ce fichier d'aide sera disponible seulement après l'installation du plugin).

IDE

Vim peut être utilisé en tant qu'IDE avec l'aide de quelques plugins.

Le Projet plugin

Le Projet plugin est utilisé pour créer un Project-manager kind of usage pour Vim.

1. Téléchargez project plugin.
2. décompressez-le dans votre répertoire ~/.vim/ .
3. Lancez :helptags ~/.vim/doc/.
4. Téléchargez le code source de Vim à partir de http://www.vim.org/subversion.php
5. Lancez :Project. Une sidebar va s'ouvrir à gauche qui sera notre 'fenêtre de project'.
6. Lancez \\c (backslash suivi de 'c')
7. Répondez aux options suivantes
   • Nom de entry, say 'vim7_src'
   • Répertoire, disons C:\\repo\\vim7\\src\\
   • CD option, comme le répertoire ce-dessus
   • Filter option, disons *.h *.c
8. Vous verrez la sidebar se remplir avec la liste des fichiers qui correspondent au filtre dans le répertoire indiqué.
9. Utilisez les touches fléchées pour vous déplacer dans la liste des fichiers, puis appuyez sur Entrée pour ouvrir le fichier dans la fenêtre principale.

Cela vous donne l'interface typique d'un IDE, la bonne chose étant qu'il n'y a pas de fichiers de configuration capricieux. La fonctionnalité du Projet plugin's est simple et évidente.

Vous pouvez utiliser les commandes standards de dépliement/repliement pour ouvrir et fermer les projets et leurs détails.

Vous pouvez aussi lancer des scripts au début et à la fin d'un projet, cela vous aide pour définir le PATH ou les options du compilateur et ainsi de suite.

Voyez :help project.txt pour plus de détails.

Exécuter du code à partir du texte

Vous pouvez exécuter du code directement à partir de Vim en utilisant des plugins comme EvalSelection.vim ou des plugins plus simples comme inc-python.vim.

intégration de SCM

Si vous commencez à éditer un fichier, vous pouvez même forcer une vérification automatique à partir de Perforce en utilisant le plugin perforce. De la même manière, il y a un CVS/SVN/SVK/Git plugin d'intégration.

Plus

Pour explorer plus de plugins afin d'avoir un comportement proche d'un IDE dans Vim, voyez :

• Vim Tip: Utilisez Vim comme un IDE tout en un
• C++/Python liste de plugins Vim+IDE

Il y a des plugins spécifiques à des langages qui peuvent vous aider à faire des choses délicates. Par exemple, pour Python, les plugins suivants peuvent être utiles :

• SuperTab vous permet d'appeler l'omni-complétion en appuyant juste sur Tab puis en utilisant les touches fléchées pour sélectionner une option.
• python_calltips montre une fenêtre en bas avec une liste de possibilités pour la complétion. Ce qui est bien ici comparé avec l'omni-complétion, c'est que vous voyez la documentation pour chacune des possibilités.
• VimPdb vous aide à débugger des programmes Python à partir de Vim.

Ecrire vos propres plugins

Vous pouvez écrire vos propres plugins pour étendre Vim de quelque manière pour ce que vous voulez. Par exemple, voici une tâche que vous pouvez prendre :

Ecrire un plugin Vim qui prend le mot courant et ouvre un navigateur avec la documentation pour ce mot (ce mot peut être un nom de fonction, ou un nom de classe).

Si vous ne voyez pas du tout comment faire cela, regardez "Online documentation for word under cursor" tip at the Vim Tips wiki.

J'ai étendu la même astuce et je l'ai rendue plus générique :

" Ajoutez les lignes suivantes à votre fichier ~/.vimrc pour activer la documentation en ligne
" Inspiration: http://vim.wikia.com/wiki/Online_documentation_for_word_under_cursor
 
function Browser()
    if has("win32") || has("win64")
        let s:browser = "C:\\Program Files\\Mozilla Firefox\\firefox.exe -new-tab"
    elseif has("win32unix") " Cygwin
        let s:browser = "'/cygdrive/c/Program\ Files/Mozilla\ Firefox/firefox.exe' -new-tab"
    elseif has("mac") || has("macunix") || has("unix")
        let s:browser = "firefox -new-tab"
    endif
 
    return s:browser
endfunction
 
function Run(command)
    if has("win32") || has("win64")
        let s:startCommand = "!start"
        let s:endCommand = ""
    elseif has("mac") || has("macunix") " TODO Untested on Mac
        let s:startCommand = "!open -a"
        let s:endCommand = ""
    elseif has("unix") || has("win32unix")
        let s:startCommand = "!"
        let s:endCommand = "&"
    else
        echo "Don't know how to handle this OS!"
        finish
    endif
 
    let s:cmd = "silent " . s:startCommand . " " . a:command . " " . s:endCommand
    " echo s:cmd
    execute s:cmd
endfunction
 
function OnlineDoc()
    if &filetype == "viki"
        " Dictionary
        let s:urlTemplate = "http://dictionary.reference.com/browse/<name>"
    elseif &filetype == "perl"
        let s:urlTemplate = "http://perldoc.perl.org/functions/<name>.html"
    elseif &filetype == "python"
        let s:urlTemplate = "http://www.google.com/search?q=<name>&domains=docs.python.org&sitesearch=docs.python.org"
    elseif &filetype == "ruby"
        let s:urlTemplate = "http://www.ruby-doc.org/core/classes/<name>.html"
    elseif &filetype == "vim"
        let s:urlTemplate = "http://vimdoc.sourceforge.net/search.php?search=<name>&docs=help"
    endif
 
    let s:wordUnderCursor = expand("<cword>")
    let s:url = substitute(s:urlTemplate, '<name>', s:wordUnderCursor, 'g')
 
    call Run(Browser() . " " . s:url)
endfunction
 
noremap <silent> <M-d> :call OnlineDoc()<CR>
inoremap <silent> <M-d> <Esc>:call OnlineDoc()<CR>a

Accéder aux Bases de Données

Vous pouvez accéder à 10 bases de données différentes d'Oracle à MySQL en passant par PostgreSQL ou Sybase ou encore SQLite, toutes à partir de Vim, en utilisant le plugin dbext.vim. La meilleure chose est que ce plugin va vous aider à éditer du SQL écrit à l'intérieur de PHP, Perl, Java, etc. et vous pouvez exécuter directement du SQL même si il est embarqué dans un langage de programmation différent et s'il vous demande des valeurs pour des variables.

Récapitulatif

Nous avons appris comment Vim peut être utilisé pour programmer avec l'aide de différents plugins et réglages. Si nous avons besoin d'une fonctionnalité, nous pouvons écrire nos propres plugins (comme nous l'avons vu dans le chapitre Scripter).

Deux bonnes sources de discussions sur ce sujet sont Stack Overflow et Peteris Krumins's blog.