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

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’

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

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.

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

+-- -- -- -- -- + -- -- --  -- -- -- + -- -- -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- -- -- +
|#  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            |
+-- -- -- -- -- + -- -- --  -- -- -- + -- -- -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- -- -- +