vim

Vendredi 12 juin 5 12 /06 /Juin 23:45
Pour tous les symfonistes (et quelques autres), manipuler des fichiers yml d'une bonne centaine de lignes minimum est une activité normale et quotidienne, indispensable pour se mettre de bonne humeur au réveil. Pour ceux qui ne connaitraient pas le parser Yaml, il s'agit d'un animal susceptible, ne tolérant que les indentations de 2 espaces et haïssant les tabulations au point de refuser de parcourir un fichier en contenant (même une petite). Il est assez facile de configurer Vim une bonne fois pour toute afin de proposer les options suivantes :

- indentation par défaut : 2 espaces
- transforme les tabulations en 2 espaces
- affiche les caractères de fin de ligne, les tabulations et espaces entre le dernier caractère et la fin de la ligne

set tabstop=2

      set shiftwidth=2

      set expandtab

      set listchars=eol:¤,trail:-


Les listchars ne seront affichés que si vous le demandez avec un «set list» pour le désactiver : «set nolist»

Cela évite les problèmes les plus courants. Par contre, dès que vos Yml deviennent consistants, il devient délicat de repérer les niveaux d'imbrication des blocs. Il est pour cela possible de surligner la ligne et la colonne courante pendant le mode édition. Vim vous permet en effet de modifier sa conf suite à un évènement. Demandez le surlignage lors du passage en mode édition et seulement pour les fichiers Yml pour les colonnes :

" Changement de configuration lors des transitions

       " mode commande & mode insertion

       autocmd insertLeave * set nocursorline

       autocmd insertEnter * set cursorline

       autocmd insertLeave *.yml set nocursorcolumn

       autocmd insertEnter *.yml set cursorcolumn

       "  Le choix des couleurs...

       highlight CursorLine                    cterm=none ctermbg=DarkBlue

       highlight CursorColumn                  cterm=none ctermbg=DarkRed



Et voila le travail, en mode insertion, les lignes sont surlignées en bleu et dans les fichiers Yml uniquement, la colonne courante est marquée en rouge pour permettre de voir rapidement le niveau d'indentation des blocs :


Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 0 commentaires
Jeudi 15 janvier 4 15 /01 /Jan 23:00
Bonsoir à tous,

D'abord la basherie

entre deux articles sur Doctrine, je profite de quelques minutes de répis pour vous soumettre (enfin) la basherie dont je me sers depuis quelques semaines maintenant : la récupération des arguments de la ligne de commande précédente.

Vous pouvez récupérer de façon simple à l'aide de l'opérateur !:n (ou n est un entier) le nième argument de la ligne de commande précédente. C'est très pratique car d'une commande à l'autre on se sert souvent deux fois de mêmes arguments, typiquement, bouger un fichier et faire un lien symbolique dessus :
shell$ mv frontend.php frontend_prod.php
shell$ ln -s frontend_dev.php !:1
ln -s frontend_dev.php frontend.php

Le shell est en plus assez sympa pour vous afficher l'expansion réalisée sous votre commande, on ne pourra pas dire que bash n'est pas user-friendly sur le coup.

Puis les bouts de Vim

Deux nouvelles choses sont venues agrémenter ma vie de Vimiste ces derniers mois. La première et pas des moindres dans mon travail de symfoniste est l'utilisation des marqueurs majuscules. Les marqueurs majuscules fonctionnent exactements comme leurs homonymes minuscules à part qu'ils ont la particularité d'être persistants et multi-fichiers ... je m'explique : une fois placés, à l'aide d'un «mX» ou X est le marqueur, les marqueurs suivants par exemple dans un projet symfony :

marqueur pseudo fichier
S Schéma /config/schema.yml
F Fixtures /data/fixtures/fixtures.yml
A Action /apps/appli_courante/modules/module_courant/actions/actions.class.php
R Routing /apps/appli_courante/config/routing.yml

Etc etc ... Cela veut dire que si je veux jeter un coup d'oeil ou modifier le routing, un coup de «'R» voila le fichier chargé dans mon éditeur. Imbattable et cela ne pose aucun problème avec l'utilisation de Project.

 Les admins système préfèreront sans doute mettre des marqueurs sur les fichiers de conf d'Apache ou Postgresql en choisissant judicieusement les marqueurs A et P par exemple ... Comme ces marqueurs sont persistants il est inutile de les remettre à chaque fois que vous lancez Vim.

Deuxième petite chose intéressante : la navigation entre les onglets grâce à «gt» et «gT» (Go Tab) qui facilite quand même grandement la vie.

@bientôt.
Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 3 commentaires
Samedi 15 novembre 6 15 /11 /Nov 21:39
Tout d'abord le vrac. Le mois de novembre est assez actif au niveau de la communauté symfony avec la préparation de la sortie de la version 1.2 et l'annonce de toutes les belles choses qu'elle apporte. On pourrait croire qu'avec cela en tête je passe toutes mes soirées à clearer du cache, hé bien non. Je viens d'ajouter une ligne à la longue liste des trucs captivants qui peuvent prendre du temps en soirée et en week end : la confection des pâtes.


Pour les raviolis, aujourd'hui la farce (trouvée sur internet) : épinards, ail, ricotta et parmesan. Le tout fond pendant la cuisson des pâtes, c'est une tuerie.

Les plus assidus d'entre vous auront remarqué que j'ai écrit les 2 derniers articles en anglais. J'ai en effet remarqué dans les stats que de plus en plus de lecteurs utilisent google translation pour lire les articles à dominante technique. J'ai pris la décision de publier les articles purement techniques en anglais. Ce n'est pas le cas de ma bafouille aujourd'hui puisque je vous propose un instant de détente en jouant avec la coloration dans Vim.

