No sé qué razón se oculta tras la configuración por defecto de mi vim/gvim que el auto-completado se ve de pena. Tenía un color rosa de fondo con letras blancas, con tan poco contraste que molesta. Para cambiar esta opción y que nuestro vim deje de tener pluma, podemos hacer lo siguiente:

highlight Pmenu guibg=blue guifg=white ctermbg=blue ctermfg=white
highlight PmenuSel guibg=white guifg=blue ctermbg=white ctermfg=blue

Esto en el ~/.vimrc y problema resuelto.

Gracias al vim-tip-1486

Estoy demasiado acostumbrado a como completa bash los nombres de ficheros, escribes un cacho le das a TAB y esperas a que complete hasta donde pueda… si insistes te saca una lista de opciones y vas completando hasta llegar al destino. Vim, cuando estás en modo comando, tiene la fea costumbre de completar todo el nombre con cada TAB… en un directorio con varios ficheros suele ser un suplicio llegar al que toca. Pero afortunadamente todo en vim es configurable, en este caso la opción se llama wildmode.

Para tener un comportamiento similar al bash, puedes poner esto en tu ~/.vimrc:

set wildmode=longest,list:longest

wildmode tiene hasta dos parámetros separados por ‘,’ el primero es lo que ocurre justo después del primer TAB, el segundo cuando el TAB se vuelve a pulsar. En este caso le estamos pidiendo que haga un match con la entrada común más larga posible (por defecto es full, que viene a decir un match completo), y si vuelves a presionar TAB mostará una lista y seguirá haciendo match con la entrada común más larga.

Para más info ‘:h wildmode’

Vamos a darle un giro de tuerca a lo que vimos en el post anterior, en este post veremos cómo compilar con cmake usando vim de forma productiva. En primer lugar, necesitamos algo que nos permita compilar un proyecto (de cmake) cuando estamos editando sus ficheros. Mientras editamos los ficheros solemos estar dentro de algún subdirectorio del proyecto con lo que nos bastaría un script que buscara el directorio build y el CMakeLists.txt y lanzara el make.

Es fácil escribir ese script, el mío lo llamo vim-cmake-makeprg y lo tengo accesible en ~/bin . Al ejecutarlo irá subiendo directorios hasta encontrar un CMakeLists.txt y un directorio build. El resultado es que cuando estoy dentro de un proyecto con este comando puedo compilarlo independientemente de donde esté.

Una vez tenemos el script, sólo nos queda decirle a vim que lo utilice para compilar, para ello editamos el ~/.vimrc y añadimos:

set makeprg=vim-cmake-makeprg


Ahora ya podemos trabajar en nuestro proyecto, editamos (con vim) cualquier fichero, empezamos a programar, y para compilar escribiremos:

:make


Aquí es donde comienza la magia de quickfix, en primero se pone a compilar, veremos la salida del proceso de compilación en el buffer de texto de vim. La salida se pasa por un filtro que va capturando los mensajes de error relevantes y los va añadiendo en una lista. Al terminar de compilar vim abrirá el primer fichero que contenga errores y posicionará el cursor en el primer error, también nos mostrará una versión resumida del error:

Podemos ver la lista completa de errores con el comando cl:

Finalmente, estos son algunos de los comandos que podemos usar con quickfix:

• :cl listar los errores
• :cc mostrar el mensaje completo del error actual
• :cn moverse al siguiente error
• :cp moverse al error anterior

Usando vim+quickfix, y cmake tendremos definitivamente una forma mucho más eficiente de programar-compilar-corregir-programar…

No hace demasiado que SnippetsEmu (un emulador de TextMate para vim del que hablábamos aquí) pasaba a la versión 1.2.1. Sé que no hace falta que hable del plugin ya que todo el mundo lo usa y es feliz y además, sigue su desarrollo… pero sólo por si las moscas, os dejo con una demo MUY curiosa:

grabada con TTYshare ! (me encanta)

más en Slippery Snippets

Grabar macros en vim significa ahorrarnos tener que teclear acciones repetitivas. Por ejemplo (caso ficticio) estamos en C++, tenemos que coger todos los métodos de un objeto y escribir una secuencia de acciones en otro fichero usando ese nombre de método. Más concretamente, estaba yo escribiendo unos bindings de C->lua cuando decidí que esto de las macros había que grabarlo, no os centréis en el código, lo interesante es cómo funcionan las macros en vim:

Get the Flash Player to see this player.

Si no ves bien el vídeo, puedes bajarlo de aquí.

El truco:
Editamos el fichero “test.cpp”, vamos a escribir los wrappers de “osg/Node”… tenemos algo así:

#include <osg/Node>

Movemos el cursor sobre la cabecera y tecleamos control-w f (control == tecla de control, “w” y “f” en minúsculas) con esto vim nos va a dividir la pantalla en dos, como se muestra en el screencast y en la parte de arriba abrirá el fichero “osg/Node”. Cómo no tiene extensión pero yo se que es c++, escribiendo :set syntax=c nos pone el resaltado de sintaxis.

Ya estamos listos, ahora lo que queremos es escribir por cada una de los métodos de la clase osg::Node algo como esto.

.set("nombre-de-metodo", &Node::nombre-de-metodo);

