Introduction générale à Vim

Deux excellentes introduction à Vim.

Essential tricks and settings

Visual cues for coders

Syntax highlighting may be enabled by default by adding the following line to your .vimrc.

syntax on

Depending on the language(s) you're working with, some adjustments may be required to highlight the correct file. Drupal developers may wish to also include the following settings:

if has("autocmd")
  filetype on " Enable filetype detection
  filetype indent on " Enable filetype-specific indenting
  filetype plugin on " Enable filetype-specific plugins
  augroup module
    " Drupal settings
    autocmd BufRead,BufNewFile *.module set filetype=php
    autocmd BufRead,BufNewFile *.install set filetype=php
    autocmd BufRead,BufNewFile *.test set filetype=php
    autocmd BufRead,BufNewFile *.inc set filetype=php
    autocmd BufRead,BufNewFile *.profile set filetype=php
    autocmd BufRead,BufNewFile *.view set filetype=php
    autocmd BufRead,BufNewFile *.info set filetype=dosini
  augroup end 
endif

Visualizing line numbers is also a one-liner:

set number

To toggle showing/hiding line numbers, you may wish to remap the « ,l » key sequence as follows:

let mapleader = ","
nnoremap <leader>l :set nonumber!<CR>

Autocompletion enhancements

Wildmenu offers a comprehensive autocomplete feature. Press the TAB key while in the :command mode to visualize a suggestion of autocomplete candidates. To activate wildmenu, place the following line in your .vimrc.

set wildmenu

In insert mode, the control-p key will offer Vim/Ctags users a list of suggestions for completing your function calls.

Essential vim modules

See : https://vimawesome.com/

Coloration de syntaxe

Vim vient de base avec plusieurs colorations de syntaxes déjà définie. Par contre des fois c'est nécessaire d'en avoir plus pour des langages additionnels et pour certains, la coloration "built-in" est pas aussi bonne qu'elle ne le devrait.

Markdown

Vim a un script de syntaxe markdown built-in mais il est un peu déficient. Celui-ci fait mieux la job:

https://github.com/plasticboy/vim-markdown

YAML

Vim a un script de syntaxe YAML buit-in mais il ne supporte pas certaines features du langage comme les contenus verbatim qui commencent avec une barre verticale en fin de ligne

https://github.com/stephpy/vim-yaml

Puppet

Offre coloration et formattage:

https://github.com/rodjek/vim-puppet

Maintenant packagé dans debian comme vim-puppet

YARD

syntaxe seulement. ça ajoute de la coloration sur les tags et directives yardoc dans les commentaires. avantage collatéral: ça colorie aussi les tags yardoc dans les fichiers puppet:

https://github.com/noprompt/vim-yardoc

Plugin management

Vundle

Vundle permet la gestion des plugins en bundle, un peu comme Pathogen ou bien les packages builtin de vim 8. Par contre le plugin offre un avantage que les packages builtin ou Pathogen n'ont pas: comme on déclare les plugins dans notre vimrc, ça rend ça vraiment facile de reproduire une installation de vim.

Une fois le plugin installé (suivre les instructions dans le README du projet), il faut ajouter un bloc comme ceci à votre ~/.vimrc:

set nocompatible              " be iMproved, required
filetype off                  " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'

" on peut lister d'autres plugins avec des lignes "Plugin" comme juste au dessus
" quand on utilise 'qqch/qqch', ça correspond à un projet github (e.g. user/project)
" on peut aussi donner une url de repos git à la place

" All of your Plugins must be added before the following line
call vundle#end()            " required
filetype plugin indent on    " required

Ensuite pour installer ou mettre à jour les plugins (dans vim):

:PluginInstall

Pour voir la liste de plugins connus par Vundle:

:PluginList

On peut également fouiller dans la liste des plugins connus de Vundle qui sont possible à installer:

:PluginSearch

Packages Vim 8

Vim 8 a ajouté une fonctionnalité qui rend l'utilisation de Pathogen maintenant inutile (nice! un plugin de moins et on garde la même fonctionnalité). On n'a rien à ajouter à notre vimrc pour que ça fonctionne.