Pourquoi colorier Vim ?
Comme toujours dans Vim, le but est d'aller plus vite. Aller plus vite ça passe aussi par mettre en valeur  ce qui est pertinent. Je ne parle pas ici de la coloration syntaxique du code mais bien de ce que nous devons rendre plus ou moins visible à l'écran. La définition d'un jeu de définition d'éléments de présentation s'appelle dans vim un colorscheme. Il en existe un certain nombre par défaut dans Debian, vous pouvez les voir et en changer en tapant «:colorscheme <TAB>». En appuyant plusieurs fois sur la touche <TAB> vous verrez défiler la liste des colorschemes. Appuyez sur entrée pour valider. Pour vérifier quel colorscheme vous convient le mieux, essayez les sur une belle page de code avec le module project et un split horizontal par exemple. Si aucun de ceux installé sur votre ordinateur ne vous convient, vous pouvez en télécharger de nouveaux sur ce site.

Dans mon cas, par exemple pour les formations, mon écran est projecté sur un tableau et les caractères sombres sont très peu distincts. J'opte donc pour le colorscheme «pablo» qui est assez sobre mais surligne ce dont j'ai besoin : les mots clés ainsi que les fonctions PHP et les variables.
Ce colorscheme possède par contre quelques défauts génants. La barre de titre de la fenêtre d'édition active est en noir et se mélange avec le code. Sur la photo il est difficile de voir que j'ai ouvert 2 fichiers.


Je vais donc construire mon propre colorscheme à partir de pablo. Pour cela, je copie le colorscheme depuis /usr/share/vim/vim71/colors vers ~/.vim/colors et je le renomme en formation. Que y a-t-il dans un fichier de colorscheme ? Presque uniquement des appels à la fonction Vim «highlight».
Cette fonction permet de définir ou de vérifier comment s'affichent les différents éléments dans Vim suivant le type de terminal utilisé. Pour voir la définition actuelle tapez juste «:hi» (raccourci pour :«highlite»). Vous devriez voir s'afficher quelque chose comme ceci :
Le premier argument est le nom du motif concerné. Ensuite, Vim affiche le motif tel qu'il apparait dans votre terminal. Suit la définition de l'affichage dans les différents types de terminaux.
Vim connait 3 types de terminaux :
  • les terminaux textes (term)
  • les terminaux textes couleur (cterm) en 8 et 16 couleurs
  • les terminaux graphiques (gui)
Vim va cascader la définition des terminaux. La définition term s'applique tout le temps, cterm s'applique en plus si votre terminal le supporte, de même pour gui. La définition pour le terminal permet de définir l'allure générale du motif :
  • bold
  • underline
  • undercurl
  • reverse
  • inverse
  • italic
  • standout
  • NONE
Dans le cas des terminaux couleur il est également possible de préciser la couleur de la police (ctermfg) et du fond (ctermbg). Ce qui nous intéresse ici c'est la définition de «StatusLine» qui affiche le nom du fichier en cours d'édition. Dans le colorscheme «pablo», la définition est la suivante :

StatusLine     xxx term=none ctermfg=11 ctermbg=12 guifg=#ffff00 guibg=#0000ff

Enlevons les couleurs en effaçant les déclaration ctermfg et ctermbg.

StatusLine     xxx term=reverse guifg=#ffff00 guibg=#0000ff

Il est alors possible de recharger le fichier de colorscheme dans vim en tapant simplement «:colorscheme formation». La barre de status de la fenêtre active devrait alors passer en blanc brillant. Il peut également être intéressant de diminuter l'intensité du blanc sur les fenêtres inactives afin de mettre en valeur l'endroit de saisie du texte.

Pour afficher la définition courante de l'objet StatusLineNC «:hi StatusLineNC». Nous allons ajouter ceci dans notre fichier :

highlight StatusLineNC   term=reverse cterm=reverse ctermfg=grey gui=reverse

Notez que nous utisons ici ctermfg pour changer la couleur du fond, c'est parce que nous sommes en inverse vidéo. Pour changer la définition des replis de code (folds) afin de les rendre moins visibles :

highlight hi Folded term=standout cterm=bold ctermfg=DarkGrey ctermbg=0

Pour en savoir plus, l'aide de Vim sur le sujet est disponible en tapant «:help highlite».

Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 1 commentaires
Vendredi 8 août 5 08 /08 /Août 20:52
Bon, je vous vois déjà en train de me lancer des cyber cailloux en criant à l'arnaque du post de blog réchauffé. C'est vrai, je vous faisais déjà part de ma découverte du plugin Project dans cet article. Mais après plusieurs mois d'utilisation intensive, ce plugin de Vim a définitivement changé ma façon de travailler en accroissant (encore) la rapidité du développement, c'est ce retour d'expérience que je me propose de partager avec vous aujourd'hui.

Allez, pour ne pas prendre l'habitde de soliloquer je vous propose de m'accompagner au fure et à mesure des manips que je présenterai ici, il n'est même pas besoin de bien connaître Vim pour ce faire.