¿cómo lo hacemos? a) forma pesada y aburrida, a manilla. b) forma más entretenida, con macros.
Para hacerlo con macros, seguimos estos pasos (para este ejemplo):

• Como el cursor aun está en la cabecera (arriba) lo situamos en el primer método y con control-w w nos volvemos a cpp donde quiero escribir código. También sitúo el cursor en este buffer.
• q q   Sí, dos “q”, la primera es para decir “voy a grabar una macro” la segunda es para decir “la macro se llama q” si sólo vas a trabajar con una macro esporádicamente es muy práctico escribir “qq” y empezar a grabar. Vim se pone en modo grabando
• control-w w   nos vamos al buffer de la cabecera (arriba)
• ^ f ( b y t (   Divertido eh? veamos con detalle qué está pasando aquí:
  • ^   Mueve el cursor al principio de la linea
  • f (   busca el primer “(”, lo que nos lleva justo al final del nombre del método
  • b   Desplaza el cursor hacia atrás una palabra, justo al principio del nombre del método
  • y t (   “copia(y) hasta(t) (”
  • ahora ya tenemos copiado el nombre del método
• control-w w   nos vamos al buffer de codigo (abajo)
• o .set(”Esc p i “, &Node::Esc p i ) Esc

  esto es literalmente lo teclado, o inserta una linea y se pone en modo inserción, Esc vuelve al modo comando, p pega lo copiado, i se pone en modo inserción.

• control-w w   nos vamos al buffer de cabecera (arriba)
• 2j q   Desplazamos 2 lineas hacia abajo y con q paramos de grabar.

Una vez tenemos grabada la macro la reproducimos con @q la @ es para reproducir la macro y “q” es el nombre de nuestra macro. Ya se que bien mirado, parece rebuscado, pero al vídeo me remito es más cómodo y rápido de lo que parece cuando uno se acostumbra a usarlo.

Vim es mi editor favorito, pero ajustarlo para que nos sea cómodo es un proceso que lleva su tiempo. Concretamente para editar texto siempre uso la opción “wrap” que lo que hace es romper las líneas en pantalla, por lo que cada párrafo es una línea, así si cambio el ancho del editor los párrafos siguen siendo párrafos.

El problema es que los movimientos <Up>(k) <Down>(j) por la pantalla mueven de línea en línea, o lo que es lo mismo para mi usando wrap, de párrafo en párrafo lo que resulta muy incómodo para moverse ya que si quieres ir a una palabra de en medio tienes que ir desplazándote a la derecha o izquierda hasta llegar. Así que me puse a buscar cómo podría solucionar esto, y como siempre, alguien lo había pensado ya.

Se trata del vim-tip #38, el tip es importante pero más aun los comentarios, en particular mi solución (modificando ligeramente un comentario) ha resultado ser esta:

" tip #38
function! ScreenMovement(movement)
    if &wrap
        return "g" . a:movement
    else
        return a:movement
    endif
endfunction

onoremap <silent> <expr> j ScreenMovement("j")
onoremap <silent> <expr> <Down> ScreenMovement("j")
onoremap <silent> <expr> k ScreenMovement("k")
onoremap <silent> <expr> <Up> ScreenMovement("k")
onoremap <silent> <expr> 0 ScreenMovement("0")
onoremap <silent> <expr> ^ ScreenMovement("^")
onoremap <silent> <expr> $ ScreenMovement("$")

nnoremap <silent> <expr> j ScreenMovement("j")
nnoremap <silent> <expr> <Down> ScreenMovement("j")
nnoremap <silent> <expr> k ScreenMovement("k")
nnoremap <silent> <expr> <Up> ScreenMovement("k")
nnoremap <silent> <expr> 0 ScreenMovement("0")
nnoremap <silent> <expr> ^ ScreenMovement("^")
nnoremap <silent> <expr> $ ScreenMovement("$")

vnoremap <silent> <expr> j ScreenMovement("j")
vnoremap <silent> <expr> <Down> ScreenMovement("j")
vnoremap <silent> <expr> k ScreenMovement("k")
vnoremap <silent> <expr> <Up> ScreenMovement("k")
vnoremap <silent> <expr> 0 ScreenMovement("0")
vnoremap <silent> <expr> ^ ScreenMovement("^")
vnoremap <silent> <expr> $ ScreenMovement("$")

Esto va en el ~/.vimrc es un poco largo pero funciona, con esto ya nos podemos mover por el texto correctamente si usamos wrap.

Via vim.org -> lista de correo de vim

luarefvim es un plugin de vim que integra el manual de lua (actualizado a 5.1) y atajos de teclado para buscar en él.

+-- -- -- -- -- + -- -- --  -- -- -- + -- -- -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- -- -- +
|#  edit  #|#    key     #|                                        |
|#  mode  #|#  sequence  #|#             action                   #|
+-- -- -- -- -- + -- -- --  -- -- -- + -- -- -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- -- -- +
|@ normal @|  <Leader>lr  |  reference for word under cursor       |
|@ visual @|  <Leader>lr  |  reference for visually selected text  |
|$ any    $|  <Leader>lc  |  manual's table of contents            |
+-- -- -- -- -- + -- -- --  -- -- -- + -- -- -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- -- -- +