En premier on doit créer un répertoire, ou bien renommer "bundle" au nouveau nom si vous aviez déjà Pathogen -- ici le nom "foo" est arbitraire et peut être remplacé par ce que vous voulez:

mkdir ~/.vim/pack/foo/start

Ensuite, on peut créer un répertoire sous celui qu'on vient de créer (comme avec Pathogen) pour chaque plugin.

pour voir plus d'information, consultez:

:help packages

Pathogen

Pathogen simplifies vim extension management.

Just add pathogen.vim to your .vim/autoload folder and add the following line at the top of your .vimrc and you will be able to activate any vim extension simply by extracting it to your .vim/bundle folder.

call pathogen#infect()

ctags

Vim peut créer et utiliser un liste de tags pour se rappeler de l'emplacement de certains trucs important dans le code d'un projet. Pour que ça fonctionne, il faut installer un des outils qui implémente les ctags. Les plus populaires sont universal-ctags et universal-ctags. Les deux sont disponibles comme packages dans debian.

Voir aussi Vim/Ctags

TagList

TagList uses vim's Vim/Ctags file to present you with a list of constants, variables and function names available within the scope of your code file. Just like an IDE does.

You may be required to specify the location of the ctags command in order to activate this feature. On Debian systems, adding the following line to your .vimrc should do the trick:

let Tlist_Ctags_Cmd = "/usr/bin/ctags"

TagBar

Une alternative au précédent.

Vim comme un IDE

Setup plus moderne pour Vim 8

Vim 8 contient une nouvelle feature qui lui permet d'avoir des outils pas mal plus intéressant à utiliser: c'est maintenant possible d'avoir des processus asynchrones et donc de rouler des tâches de modules complexes sans bloquer l'interface de l'éditeur. C'est donc pour ça qu'on désigne ces plugins là comme "modernes" puisque ça ajoute les fonctionnalités avec des processus asynchrones et donc ça s'exécute en apparence plus vite et c'est moins disruptif dans l'expérience d'édition

Syntax checking, lintin, correction, suggestion: LSP client

Microsoft a défini un protocole à spécification ouverte, Language Server Protocol (LSP), qui est utilisé par Visual Studio Code pour permettre à la communauté d'implémenter le support à l'édition à plein de langages de programmation. LSP vise la vérification de syntaxe et de "lint", l'auto-correction, le support aux rechercher et modifications assistées (e.g. changer le nom d'une variable partout dans le projet) et les suggestions de noms de variables, de types de données et aussi d'arguments selon la signature définie d'une fonction.

Un effort communautaire de répertoire des adaptateurs LSP open source peut être trouvé ici: https://langserver.org/

On peut donc réutiliser les adaptateurs LSP qui sont en logiciel libre pour implémenter le support à l'édition pour plusieurs langages.

Il existe plusieurs clients LSP pour Vim. Le plus simple à installer est coc.vim. coc permet ensuite d'installer différents adaptateurs pré-configurés selon les besoins. On peut également en configurer certains additionnels par nous-même.

note: les utilisatrices.teurs de emacs seraient p-e intéressés par: https://github.com/emacs-lsp/lsp-mode