Qu'est ce que Project ?
Project est un plugin de Vim écrit par Aric Blumer qui permet d'afficher un navigateur de projet à gauche de l'écran d'édition. Pour installer ce plugin dans Vim, il est nécessaire de télécharger l'archive présente sur cette page et de la placer soit dans /usr/share/vim/vimcurrent/plugin (debian) pour permettre à tous les utilisateurs d'y avoir accès soit simplement dans votre $HOME/.vim/plugin.
Une fois ce plugin installé, vous pouvez lancer Vim avec Project en tapant vim +Project ou pour les utilisateurs de screen : screen vim +Project . Vous pouvez bien sûr lancer Project à n'importe quel moment quand vous êtes sous Vim en tapant :Project
Une fois cela fait, vous devriez obtenir quelque chose comme ça :


Un peu vide me direz vous, c'est normal vous n'avez pas ouvert de fichier et votre liste de projets est vide. Cette barre sur la gauche est le navigateur de projets. L'astuce est tellement simple qu'elle en est diablement efficace : ce gestionnaire de projets n'est ni plus ni moins qu'un bête fichier texte (le plus souvent $HOME/.vimprojects) auquel le plugin donne quelques propriétés intéressantes.

Si vous avez un projet symfony à portée de Vim alors ne reste plus qu'à créer une entrée dans votre gestionnaire de projet à l'aide de la combinaison «\C» (create, les majuscules indiquent un comportement récursif). Le plugin vous demande alors
(1) Enter the Name of the Entry:
l
e nom de l'entrée, nous allons ici lui donner le nom du projet tel que nous voulons le voir apparaître dans la fenêtre. (par exemple : «mon projet de test»)
(2) Enter the Absolute Directory to Load:
le chemin absolu du répertoire à charger. Indiquer ici le chemin absolu du répertoire racine du projet symfony. Si vous avez déjà un terminal ouvert dans ce répertoire, la commande «pwd» devrait vous préparer le copier-coller.
(3) Enter the CD parameter:
Ce paramètre permet à Project de changer le répertoire courant de Vim. Nous verrons plus loin que cela nous ouvre des horizons insoupçonnés. Dans le cadre d'un projet symfony, mettez là encore le chemin absolu du répertoire racine de votre projet.
(4) Enter the File Filter:
Rentrez ici une liste séparée par des espaces du masque de sélection de fichiers que vous voulez voir apparaître dans votre projet, par exemple, dans le cas d'un projet symfony  : *.php *.yml *.sql *.ini *.txt *.css *.js .

Crrr crrr, le disque se met à tourner, si vous avez la lib symfony dans votre projet, cela va mettre quelques secondes à tout importer, une fois le travail fait, vous voila avec toute l'arborescence dépliée de votre projet. Un coup de barre espace et vous agrandissez votre vue du projet (un coup de barre espace et l'espace se réduit). Placez votre curser sur une entrée quelconque du projet et appuyez successivement sur «zm», cette commande permet de réduire tous les folds, nous ne voyez plus que l'entrée principale de votre projet. Placez votre curser dessus et appuyez sur «enter», l'entrée se déplie et cela vous rappelle quelque chose n'est ce pas ?


La première chose que nous pouvons faire est d'enlever les entrées «cache» et «log». Pour, cela, il suffit tout simplement de placer le curser sur la ligne correspondante et de faire «dd». C'est là qu'est la grande force de Project, cette vue n'est qu'un bête fichier texte entouré de scripts simples. Vous pouvez faire des modifs dessus, replacer des entréer dans l'ordre que vous voulez puis «:w» pour enregistrer notre projet dans $HOME/.vimprojects.

Plaçons maintenant le curser sur l'entrée «apps» et validons. L'entrée se déplie, nous devrions avoir quelque chose comme ça :

Comme vous le voyez, les questions que Project vous a posé tout à l'heure sont des attributs de l'entrée principale. Vous pouvez évidemment les mofier directement, une fois votre modif terminée, en mode commande, faite un «\R» (refresh) et elle devrait être prise en compte. Ce qui est important ici, est de voir que l'entrée «apps» ne possède pas tous les attributs de son père, il n'en possède qu'un : le nom du sous répertoire. C'est grâce à la notion d'héritage que l'entrée «apps» possède automatiquement le bon filtre de fichiers. Vous pouvez redéfinir le filtre pour certaines des entrées de votre projet («config» par exemple).

La navigation : utilisation courante de Project
La navigation dans project est très simple, les touches de mouvement (flèches, recherche, sauts) sont évidemment accessibles (les marqueurs aussi...) pour aller d'une entrée à l'autre, les folds sont des replis de Vim comme les autres à part que l'appuie sur la touche «enter» vous permet de les déplier, replier, l'appuie sur la touche «enter» sur un fichier l'ouvre dans votre fenêtre de droite et place le curser dans la fenêtre du fichier.

 La combinaison «ctrl w» et flèche vous permet de sauter d'une fenêtre à l'autre (en général «ctrl w» préfixe les opérations sur les fenêtres (window)). Cela ouvre toute la puissance du split de Vim. Faites un «:sp» et Vim ouvre un split horizontal, «ctrl w» «flèche gauche» vous permet de retourner dans la vue Project, sélectionnez un nouveau fichier et le voila qui s'ouvre dans votre split. Vous pouvez ainsi par exemple avoir sous les yeux directement le contrôleur et la vue pour vous assurer du passage de paramètres ....


Pour ceux qui veulent en savoir plus sur le déplacement dans Vim, je vous conseille la méthode hypoallergénique.

Comment Vim se transforme en éditeur tout en un
L'astuce ici est que dès que vous travaillez sur une entrée de votre projet, le paramètre CD de project rentre en action et place votre Vim dans le répertoire racine de votre projet. Il devient ainsi possible d'utiliser directement l'utilitaire «symfony» depuis Vim !
:!./symfony cc
et le tour est joué ! Je nous vous parle pas des commandes svn... Pour bien faire, il suffit de mapper les opérations les plus courantes sur les touches f2 à f12 (f1étant réservé pour l'aide de Vim), je vous ai concocté un petit extrait à mettre dans votre .vimrc
map <F2> :!phptags ^M:set tags=.ctags^M
map <F5> :!svn up^M
map <F6> :!svn ci^M
map <F7> :!svn
map <F9> :!./symfony cc^M
map <F10> :!./symfony propel:build-model^M
map <F11> :!./symfony propel:build-all-load
map <F12> :!./symfony


Pour faire le ^M (retour chariot), il suffit de faire «ctrl v»«ctrl m». (utile aussi dans des chercher/remplacer).

On s'habitue très vite au F9 pour clearer le cache, notez les options qui ne font pas de retour chariot pour attendre des informations supplémentaires de votre part (F7, F11 et F12). La touche F2 sera décrite plus loin dans cet article.

Commandes de groupe

Il est également possible de définit des actions à effectuer sur des parties ou une entrée d'un projet, par exemple le «svn revert» qui permet d'annuler les dernières modifs sur un fichier et revenir à l'état précédent.

Pour cela, il suffit d'entrer en mode commande la ligne suivante :
:let g:proj_run1='!svn revert %f'
Cela vous permet alors en vous plaçant sur un fichier de votre projet et en tapant «\1» de lancer «svn revert» sur ce fichier. Vous pouvez ainsi définir 9 fonctions Vim à affecter aux combinaisons de «\1» à «\9».

Pour définir des commandes Vim s'appliquant à tous les fichiers d'une sous arborescence, il suffit de déclarer les variables de «g:proj_run_fold1» à «g:proj_run_fold9» (amateurs de la commande dos2unix, vous voila comblés). Il suffit ensuite de faire «\f1» pour appliquer la commande 1 au niveau courant et «\F1» pour inclure tous les enfants.

Cerise sur le gateau : la commande grep
Grep existe depuis Unix. Cette commande est tellement indispensable au programmeur qu'un bon système ne peut se passer d'un bon grep. Ici nous sommes doublement servis :
- le grep ne s'applique qu'aux entrées dans Project: aux entrées qui nous intéressent ! (finis les entrées .svn et cache etc))
- le grep est intégré à Vim, la liste des résultats permet d'ouvrir directement le bon fichier au bon endroit.

Pour lancer grep, dans la fenêtre Project un «\g» ou «\G» (récursif) sur l'entrée voulue vous ouvre le dialogue suivant :
GREP options and pattern: -iHn *motif*
Vous pouvez évidemment utiliser autre chose que -iHn pour les options... Il n'est pas impossible que les codes couleurs de Vim cassent un peu la mise en page de votre terminal. Un «ctrl l» (L) rafraichira votre terminal. Vous devriez voir ceci :

Une liste de fichiers avec la ligne correspondante à votre recherche. Vous pouvez vous déplacer avec les flèches et appuyez sur «enter» pour choisir le fichier à ouvrir, il s'ouvrira et placera le curser à la bonne ligne. un «:q» dans la fenêtre du grep pour finir.

Les plus curieux d'entre vous n'hésiteront évidemment pas à aller voir la page d'aide de project :
:help project

Naviguer dans les classes avec exubertant-ctags:
L'utilitaire ctags permet de naviguer rapidement dans les dépendances de classe d'un projet. Pour cela, dans un shell à la racine de votre projet symfony, la commande suivante (volée et adaptée de ce très bon blog):

ctags -f .ctags -h ".php" -R \
--exclude="\.svn" \
--exclude="/cache" \
--exclude="/log" \
--totals=yes \
--tag-relative=yes \
--PHP-kinds=+cf \
--regex-PHP='/abstract class ([^ ]*)/\1/c/' \
--regex-PHP='/interface ([^ ]*)/\1/c/' \
--regex-PHP='/(public |static |abstract |protected |private )+function ([^ (]*)/\2/f/'


crééra un fichier «.ctags» dans le répertoire courant. Je vous conseille d'enregistrer la commande dans un script shell (qui s'appellerait par exemple phptags). Cela tombe bien, c'est justemment le même nom de fichier que celui du fichier pointée par la commande mappée en <F2> plus haut dans Vim. Une fois les tags avalés dans Vim, placez vous sur une classe (par exemple sfActions) et un «ctrl ]» vous permettra d'ouvrir le fichier déclarant la classe sfActions,«ctrl t» reviendra au fichier précédent.
Pour lister les méthodes de la classe courante, rien de plus facile «:g:function:#» vous donnera la liste des méthodes et le numéro des lignes ... que demander de plus ?

Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 2 commentaires
Mercredi 26 mars 3 26 /03 /Mars 00:13
Bon après l'article fleuve d'hier, je vais faire (relativement) court aujourd'hui, je vais vous parler d'un logiciel libre qui me tient particulièrement à coeur dont le nom commence par V et finit par M (buzze à ma gauche) : vim !! et le plugin Project.

J'ai lu cet excellent article sur Project et je n'ai pas pu m'empêcher d'essayer ... et là, ma vie a (une fois de plus) changé. Voici l'outil que j'attendais depuis que j'utilise Vim pour coder en PHP : un explorateur de projet. Son principe de fonctionnement est tellement simple que cela en est un peu déroutant au début... je m'explique.

vm01.png
Project sur la gauche avec le modèle à portée de souris