Installer coc.vim (ici en utilisant le gestionnaire de plugins Vundle. le principe est le même avec les packages builtin ou avec d'autres gestionnaires comme pathogen, Plug ou autre):

dans ~/.vimrc:

Plugin 'neoclide/coc.nvim', {'branch': 'release'}

dans vim:

:VundleInstall

Ensuite, redémarrer vim. Puis on peut installer des adaptateurs avec qqch comme ça:

:CocInstall coc-python

Une liste des extensions disponibles avec la commande d'installation peut être trouvée dans le wiki du projet coc

Il est aussi possible d'installer une extension en donnant l'URL du repository git ou du projet github d'une extension à la commande CocInstall

Pour lister les extensions présentement installées:

:CocList extensions

Adaptateur LSP pour puppet

Une fois qu'on a coc d'installé, on peut installer le serveur LSP pour le langage puppet et ajouter une configuration pour que coc l'utlise.

Installer puppet-editor-services:

# qqpart où vous voulez. pour pouvoir référencer l'emplacement dans la configuration on utilise ici:
cd ~/dev
git clone https://github.com/puppetlabs/puppet-editor-services
cd puppet-editor-services

Configurer coc:

vim +CocConfig

dans la fenêtre, entrer en mode insertion et ajouter (modifier le chemin vers les modules pour que ça corresponde à où vous les avez installés):

{
  "languageserver": {
    "puppet": {
      "command": "ruby",
      "args": ["~/dev/puppet-editor-services/puppet-languageserver","--stdio","--puppet-settings=--moduledir,/path/to/module/path"],
      "cwd": "~/dev/puppet-editor-services",
      "filetypes": ["puppet"],
      "rootPatterns": [".git/", "metadata.json"]
    }
  }
}

cf. https://voxpupuli.org/blog/2019/04/08/puppet-lsp-vim/

Débuggage: DAP

Un autre protocole à spécifiction ouverte également créé par Microsoft pour VS Code, mais qui permet de réutiliser des serveurs (adapteurs) Debugging Adapter Protocol (DAP) avec n'importe quel client du protocole.

Vim 8 a le client DAP vimspector qui transforme vim en débuggeur visuel!

note: les utilisatrices.teurs de emacs seraient p-e intéressés par: https://github.com/emacs-lsp/dap-mode

Installer vimspector:

Avec l'aide de Vundle (le même principe s'applique si vous utiliser les packages built-in de vim8 ou bien pathogen, ou vim-plug ou un autre):

Plugin 'puremourning/vimspector'

Installer des extensions (nommés gadgets dans la doc de vimspector):

Un peu comme avec coc.vim, il faut ensuite installer les adaptateurs DAP comme des extensions. Pour rendre l'installation des gadgets plus prévisible, on peut configurer la liste des gadgets "builtin" qu'on désire installer.

dans votre ~/.vimrc:

let g:vimspector_install_gadgets = [ 'debugpy', 'vscode-bash-debug' ]

Ensuite on peut installer les gadgets:

:VimspectorInstall 

Configurer des raccourcis clavier:

Par défaut, vimspector ne défini pas de raccourcis. On peut cependant lui demander de configurer un des deux ensembles de raccourcis.

dans ~/.vimrc:

let g:vimspector_enable_mappings = 'HUMAN'  # peut etre aussi VISUAL_STUDIO si on veut que les raccourcis ressemblent à ceux de VS Code

note: vous pouvez aussi définir vos propres mappings si vous n'aimez pas utiliser les touches F*

Adapteur DAP pour puppet

En utilisant le code du même repository git que pour l'adapteur LSP, puppet-editor-services, on peut configurer vimspector pour interagir avec l'apdapteur DAP qui s'y trouve: puppet-debugserver.

vimspector prendra en charge le download et l'installation du code de puppet-editor-services pour vous.

Créer une configuration d'adapteur custom pour vimspector:

L'expemple plus bas suppose que vous utilisez Vundle ou Pathogen, mais dans le cas où vous utilisez des packages vim 8, adaptez le chemin pour pointer vers où vous avez installé vimspector.

mkdir -p ~/.vim/bundle/vimspector/gadgets/custom
cat > ~/.vim/bundle/vimspector/gadgets/custom/cust_puppet-debugger <<EOF
{
  "puppet-debugserver":  {
    "download": {
      "url": "https://github.com/puppetlabs/puppet-editor-services/releases/download/${version}/${file_name}"
    },
    "all": {
      "version": "1.0.1",
      "file_name": "puppet_editor_services_1.0.1.zip",
      "checksum": "15b33bf63062f226466191d4417368a411f6a14f53c67d4898ca488a8b22454b",
      "adapters": {
        "cust_puppet-debugserver": {
          "command": [
            "ruby",
            "${gadgetDir}/cust_puppet-debugserver/puppet-debugserver",
            "--port",
            "${unusedLocalPort}"
          ],
          "configuration": {
            "cwd": "${workspaceRoot}"
          },
          "name": "puppet-debugserver",
          "port": "${unusedLocalPort}"
        }
      }
    }
  }
}
EOF

Dans vim, demandez à vimspector d'installer le gadget pour vous:

:VimspectorUpdate

Créer une configuration d'exécution par défaut:

Changer dans le fichier de configuration l'emplacement de vos répertoires de modules:

mkdir -p ~/.vim/bundle/vimspector/configurations/linux/puppet
cat > ~/.vim/bundle/vimspector/configurations/linux/puppet/run_current_file.json << EOF
{
  "configurations": {
    "launch current file": {
      "adapter": "cust_puppet-debugserver",
      "configuration": {
        "request": "launch",
        "manifest": "${file}",
        "noop": true,
        "args": [ 
          "--modulepath",
          "/home/gabster/koumbit/control-repo/site:/home/gabster/koumbit/control-repo/modules"
        ]
      }
    }
  }
}
EOF

Débugger du code:

Ça y est, on peut commencer à débugger! Il faut cependant savoir deux détails important pour pouvoir utiliser le débugger:

  1. Ce qu'on débug avec cet outil là c'est en fait la compilation du catalogue
    1. Donc débugger un fichier qui ne fait que déclarer une classe ou un type défini, mais qui ne l'utilise pas, ne sert à rien: on demande à puppet de créer un catalogue vide.
    2. Pour pouvoir débugger qqch de tangible, il faut avoir un fichier qui instancie une ou plusieurs ressources. Donc on doit se créer un fichier seulement pour faire ça. Le plus simple cas c'est un manifest puppet qui ne contient qu'une ligne include ce::que::vous::voulez::debugger

    3. Aussi, vu la façon dont on a configuré l'exécution par défaut, il faut placer notre fenêtre sur le fichier qui instancie des ressource avant de lancer le débuggeur. e.g. on peut avoir d'autres fichiers d'ouvert par exemple pour aller ajouter des breakpoints, mais il faudra revenir au fichier de test pour démarrer la session.
  2. Il faut absolument demander à puppet de s'arrêter qqpart, sans quoi le debuggeur lance puppet apply et ne s'arrête juste pas pendant la run.

    1. Avant de lancer le fichier, il faut donc créer au moins un breakpoint (voir les raccourcis pour faire ça).

Quelques informations complémentaires par rapport au débuggeur puppet:

Setup pour Vim <= 7

Syntax checking: Syntastic

Syntastic allows for easy Lint-style syntax checking for a variety of languages.

Syntastic currently supports more languages than LSP clients, but this is probably bound to get even as users are jumping more and more into LSP (see vim 8 section above). However, Syntastic suffers from not using Vim 8's asynchronous processes. This means that syntax checking can have a big impact on your editor's speed, or as a tradeoff happen only when saving a file. The current benefit of Synstastic though is that it does not require vim 8 to run.

To install Syntastic, you can either clone the upstream git repository as linked just above, and use a tool like Pathogen to manage installation, or you can install the debian package:

apt install vim-syntastic

These configurations in your .vimrc might make your experience more pleasant with Syntastic:

" Populate and open Location List when checking syntax
let g:syntastic_always_populate_loc_list = 1
let g:syntastic_auto_loc_list = 1
"let g:syntastic_check_on_open = 1 " This one's annoying when opening a large file
" Disable syntax check on that useless case
let g:syntastic_check_on_wq = 0

The following .vimrc settings will allow you to launch a syntax check and open up an error report pane quite rapidly:

nmap <silent> <leader>sc :SyntasticCheck<CR>
nmap <silent> <leader>se :Errors<CR>

Using Syntastic may require setting up a working syntax checker on your system. For example, to verify your code against the Drupal Coding Standards, you should install the Drupal Code Sniffer module, and tell vim to use it in place of the default PHP checks.

let g:syntastic_phpcs_conf='--standard=Drupal'

Note that the the Drupal Code Sniffer can be a bit too strict (even for core!), and slow on large files.

Gestionnaire de fichiers

Vim a un gestionnaire de fichier buit-in qui s'appelle netrw. Il est un peu simpliste et pourrait répondre aux besoin de beaucoup de gens. Les plugins plus bas cherchent à ajouter des features sur l'approche simpliste.

NERD Tree

NERD Tree is a filesystem explorer.

vinegar.vim

Utilise l'implémentation native de vim Netrw avec quelques ajustements. Remplace NERDTree et est plus facile à utiliser.

https://github.com/tpope/vim-vinegar