Project est un plugin qui gère tout bêtement un fichier texte. Ce fichier est par défaut à la racine de votre home et possède tous les projets sur lesquels vous travaillez. Lorsqu'il est chargé dans Vim avec le bon plugin, ce fichier a un comportement particulier, il vous permet d'ouvrir directement dans un split les fichiers auxquels il fait référence et il est capable de dire à Vim de changer son répertoire courant.

Prenons un exemple, une fois le plugin installé, vous voulez travailler sur un projet symfony. Ouvrez un shell et tapez tout simplement «vim». Une fois lancé rentrez «:Project». Une barre apparait alors à gauche et elle est vide si c'est la première fois que vous lancez Project. Créons un nouveau projet. Pour cela il suffit de se placer dans la fenêtre et de rentrer \C. Vim vous pose alors quelques question afin de créer une entrée projet pour vous.

Le path :
Le chemin du répertoire, «/var/www/mon_projet»,
Le CD : le chemin du nouveau répertoire courant de Vim si vous voulez le changer «.» permettra de lui affecter la même valeur que pour le path (pratique pour lancer l'utilitaire symfony depuis Vim).
Les flags : permettent d'influer sur les recherchers etc etc ... les flags par défaut sont très bien.
Les filtres : permet d'indiquer quels fichiers vous voulez voir apparaitre par exemple «*.php *.yml *.ini *.sql *.css *.js»

Une fois ces renseignement rentrés, Vim va chercher tous les fichiers et créer l'arborescence du projet pour vous. Il est alors possible de surfer comme un explorateur de fichier ... mais ce n'est pas un explorateur ! C'est un fichier texte. Vous pouvez prendre les entrées, effacer celles qui ne vous servent à rien (cache, log), les déplacer pour mettre à coté les unes des autres celles que vous utilisez souvent (/lib/model et /app). Mieux que ça ! Vous pouvez créer une arborescence logique qui répond plus à vos besoins, pourquoi ne pas mettre dans un même répertoire virtuel mes les modules de mes application et mon modèle (sans afficher om et base) pour ne pas avoir à jongler sans cesse avec mille répertoires ...

vm02-copie-1.png
Pour info, presser «espace» vous permet d'avoir une vue agrandie (comme sur l'image à droite), «enter» vous permet d'ouvrir le fichier dans le dernier split utilisé ... je vous laisse taper «:help Project» pour voir la page d'aide de ce merveilleux plugin qui n'a pas changé depuis 2006 ! Quand ça marche ...
Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 9 commentaires
Lundi 12 mars 1 12 /03 /Mars 11:06
Les macro-commandes

Dans notre précédente excursion dans les arcanes de Vim, nous avons vu qu'il existait 3 grands groupes de commandes :
- les commandes de changement de mode
- les commandes de déplacement
- les commandes de coupé-copié-collé

Nous avons vu également que nous pouvions utiliser des multiplicateurs et définir des zones de textes. Le soucis de toutes ces commandes n'est il pas que, mêmes très puissantes, elles s'adaptent difficilement aux tâches répétitives ? Vim propose pour contrer cela d'enregistrer des séquences de commandes.

«qX» enregistre une suite de commandes dans le registre 'X' («q» pour arrêter l'enregistrement).
«@X» rejoue la suite de commande enregistrée dans le registre 'X'

Lorsque que vous passez en mode «enregistrement», toutes vos entrées clavier sont alors épiées et duemment enregistrées par Vim qui se fera une joie de vous ressortir la séquence dans l'ordre. Imaginez par exemple que vous ayiez une suite de temps en microsecondes séparés par des espaces et que vous voulez en faire une liste de lignes de temps en secondes.

Pressez vous en début de la ligne et rentrez «qa», la mention «recording» apparait en bas à gauche de Vim. Saisissez alors la suite de combinaisons suivantes :
«a.<ECHAP>f<ESPACE>is<ENTREE><ECHAP>q»

Nous avons rentré la suite de commandes nécessaire pour traduire un de nos temps, nous pouvons alors réitérer le scénario en appuyant sur «@a», mieux que cela, nous pouvons même demander à Vim de l'exécuter un certain nombre de fois pour nous en tapant «5@a».

Les délimiteurs
Ces macros commandes sont bien utiles pour nous faciliter la vie sur un grand ensemble de résultats. Le soucis est que lorsque l'on cherche à automatiser une tâches, il faut que tout le contenu se ressemble le plus possible. Or les travaux que nous cherchont à faire sur le texte inclue très souvent des blocs de tests bordés de délimiteurs tels que "()'{} ou même <tag></tag>.
Vim propose un moyen de ne sélectionner que ce qui est entre (ou avec) des délimiteurs donnés. Les touches «a» et «i» si elles sont précédées d'une commandes se comportent comme des déclarateurs de délimiteurs.

«a» pour sélectionner le contenu ET les délimiteurs.
«i» pour sélectionner le contenu des délimiteurs.


Par exemple
«da'»  efface le bloc délimité par '' (quotes comprises) sur la ligne courante.
«cit»  Efface le contenu du tag SGML, HTML ou XML de la ligne et passe en mode insertion.
«gUi"» passe sur la ligne, le contenu entre "" en majuscules.
«=i{» Indente le code compris entre les acolades courantes.


Pour finir, petite cerise sur le gâteau, il est possible d'afficher la commande en cours (partielle) dans la barre de status en tapant «:set showcmd»

Substitution
La substitution est une des grandes forces de Vim. Elles permet sur une zone de texte (par défaut l'ensemble du tampon), de substituer du texte par un autre en tirant parti des expression régulières. Les opérations de substitution et recherche ne prennent place que sur la ligne de commande Vim, elles sont donc précédées d'un «:».

«:s/un/deux/» Change la première occurence de "un" par "deux" sur la ligne courante.
«:%s/un/deux/g» Change toutes les occurerences (option «g» pour "gourmand") sur l'ensemble du tampon.
«:'<,'>s/un/deux/gc» Change toutes les occurerences de "un" par "deux" sur la précédente sélection visuelle en demandant confirmation.
«:%s/^/#/» Ajoute un "#" devant toutes les lignes du tampon.
«:%s/^#//» Supprime les "#" en début de ligne sur l'ensemble du tampon.


Si vous utilisez ces commandes dans vos scripts shells vous pourrez être confronté au problème d'échapper les caractères "/" contenu dans les motifs de vos recherches ou remplacements. Vim vous propose en fait de choisir vous même les délimiteurs de la commande de substitution pour vous éviter cette tracasserie:

«:s#/var/www#/home/greg/var/www#» change la première occurence de "/var/www" par "/home/greg/var/www" dans la ligne courante.

Ce dernier exemple pourrait encore soulever des remarques, les expressions régulières me permettent en effet de ne pas forcément savoir ce que je vais remplacer. Vim nous propose là encore un raccourci pratique : le "&". Il signifie "le texte qui correspond à ma recherche". Notre exemple précédent devient :

«:s#/var/www#/home/greg&#»

Imaginez maintenant que nous ayions une liste de noms prénoms séparés par des espaces et que nous souhaitions les inverser.

 Le support des expressions régulièrs de Vim et des groupes de correspondances va nous simplifier le problème en une ligne :
«:%s/(w+)s(w+)/2 1/»


Nous avons défini des groupes dans notre expression régulière par l'utilisation des "()" et nous remplaçons le tout par les groupes dans l'ordre inverse. Vim permet même certaines choses particulièrement intéressantes comme par exemple substituer en majuscules ou l'inverse voir même capitaliser. Nous allons remplacer notre liste toute en minuscule par le nom en majuscule avec une capitale sur la première lettre du prénom :
«:%s/(w+)s(w+)/u2 U1/»


La commande "globale"
Je vois d'ici des centaines d'idées germer dans vos cerveaux fertils. Mais cela devient vite insuffisant dès que l'on doit préciser que cette opération ne doit s'appliquer qu'à certains types de lignes, les expressions régulières deviennent vites très acrobatiques. Il existe une autre commande qui va vous éviter des acrobaties complexes : la commande "globale".

La commande "globale" «:g» permet par défaut de lancer un grep sur le tampon en court. Cette commande permet en fait de lancer une commande pour les lignes vérifiant le motif fourni. Ce dernier peut, là encore, être une expression régulière.

«:g/un/»  Affiche toutes les lignes du texte qui contiennent la chaîne "un" (utilise la commande «:p» par défaut).
«:g/un/#» La même chose mais avec les numéros de ligne.
«:g/deux/d» Efface toutes les lignes du texte qui contiennent "deux"
«:g!/^#/s/un/deux/gc» Remplace tous les "un" par des "deux" sur les lignes du textes ne commençant pas par "#" en demandant confirmation à chaque fois.
«:g/un/d A» Coupe les lignes contenant "un" et les met toutes dans le buffer nommé "a" (les buffer nommés en majuscules concatènent les ajouts).


Voila, j'espère que ce deuxième article vous sera utile et vous permettra de gagner du temps dans vos traitements de fichiers textes car c'est exactement le but de Vim. Nous n'avons évidemment pas couvert toutes les fonctionnalités de l'éditeur mais c'est également ce qui fait son "charme" : «des années d'utilisation et tous les jours quelque chose de nouveau».
Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 0 commentaires
Dimanche 4 mars 7 04 /03 /Mars 13:18
Un peu d'histoire
Si je vous demande un logiciel incontournable du monde linux qui s'apprend dans la douleur ? Je pense que sans soucis, la majorité d'entre vous me répondront Vi. Loué par les habitués pour la puissance de ses commandes, raillé par ses détracteurs lui reprochant son manque de convivialité, Vi est un logiciel atypique du paysage informatique.

Vi est un éditeur de texte modal (Cf la définition sur wikipedia) pour Unix écrit par Bill Joy en 1976. Un éditeur de texte n'est pas un éditeur héxadécimal, ni un traitement de texte, c'est à dire qu'il permet à un utilisateur de saisir des caractères textes (ascii) et de les enregistrer tels quels sous forme de fichier. Modal est ce qui fait toute la différence entre Vi et les autres éditeurs de textes, c'est à dire que Vi possède différents modes de saisie, principalement le mode commande et le mode édition.

Mais, me diriez vous, le tître de cet article fait mention de Vim et non de Vi, y aurait il tromperie sur la marchandise ? Nenni ! Le soucis de Vi est ... qu'il n'est pas libre. Impossible donc de le porter sur une plate-forme sans s'acquitter de droits. En 1991, Bram Moolenaar  a donc décidé, puisque personne d'autre ne le faisait, d'écrire un clone de Vi qui tournerait sur son amiga. Grâce à la licence libre de son programme, des contributeurs ont commencés à s'intéresser à ce projet et très rapidement, le clône a dépassé son modèle héritant ainsi du nom de Vim (Vi iMproved).

Quels sont les avantages d'utiliser Vim ? Le premier est très important : il fonctionne en mode texte. Il est donc possible de l'utiliser dans une console ou via SSH. Deuxièmement, il est très rapide : il se lance instantanément et est capable d'avaler des fichiers de plusieurs dizaines de mégaoctets sans se plaindre. Troisièmement : il est très puissant comme nous le verrons plus bas. Si son interface à de quoi rebuter au premier abord, sachez que son austérité n'est cepandant pas cliquophobe et qu'une interface graphique existe : GVim.


GVim7 - browser de classes, coloration syntaxique, onglets, splits, replis ... la classe !

Un éditeur de texte modal

Vim fonctionne avec des modes, et mine de rien, c'est le truc le moins intuitif au monde. Par défaut, on arrive sous Vim en mode commandes, cela veut dire que l'on peut taper sur son clavier, rien ne s'affiche à l'écran (sauf peut être des messages d'erreur) ... Vim interprète ce qu'on lui rentre comme une suite de commandes.  Le mode commandes est d'ailleurs le mode central de Vim, il suffit d'appuyer 2 fois sur la touche «echap» et l'on est en mode commande. Le mode Édition est le mode qui permet de rentrer du texte dans le fichier en cours. En fait le mode édition est soit un mode dit insertion soit un mode remplacement (on remplace du texte par la saisie).

passer d'un mode à l'autre
Touches Description
Echap Passe  en mode commandes
«a» ou «A» Passe  en mode insertion après le caractère courant ou en fin de ligne.
«i» ou «I» Passe  en mode insertion avant le caractère courant ou en début de ligne.
«o» ou «O» Passe  en mode insertion en ajoutant une ligne vièrge après/avant la ligne courante.
«s» ou «S» Efface le caractère/la ligne courant et passe en mode insertion.
«R» Passe en mode remplacement.
«v» ou «V» Passe en mode visuel par caractère / ligne.
«Ctrl+V» Passe en mode visuel par bloc.


Naviguer dans du texte

Bon, ça nous fait déjà les lettres "aiosrv", l'alphabet nous permet encore quelques combinaisons sympathiques ;o) notemment pour jouer avec du texe : se déplacer, faire du copier-coller et toutes ces choses qu'il est d'usage de faire dans un éditeur de texte.
 Pour bien comprendre comment fonctionne Vim, il est plus juste de considérer que le texte actuellement dans l'éditeur est un «buffer» (tampon). C'est à dire qu'il est dans la mémoire de l'ordinateur. Il est possible, nous verrons plus loin d'ouvrir plusieurs tampon, de les fusionner etc etc mais revenons à notre curser :

How to naviguer dans un tampon
Touche
Description
:445
Va à la ligne 445 du tampon en court
Touches fléchées ou «h,j,k,l»
Déplace le curser.

«w» et «b»
Déplace le curser d'un mot vers la droite / gauche
«(» et «)»
Déplace le curser d'une phrase vers le haut / bas
«^» et «$»
Va en début / fin de ligne
/chaine
Cherche la chaîne de caractères «chaine» et place le curser sur la première occurence («n» et «N» pour occurence suivante / précédente).
«tX» ou «fX»
Cherche la première occurence de "X" et place le curser devant / dessus.
«ma»
Créer un marqueur nommé "a"
«'a»
Place le curser sur le marqueur nommé "a"
«gg»
 pareil que :1
«G»
pareil que «:$» (fin de tampon).
«{» et «}» Va au paragraphe précédent / suivant.
«%» Va à l'acolade / parenthèse / crochet correspondant.
«*» Va à la prochaine occurence du mot sous le curser

Les registres et le copier-coller.

Comme vous pouvez le constater, Vim est riche d'un grand nombre de commandes pour se déplacer dans du texte. Jetons maintenant un oeil aux opérations de copier coller.

Copieeeeer, colleeeeer, que j'aime le copiéééé collé !
touches

Description

«u» Annule la commande précédente :o)
«dd»
Coupe la ligne courante vers le registre (reg) par défaut
«yy»
Copie la ligne courante vers le reg par défaut
«p» ou «P»
Colle avant / après la position / ligne courante depuis le reg par défaut
«dtc»
Coupe le texte depuis la position actuelle du curser jusqu'à la première occurence de la lettre "c" dans le reg par défaut.
«yw»
Copie le mot à droite dans le reg par défaut.
«d}» Coupe le paragraphe suivant dans le reg par défaut.

Ce registre par défaut a un petit goût de planté de baton n'est ce pas ? Il faut en effet savoir que Vim permet d'utiliser d'autres types de registres en lieu et place de celui par défaut ce qui vous permet de conserver différentes sélections selon vos besoins.

- les registres numérotés (1 à 9)
- les registres nommés (a à z et A à Z).

Le registre par défaut est un registre spécial appelé «""» et contient systématiquement le contenu de la dernière sélection.

Les registres numérotés permettent d'accéder à vos coupés-collés précédents le plus récent prenant l'index 1 et décalant tous les autres ... je vous laisse savourer cette cerise sur le gâteau du copier-coller.

"2p # Colle après le curser le contenu de l'avant dernier registre
"3P # Colle avant le curser le contenu de l'avant avant dernier registre.


Les registres nommés vous permettent de mettre de coté des sélections et de les ressortir quand bon vous semble.

"add # Copie la ligne courante du curser dans le registre nommé "a"
"bp # Colle le contenu du registre nommé "b"

Pour finir et s'y retrouver, la commande «:reg» vous permet d'afficher un ou tous les registres.

Les multiplicateurs et les marqueurs

Avant de pousser plus loin notre exploration, il est important de savoir que presque toutes les commande Vim peuvent s'appliquer un certain nombre de fois (multiplicateurs) et / ou sur une région bien définie du tampon (marqueurs).

Les multiplicateurs permettent d'indiquer combien de fois répéter une commande. Il se saisissent sous forme de nombres rentrés juste avant la commande voulue :

3w # Déplace le curser de 3 mots vers la droite
2tA # Place le curser devant la deuxième occurence de la lettre "A".
d35d # Coupe les 35 lignes sous le curser dans le registre par défaut
"cy5b # Copie les 5 mots à gauches dans le registre nommé "c"
"a500p # Colle 500 fois le contenu du registre nommé "a" avant le curser.

Vous allez me dire avec raison que compte le nombre de ligne à supprimer n'est pas le moyen le plus simple de faire. Pour cela Vim propose d'appliquer des commandes sur certaines régions du texte soit en utilisant les numéros de lignes, soit les marqueurs :

:20,35y # Copie de la ligne 20 à la ligne 35 dans le registre par défaut.
:,100d # Coupe de la position actuelle jusqu'à la ligne 100
:100,d # Coupe de la ligne 100 à la position actuelle
:,$d # Coupe de la ligne actuelle jusqu' à la fin du fichier
:,'ay # Copie de la position actuelle du curser jusqu'au marqueur nommé "a"
:'a,'bd # Coupe du marqueur nommé "a" au marqueur nommé "b"
:-15,+15d # Coupe de 15 lignes avant à 15 lignes après la position du curser.
:%d # Supprime toutes les lignes du tampon (equiv :1,$d)

Vim propose un mécanisme de sélection plus intuitif que le mécanisme de marqueurs nommés qui permet d'appliquer des commandes sur une sélection :

le mode visuel

Le mode visuel permet de définir manuellement des régions à l'aide d'une sélection. Pour cela il suffit de rentrer en mode visuel à l'aide d'une des commandes données dans le tableau 1 et ensuite de se déplacer à l'aide de n'importe quelle combinaison de commandes de déplacement jusqu'au point désiré. Un fois cela fait, pressez «d» pour couper. Si vous préférez garder votre sélection, pressez «echap» pour retourner en mode commande. Les marqueurs «<» et «>» sont maintenant fixés vous pourrez les utiliser quand bon vous semble. Si vous voulez rentrez de suite une commande sur votre sélection, pressez «:» une fois la sélection faite, vim vous proposera automatiquement le prompt suivant :

:'<,'>

Ne vous reste qu'à appliquer la commande voulue.

Jongler avec les tampons

 La notion de tampon n'est pas un artifice purement gadget. On peut ainsi charger un fichier dans le buffer ou sauvegarder le buffer dans un fichier. Mais on peut également écrire le buffer dans l'entrée d'une commande Unix ou remplir le buffer à partir de la sortie d'une commande Unix ou d'un autre tampon !

Commandes de gestion des tampons
Touches
Description
:Ex
Ouvre un explorateur de fichiers
:enew Créée un tampon vide
:e fichier
Créer un tampon à partir du fichier «fichier»

:w
Écrit le tampon dans le fichier en cours si ouvert.
:w newfile
Écrit le tampon en cours dans le fichier «newfile»
:r fichier
Insère le fichier «fichier» dans le tampon actuel à la ligne courante.
:r !commande
Exécute «commande» et insère sa sortie standard dans le tampon actuel à la ligne courante.
:sp fichier
Sépare l'écran en 2 et charge «fichier» dans le nouveau tampon.
:wq ou :x
Sauve le tampon dans le fichier ouvert et quitte Vim

Vous remarquerez qu'en mode commande, lorsque vous tapez le caractère «:» une ligne de commande apparait en bas de votre écran : la ligne de saisie de commandes. Il s'agit du mode normal de saisie de commandes, les commandes non saisies sont des raccourcis vers les commandes saisies. (appuyer sur la touche «a» est un raccourci de la commande «:append»). Vous remarquerez qu'une pression sur la touche TAB après une des commandes de lecture ou d'écriture de fichier vous offre le choix des fichiers ou répertoires (autocomplétion).

Vim va plus loin, il est possible par exemple d'écrire seulement une partie du tampon en court dans un fichier ou une commande en définissant des marqueurs ou en passant par le mode visuel. Imaginez que vous ayiez dans un fichier, des requêtes SQL compliquées que vous gardez précieusement. Vous voulez exécuter l'une (ou plusieurs) d'entre elles mais pas l'ensemble du fichier. En mode commande, placez votre curser au début de la première requête à exécuter, puis passer en mode VISUEL en pressant les touches «SHIFT V». À l'aide des touches fléchées, sélectionnez jusqu'à la fin de la requête qui vous intéresse et pressez la rouche «:». Rentrez alors

:'<,'>w !mysql ma_base -u mon_user -h mon_host -p

Vous allez écrire votre séléction dans l'entrée de la commande mysql ... le tour est joué.

Plus loin avec Vim
Évidemment Vim possède une aide accessible à tout moment en pressant la touche «F1» ou en tapant ":help commande" en mode commande. Cette aide est très complète et naviguable facilement, seul hic : elle est en anglais.

Si cet article vous a intéressé faites le moi savoir, nous verrons la prochaine fois comment effectuer des recherches complexes, éditer plusieurs fichiers dans des tabs, remplacer et générer du contenu grâce à des expressions régulières, installer des plugins, configurer Vim grâce au vimrc, créer des macros et plus encore.
Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 7 commentaires
 
Créer un blog gratuit sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus - Articles les plus commentés