voir: Vim: you don't need NERDtree or (maybe) netrw

snippets

UltiSnips

UlstiSnips est essentiellement la même chose que SnipMate mais va plus vite. Le format des snippets est relativement le même que celui de SnipMate alors c'est possible d'utiliser les mêmes snippets.

Snipmate

Snipmate lets you define per-file type templates (or snippets) and use them in a manner similar to how you would in TextMate.

Write the snippet name and then hit the Tab key to paste the snippet in your buffer. You can then cycle through "variable" spots to change them (i.e. class name, parameter names, values, etc).

Here's an example, editing a php file:

<?php

ife<TAB>

The "ife" snippet is defined in this way in the php snippets:

snippet ife
        if (${1:/* condition */}) {
                ${2:// code...}
        } else {
                ${3:// code...}
        }
        ${4}

Hitting Tab right after typing "ife" will paste the associated snippet:

<?php

if (/* condition */) {
    // code...
} else {
    // code...
}

The "/* condition */" part will be highlighted. You can start typing to replace that part with the condition you'd like to verify.

When you placed what you wanted in the condition, hit Tab and it'll highlight the first "// code..." line. You can start typing to replace the line by the code you want to see in this part.

Hit Tab again, and it'll highlight the second "// code..." line. Type in the code for the second part.

When done, hit Tab again to move the cursor after the last closing brace.

Sadly, the original author seems to have stopped development, and stopped responding to tickets in the github interface. So, others have started to fork the project in order to add their own useful things..

Surround

Surround.vim makes your life easier when you want to substitute a delimiter around a string of text. With this plugin, you can easily change a singly-quoted string into a doubly-quoted one, a pair of curly braces around a block of code into square brackets or parentheses.

Par exemple, pour modifier un string qui utilise des guillemets double et lui faire utliser des apostrophes à la place, on se place dans la string et on peut utiliser:

cs"'

I can't really explain it better than this post by Peteris Krumins did.

Repeat

Repeat.vim re-maps your "." key to a function that can repeat mappings. So, it'll enable you to repeat a whole bunch of non-visual commands, like the "csw" mapping (change surrounding around word to something else) that the Surround.vim plugin above brings you.

Check out an example here.

Speeddating

Speeddating Adds date increment/decrement functionality to Ctrl-A/Ctrl-X.

... You knew about Ctrl-A/Ctrl-X before, right? You should!

The repeat.vim plugin makes those commands able to not only increase decimal, octal and hex numbers, but also dates. It wraps around time, day, month and year:

1999-12-30 # this is in your text, and you're in "normal" (e.g. not insert) mode

Place your cursor on or before the above date, and hit Ctrl-A to increase the date. It becomes:

2000-01-01

The plugin also adds mappings to transform a date in the text to the current date and time. In the above example, if you place your cursor on the date and hit the sequence 'd<Ctrl-X>', the date will be changed to the current date.

It can also increment/decrement roman numbers (I, II, III, IV, etc) and english ordinals ("1st", "2nd", "3rd", etc)

git

Quand on passe sa vie dans un éditeur de texte, on ne veut pas trop en sortir pour gérer le repository git dans lequel on travaille. Il existe quelques plugins pour faciliter l'intéraction avec git via vim.

Gitgutter

vim-gitgutter will show you diff-like indicators (e.g. +/-/~ to show added, removed and modified lines) in the gutter (vertical line left of line numbers, or the text buffer if line numbers are not enabled, when editing a file that's in a git repository. Indicators are updated every time you save the file.

This way you'll quickly know what changes are in place for this file with regards to what's in the repository.

fugitive.vim

Limelight

LimeLight creates a mode that can be activated to gray out all text but the current paragraph or block of code. It makes it super easy to focus on the current lines that you're editing.

With the following line in your vimrc, it'll make it easy to toggle LimeLight mode using Ctrl-g+l:

nnoremap <C-g>l :Limelight!!<CR>

fzf

fzf is a command line tool that takes lines of text as input and lets you interactively type to fuzzy-search something in those lines, then outputs the selection.

The vim plugin called fzf lets you use the fuzzy-search functionalities within vim. By itself it's only an integration, but you need to define functions for what text to search on and actions to take with the selection.

Unfortunately fzf is not yet packaged in debian, but the fzf vim plugin will offer to download it for you if it's missing. The binary will be installed in a bin/ directory inside the plugin's own directory (e.g. for me that was ~/.vim/bundle/fzf/bin/fzf)

fzf.vim is a plugin from the same author as the fzf vim plugin that basically just defines a couple of search functions for you. You can fuzzy-search file names on disk, file names tracked by git, git commit messages, file lines within vim buffers, file lines with the ag command (think grep -r), window names, buffer names, marks.

To use the recursive grep look-alike ag to search for file lines, you need to install that tool first: apt install silversearcher-ag.

To get a better idea of all functions from fzf.vim, see this presentation

* Il se peut que vous aillez des problèmes à utiliser fzf. Les instructions ne sont pas généralisé à pathogen par exemple.

* Si vous voyez: No fzf#run function c'est parce qu'il vous faut aussi installer l'utilitaire fzf en plus de fzf-vim: junegunn/fzf: A command-line fuzzy finder

* Une fois que vous avez clonez le repos, vous pouvez utiliser ./install --bin pour installer localement dans votre home.

* Dans .vimrc, il faut aujouter: set rtp+=~/.fzf. Cela va fonctionner si votre git clone de fzf est nommé .fzf et est à la racine de votre home.

tabular

tabular permet d'aligner des éléments par exemple pour former des tableaux bien espacés.

Pour l'utiliser on appelle la fonction Tabularize et on lui donne comme argument / et la chaîne de caractères autour duquel on veut aligner les choses. Par exemple, pour aligner un tableau dans moinmoin (penser rapport de paye), on peut utiliser la commande suivante pour aligner les double barres verticales:

:Tabularize /||

Aussi, dans le contexte du code puppet, le plugin est extrêmement utile pour aligner les flèches dans les "hash" de données ou bien les paramètres de define ou classe:

:Tabularize /=>

Guides visuels pour l'indentation: vim-indent-guides ou indentLine

Garder les choses alignées comme du monde sur les niveaux d'indentation c'est toujours un peu chiant quand on n'a pas d'indicateur visuel pour aider. Les deux plugins plus bas ajoutent des guides visuels pour ça!

" IndentLine                               
nnoremap <leader>il :IndentLinesToggle<CR> 

MatchTagAlways

The MatchTagAlways (MTA) plug-in for the Vim text editor always highlights the XML/HTML tags that enclose your cursor location. In other words, it's easier to spot the opening and closing tag.

Note:

If you use NeoVim, make sure python plugins support (PyNVim) is activated and/or installed.

vim-eunuch

Vim sugar for the UNIX shell commands that need it the most. Features include:

    :Delete: Delete a buffer and the file on disk simultaneously.
    :Unlink: Like :Delete, but keeps the now empty buffer.
    :Move: Rename a buffer and the file on disk simultaneously.
    :Rename: Like :Move, but relative to the current file's containing directory.
    :Chmod: Change the permissions of the current file.
    :Mkdir: Create a directory, defaulting to the parent of the current file.
    :Cfind: Run find and load the results into the quickfix list.
    :Clocate: Run locate and load the results into the quickfix list.
    :Lfind/:Llocate: Like above, but use the location list.
    :Wall: Write every open window. Handy for kicking off tools like guard.
    :SudoWrite: Write a privileged file with sudo.
    :SudoEdit: Edit a privileged file with sudo.
    File type detection for sudo -e is based on original file name.
    New files created with a shebang line are automatically made executable.

GitHub - tpope/vim-eunuch: eunuch.vim: Helpers for UNIX

Useful subsitute commands

moinmoin formatting

s/\[\[\([^|]*\)|\([^|]*\)\]\]/\2 (\1)/gc

Takes a moinmoin formatted wiki link and reformats it in the format:

Linktext (Linkpath)

Convert from camel case to underscore seperated

%s/\([a-z]\)\([A-Z]\)/\1_\L\2/gc

Themes

Solarized and vimdiff

set background=dark
let g:solarized_diffmode="high"
colorscheme solarized


CatégorieOutilSysadmin

Vim (last edited 2021-01-12 11:44:39 by gabriel)