Vim/Como editar preferências

Como editar preferências no Vim

O arquivo de preferências do vim é ".vimrc", um arquivo oculto que pode ser criado no home do usuário

 ~/.vimrc

Caso use o Windows o arquivo é:

 ~\_vimrc

Onde colocar plugins e temas de cor

No windows procure ou crie uma pasta chamada 'vimfiles' que fica em

c:\documents and settings\seuusuario\

No linux procure ou crie uma pasta chamada .vim que deve ficar em

/home/user/.vim

Nesta pasta '.vim' ou 'vimfiles' deve haver pastas tipo

   vimfiles
      |
      +--color
      |
      +--doc
      |
      +--syntax
      |
      +--plugin

Comentários

 " linhas começadas com aspas são comentários
 " e portanto serão ignoradas pelo vim

Ao fazer modificações comente usando aspas duplas no começo da linha, os comentários lhe ajudarão mais tarde, pois à medida que o seu vimrc cresce podem aparecer dúvidas sobre o que determinado trecho faz :)

Notas sobre mapeamentos

Mapeamentos são um ponto importante do vim, com eles podemos controlar ações com quaisquer teclas, mas antes temos que saber que:

Tecla            : Tecla mapeada
<CR>             : Enter
<ESC>            : Escape
<LEADER>         : normalmente \
<BAR>            : | pipe 
<CWORD>          : Palavra sob o cursor
<CFILE>          : Arquivo sob o cursor
<CFILE><         : Arquivo sob o cursor sem extensão
<SFILE>          : Conteúdo do arquivo sob o cursor
<LEFT>           : Salta um caractere para esquerda
<UP>             : Equivale clicar em 'seta acima'
<M-F4>           : A tecla ALT -> M  mais a tecla F4
<C-f>            : Control f
<BS>             : Backspace
<space>          : Espaço
<TAB>            : Tab

No Vim podemos mapear uma tecla para o modo normal, realizando determinada operação e a mesma tecla pode desempenhar outra função qualquer em modo insert ou comando, veja:

 " mostra o nome do arquivo com o caminho
 map <F2> :echo expand("%:p") 

 " insere um texto qualquer
 imap <F2> Nome de uma pessoa  

A única diferença nos mapeamentos acima é que o mapeamento para modo insert começa com 'i', assim como para o modo comando ':' começa com 'c' no caso cmap.

Recarregando o arquivo de configuração

Cada alteração no arquivo de configuração do vim só terá efeito na próxima vez que você abrir o vim a menos que você coloque isto dentro do mesmo

" recarregar o vimrc
" Source the .vimrc or _vimrc file, depending on system
if &term == "win32" || "pcterm" || has("gui_win32")
	map ,v :e $HOME/_vimrc<CR>
	nmap <F12> :<C-u>source ~/_vimrc <BAR> echo "Vimrc recarregado!"<CR>
else
	map ,v :e $HOME/.vimrc<CR>
	nmap <F12> :<C-u>source ~/.vimrc <BAR> echo "Vimrc recarregado!"<CR>
endif                   

Agora basta pressionar F12 em modo normal e as alterações passam a valer instantaneamente!

Set

Os comandos set podem ser colocados no .vimrc:

set nu

ou digitados como comandos:

:set nu

 set nu       "mostra numeração de linhas
 set showmode "mostra o modo em que estamos
 set showcmd  "mostra no status os comandos inseridos
 set ts=4     "tamanho das tabulações
 syntax on    "habilita cores
 set hls      "destaca com cores os termos procurados
 set incsearch "habilita a busca incremental
 set ai       "auto identação
 set aw       "salvamento automático - veja :help aw
 set ignorecase "faz o vim ignorar maiúsculas e minúsculas nas buscas
 set smartcase  "Se começar uma busca em maiúsculo ele habilita o case
 set ic        "ignora maiúscula e minúsculas em uma busca
 set scs       "ao fazer uma busca com maiúsculos considerar case sensitive
 set backup
 set backupext=.backup
 set backupdir=~/.backup,./
 set cul        "abreviação de cursor line (destaca linha atual)
 set ve=all     "permite mover o cursor para áreas onde não há texto
 set ttyfast    "Envia mais caracteres ao terminal, melhorando o redraw de janelas. 
 set columns=88 "Determina a largura da janela.
 set mousemodel=popup "exibe o conteúdo de folders e sugestões spell

O comando gqap ajusta o parágrafo atual em modo normal

 " * coloca 2 espaços após o . quando usando o gq 
 "set nojoinspaces
" **************************************************************************
 " *                                                                        *
 " *   geralmente usamos ^I para representar uma tabulação                  *
 " *   <Tab>, e $ para indicar o fim de linha. Mas é possível               *
 " *   customizar essas opções. sintaxe:                                    *
 " *                                                                        *
 " *   set listchars=key:string,key:string                                  *
 " *                                                                        *
 " *                                                                        *
 " * - eol:{char}                                                           *
 " *                                                                        *
 " *     Define o caracter a ser posto depois do fim da linha               *
 " *                                                                        *
 " * - tab:{char1}{char2}                                                   *
 " *                                                                        *
 " *     O tab é mostrado pelo primeiro caracter {char1} e                  *
 " *     seguido por {char2}                                                *
 " *                                                                        *
 " * - trail:{char}                                                         *
 " *                                                                        *
 " *     Esse caracter representa os espaços em branco.                     *
 " *                                                                        *
 " * - extends:{char}                                                       *
 " *                                                                        *
 " *    Esse caracter representa o início do fim da linha  sem quebrá-la    *
 " *    Está opção funciona com a opção nowrap habilitada                    *
 " *                                                                        *
 " **************************************************************************
 "exemplo 1:
 "set listchars=tab:>-,trail:.,eol:#,extends:@

 "exemplo 2:
 "set listchars=tab:>-

 "exemplo 3:
 "set listchars=tab:>-

 "exemplo 4:
 set nowrap    "Essa opção desabilita a quebra de linha
 "set listchars=extends:+

 Caso esteja usando o gvim pode setar um esquema de cores
 set colo desert

Exibindo caracteres invisíveis

:set list

Setando macros prévias

Definindo uma macro de nome 's' para ordenar e retirar linhas duplicadas

 let @s=":%sort -u"

Para executar a macro 's' definida acima faça:

 @s

O Vim colocará no comando

 :%sort -u

Bastando pressionar <ENTER>. Observação: esta macro prévia pode ficar no vimrc ou ser digitada em comando ':'

Obs: O vim à partir de sua versão '7' passou a ter um comando de ordenação próprio, ou seja, ele não depende mais de comandos externos para ordenar e retirar duplicados

 :5,20sort u
 "da linha 5 até a linha 20 ordene e retire duplicados

 :sort n
 " ordene meu documento considerando números
 " isto é útil pois se a primeira coluna contiver 
 " números a ordenação pode ficar errada caso não usemos
 " o parâmetro 'n'

Mapeamentos

Mapeamentos permitem criar atalhos de teclas para quase tudo. Tudo depende de sua criatividade e do quanto conhece o Vim.

Os mapeamentos abaixo são úteis para quem escreve códigos html, permitem inserir caracteres reservados do html usando uma barra invertida para proteger os mesmos, o vim substituirá os "barra alguma coisa" pelo caractere correspondente.

    inoremap \& &
    inoremap \< &lt;
    inoremap \> &gt;
    inoremap \. &middot;

O termo inoremap significa: em modo "insert" não remapear, ou seja ele mapeia o atalho e não permite que o mesmo seja remapeado, e o mapeamento só funciona em modo insert, isso significa que um atalho pode ser mapeado para diferentes modos de operação.

Veja este outro mapeamento:

 map <F11> <esc>:set nu!<cr>

Permite habilitar ou desabilitar números de linha do arquivo corrente. A exclamação ao final torna o comando booleano, ou seja, se a numeração estiver ativa será desabilitada, caso contrário será ativada. O "<cr>" ao final representa um ENTER.

Limpando o buffer de buscas

A cada busca, se a opção 'hls' estiver habilitada o vim faz um destaque colorido, mas se você quiser limpar pode fazer este mapeamento

  nno <S-F11> <esc>:let @/=""<CR>

É um mapeamento para o modo normal que faz com que a combinação de teclas Shift-F11 limpe o buffer de buscas

Destacar palavra sob o cursor

  nmap <s-f> :let @/="<C-r><C-w>"<CR>

O atalho acima 's-f' corresponde a Shift-f

Remover linhas em branco duplicadas

  map ,d <esc>:%s/\(^\n\{2,}\)/\r/g<cr>

No mapeamento acima estamos associando o atalho

,d

à ação desejada, fazer com que linhas em branco sucessivas seja substituidas por uma só linha em branco, vejaos como funciona:

 map ...................... mapear
 ,d ....................... atalho que quermos
 <esc> .................... se estive em modo insert sai
 : ........................ em modo de comando
 % ........................ em todo o arquivo
 s ........................ substitua
 \n ....................... quebra de linha
 {2,} ..................... duas ou mais vezes
 \r ....................... trocado por \r enter 
 g ........................ globalmente
 <cr> ..................... confirmação do comando

As barras invertidas podem não ser usadas se o seu vim estiver com a opção magic habilitada

:set magic 

Por acaso este é um padrão portanto tente usar assim pra ver se funciona

map ,d :%s/\n{2,}/\r/g<cr>

Os atalhos

Para criar mapeamentos, precisamos conhecer a maneira de representar as teclas e combinações. Alguns exemplos:

<C-X>   onde 'C'  corresponde a CTRL e 'X' a uma tecla qualquer
<Left>  seta para a esquerda
<Right> seta para a direita
<C-M-A> CTRL+ALT+A

Podemos fazer mapeamentos globais ou que funcionam em apenas um modo:

map  - funciona em qualquer modo
nmap - apenas no modo Normal
imap - apenas no modo de Inserção

Mover linhas com Ctrl+(seta abaixo) ou Ctrl+(seta acima):

" tem que estar em modo normal!
nmap <C-Down> ddp
nmap <C-Up> ddkP

Salvando com uma tecla de função:

" salva com F9
nmap <F9> :w<cr>
" F10 - sai do vim
nmap <F10> <esc>:q<cr>

Convertendo as iniciais de um documento para maiúsculas

" MinusculasMaiusculas: converte a primeira letra de cada
" frase para MAIÚSCULAS
nmap ,mm :%s/\C\([.!?][])"']*\($\|[ ]\)\_s*\)\(\l\)/\1\U\3/g<CR>
"caso queira confirmação coloque uma letra 'c' no final da linha acima:
" (...) \3/gc<CR>

Autocomandos

Autocomandos habilitam comandos automáticos para situações específicas. Se você deseja que seja executada uma determinada ação ao iniciar um novo arquivo o seu autocomando deverá ser mais ou menos assim:

 au BufNewFile tipo ação

Veja um exemplo:

 au BufNewFile,BufRead *.txt source ~/.vim/syntax/txt.vim

No exemplo acima o vim aplica autocomandos para arquivos novos "BufNewFile" ou existentes "BufRead" do tipo 'txt' e para estes tipos carrega um arquivo de syntax, ou seja, um esquema de cores específico.

  " http://aurelio.net/doc/vim/txt.vim    coloque em ~/.vim/syntax
  au BufNewFile,BufRead *.txt source ~/.vim/syntax/txt.vim

Para arquivos do tipo txt '*.txt' use um arquivo de syntax em particular

O autocomando abaixo coloca um cabeçalho para scripts 'bash' caso a linha 1 esteja vazia, observe que os arquivos em questão tem que ter a extensão .sh

  au BufEnter *.sh if getline(1) == "" | :call setline(1, "#!/bin/bash") | endif 

Autocomando para arquivos python

" autocomandos para python
autocmd BufRead *.py set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class

Fechamento automático de parênteses

" --------------------------------------
" Ativa fechamento automático para parêntese
" Set automatic expansion of parenthesis/brackets
inoremap ( ()<esc>:call BC_AddChar(")")<cr>i
inoremap { {}<esc>:call BC_AddChar("}")<cr>i
inoremap [ []<esc>:call BC_AddChar("]")<cr>i
" inoremap " ""<esc>:call BC_AddChar(""")<cr>i
"
" mapeia CTRL+j para pular fora de parênteses colchetes etc...
inoremap <C-j> <esc>:call search(BC_GetChar(), "W")<cr>a
" Function for the above
function! BC_AddChar(schar)
   if exists("b:robstack")
       let b:robstack = b:robstack . a:schar
   else
       let b:robstack = a:schar
   endif
endfunction
function! BC_GetChar()
   let l:char = b:robstack[strlen(b:robstack)-1]
   let b:robstack = strpart(b:robstack, 0, strlen(b:robstack)-1)
   return l:char
endfunction

Outra opção para fechamento de parênteses

" Fechamento automático de parênteses
imap { {}<left>
imap ( ()<left>
imap [ []<left>

" pular fora dos parênteses, colchetes e chaves, mover o cursor
" no modo insert
imap <c-l> <esc><right>a
imap <c-h> <esc><left>a

Destaque colorido para endereços IP

Referências: http://vim.wikia.com/wiki/Mathing_valid_IP_address

 syn match ipaddr   /\(\(25\_[0-5]\|2\_[0-4]\_[0-9]\|\_[01]\?\_[0-9]\_[0-9]\?\)\.\)\{3\}\(25\_[0-5]\|2\_[0-4]\_[0-9]\|\_[01]\?\_[0-9]\_[0-9]\?\)/
 hi link ipaddr Identifier

Fechamento automático de Tags HTML

 imap ><Tab> ><Esc>mt?<\w<Cr>:let @/=""<Cr>lyiw`ta</><Esc>P`tli

Agora basta escrever a sua tag e ao fechá-la com * aperte <Tab> para completar com seu respectivo fechamento.

Data automática

Caso esta função esteja configurada corretamente, a cada salvamento do arquivo a data contida no cabeçalho será atualizada.

" =============== DATA AUTOMÁTICA ===========================
" insira na em seus arquivos =   "ultima modificação:"
" em qualquer das três primeiras linhas
fun! SetDate()
  mark z
  if getline(1) =~ ".*ultima modificação:" ||
                          \ getline(2) =~ ".*ultima modificação:"  ||
                          \ getline(3) =~ ".*ultima modificação:"  ||
                          \ getline(4) =~ ".*ultima modificação:"  ||
                          \ getline(5) =~ ".*ultima modificação:"
     exec "1,5s/\s*ultima modificação: .*$/ultima modificação: " . strftime("%c") . "/"
  endif
  exec "'z"
endfun
"  abaixo a chamada a função de data que é chamada toda vez que você
"  salva um arquivo preexistente
fun! LastChange()
  mark z
  if getline(1) =~ ".*Last Change:" ||
                          \ getline(2) =~ ".*Last Change:"  ||
                          \ getline(3) =~ ".*Last Change:"  ||
                          \ getline(4) =~ ".*Last Change:"  ||
                          \ getline(5) =~ ".*Last Change:"
     exec "1,5s/\s*Last Change: .*$/Last Change: " . strftime("%c") . "/"
  endif
     exec "'z"
endfun
" coloquei duas opções (alteração e modificação), assim
" não tem perigo de você esquecer e o sistema
" não atualizar a data do salvamento, outra melhoria na função
" é que agora é válida para qualquer tipo de arquivo. se usar
" num html por exemplo insira um começo de comentário na linha
" da data e feche o comentário na próxima linha
"  abaixo a chamada a função de data que é chamada toda vez que você
"  salva um arquivo preexistente
au BufWritePre * call SetDate()
au BufWritePre * call LastChange()
"============ Fim da Data Automática ===================

Change log

" === Cria um registro de alterações de arquivo ========
" ChangeLog entry convenience
" Função para inserir um status do arquivo
" cirado: data de criação, alteração, autor etc (em modo normal)
fun! InsertChangeLog()
   normal(1G)
   call append(0, "Arquivo")
   call append(1, "Criado: " . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(2, "ultima modificação: " . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(3, "Autor: Sérgio Luiz Araújo Silva")
   normal($)
endfun
map ,cl :call InsertChangeLog()<cr>A
"
" Cria um cabeçalho para scripts bash
fun! InsertHeadBash()
   normal(1G)
   :set ft=bash
   :set ts=4
   call append(0, "#!bin/bash")
   call append(1, "# Criado em:" . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(2, "# ultima modificação:" . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(3, "# Nome da empresa")
   call append(3, "# Propósito do script")
   normal($)
endfun
map ,sh :call InsertHeadBash()<cr>A

Barra de status

" O trecho abaixo formata a barra de status com algumas opções interessantes!
" mostra o código ascii do caractere sob o cursor e outras coisas mais
set statusline=%F%m%r%h%w [FORMATO=%{&ff}] [TIPO=%Y] [ASCII=\%03.3b] [HEX=\%02.2B]   [POSIÇÃO=%04l,%04v][%p%%] [TAMANHO=%L]
set laststatus=2 " Sempre exibe a barra de status

Mudar cor da barra de status dependendo do modo

 " Ao entrar em modo insert ele muda a cor da barra de status
 " altera a cor da linha de status dependendo do modo
 if version >= 700
	 au InsertEnter * hi StatusLine term=reverse ctermbg=5 gui=undercurl guisp=Magenta
	 au InsertLeave * hi StatusLine term=reverse ctermfg=0 ctermbg=2 gui=bold,reverse
 endif

Rolar outra janela

Se você dividir janelas tipo

Ctrl-w-n

pode colocar esta função no seu .vimrc

 " rola janela alternativa
 fun! ScrollOtherWindow(dir)
	if a:dir == "down"
		let move = "\<C-E>"
	elseif a:dir == "up"
		let move = "\<C-Y>"
	endif
	exec "normal \<C-W>p" . move . "\<C-W>p"
 endfun
 nmap <silent> <M-Down> :call ScrollOtherWindow("down")<CR>
 nmap <silent> <M-Up> :call ScrollOtherWindow("up")<CR>

Esta função é acionada com o atalho 'alt' + setas acima e abaixo

Função para numerar linhas

Adicione as linhas abaixo ao seu vimrc

"numerar linhas 
command! -nargs=* -range Nlist <line1>,<line2>call Nlist(<f-args>)
function! Nlist(...) range
    if 2 == a:0
        let start = a:1
        let append = a:2
    elseif 1 == a:0
        let start = a:1
        let append = " "
    else
        let start = 1
        let append = " "
    endif

    " try to work like getline (i.e. allow the user to pass in . $ or 'x)
    if 0 == (start + 0)
        let start = line(start)
    endif

    exe a:firstline . "," . a:lastline . 's/^/\=line(".")-a:firstline+start.append/'
endfunction

Agora você pode fazer uma seleção visual

Shift-v

Pressionar 'j' até selecionar o trecho desejado e

:'<,'>Nlist

O vim numerará o trecho selecionado à partir de 1 outro modo seria assim:

 map ,n <esc>:let i=1 <bar> g/^/s//\=i."\t"/ <bar> let i=i+1<cr>

Só que deste modo ele numeraria todo o arquivo usando o atalho ,n

Função para trocar o esquema de cores

	function! <SID>SwitchColorSchemes()
	  if exists("g:colors_name")
		if g:colors_name == 'native'
		  colorscheme billw
		elseif g:colors_name == 'billw'
		  colorscheme desert
		elseif g:colors_name == 'desert'
		  colorscheme navajo-night
		elseif g:colors_name == 'navajo-night'
		  colorscheme  zenburn
		elseif g:colors_name == 'zenburn'
		  colorscheme bmichaelsen
		elseif g:colors_name == 'bmichaelsen'
		  colorscheme wintersday
		elseif g:colors_name == 'wintersday'
		  colorscheme summerfruit
		elseif g:colors_name == 'summerfruit'
		  colorscheme native
		endif
	  endif
	endfunction
	map <silent> <F6> :call <SID>SwitchColorSchemes()<CR>

baixe os esquemas aqui: http://nanasi.jp/old/colorscheme_0.html

Miscelânea

Uma função para inserir cabeçalho de scrip bash para chamar a função basta pressionar, sh em modo normal

" Cria um cabeçalho para scripts bash
fun! InsertHeadBash()
   normal(1G)
   :set ft=bash
   :set ts=4
   call append(0, "#!/bin/bash")
   call append(1, "# Criado em:" . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(2, "# ultima modificação:" . strftime("%a %d/%b/%Y hs %H:%M"))
   call append(3, "# NOME DA SUA EMPRESA")
   call append(3, "# Propósito do script")
   normal($)
endfun
map ,sh :call InsertHeadBash()<cr>

Função para inserir cabeçalhos python

 " função para inserir cabeçalhos python
 fun! BufNewFile_PY()
 	normal(1G)
 	:set ft=python
 	:set ts=2
 	call append(0, "#!/usr/bin/env python")
 	call append(1, "# # -*- coding: ISO-8859-1 -*-")
 	call append(2, "# Criado em:" . strftime("%a %d/%b/%Y hs %H:%M"))
 	call append(3, "# Last Change: " . strftime("%a %d/%b/%Y hs %H:%M"))
 	call append(4, "# Instituicao: <+nome+>")
 	call append(5, "# Proposito do script: <+descreva+>")
 	call append(6, "# Autor: <+seuNome+>")
 	call append(7, "# site: <+seuSite+>")
 	normal gg
 endfun
 autocmd BufNewFile *.py call BufNewFile_PY()
 map ,py :call BufNewFile_PY()<cr>A

" Ao editar um arquivo será aberto no último ponto em " que foi editado

 autocmd BufReadPost *
   \ if line("'\"") > 0 && line("'\"") <= line("$") |
   \   exe "normal g`\"" |
   \ endif

"
" Permite recarregar o Vim para que modificações no
" Próprio vimrc seja ativadas com o mesmo sendo editado
nmap <F12> :<C-u>source $HOME/.vimrc <BAR> echo "Vimrc recarregado!"<CR>

Redimensionar janelas

" Redimensionar a janela com
" ALT+seta à  direita e esquerda
map <M-right> <ESC>:resize +2 <CR>
map <M-left> <ESC>:resize -2 <CR>

Função para pular para uma linha qualquer

"ir para linha
" ir para uma linha específica

 function! GoToLine()
 let ln = inputdialog("ir para a linha...")
 exe ":" . ln
 endfunction

 "no meu caso o mapeamento é com Ctrl-l
 "use o que melhor lhe convier
 imap <S-l> <C-o>:call GoToLine()<CR>
 nmap <S-l> :call GoToLine()<CR>

Função para gerar backup

A função abaixo é útil para ser usada quando você vai editar um arquivo gerando modificações significativas, assim você poderá restaurar o backup se necessário

" A mapping to make a backup of the current file.
fun! WriteBackup()
        let fname = expand("%:p") . "__" . strftime("%d-%m-%Y_%H:%M:%S")
        silent exe ":w " . fname
        echo "Wrote " . fname
endfun
nnoremap <Leader>ba :call WriteBackup()<CR>

O atalho

<leader>

em geral é a contrabarra "\" na dúvida

:help <leader>

Como adicionar o python ao path do vim?

• fonte: http://vim.wikia.com/wiki/Automatically_add_Python_paths_to_Vim_path

Coloque o seguinte script em:

• ~/.vim/after/ftplugin/python.vim (on Unix systems)
• $HOME/vimfiles/after/ftplugin/python.vim (on Windows systems)

python << EOF
import os
import sys
import vim
for p in sys.path:
    # Add each directory in sys.path, if it exists.
    if os.path.isdir(p):
        # Command 'set' needs backslash before each space.
        vim.command(r"set path+=%s" % (p.replace(" ", r"\ ")))
EOF

Isto lhe permite usar 'gf' ou Ctrl-w Ctrl-F para abrir um arquivo sob o cursor

Criando um menu

Como no vim podemos ter infinitos comandos fica complicado memorizar tudo é aí que entram os menus, podemos colocar nossos plugins e atalhos favoritos em um menu veja este exemplo

amenu Ferramentas.ExibirNomeDoTema :echo g:colors_name<cr>

O comando acima diz:

 amenu ........................... cria um menu
 Ferramentas.ExibirNomeDoTema ......... Menu plugin submenu ExibirNomeDoTema
 :echo g:colors_name<cr> ......... comando para exibir o nome do tema de cores atual

Caso haja espaços no nome a definir você pode fazer assim

amenu Ferramentas.Exibir\ nome\ do\ tema :echo g:colors_name<cr>

Criando menus para um modo específico

:menu .... Normal, Visual e Operator-pending
:nmenu ... Modo Normal
:vmenu ... Modo Visual
:omenu ... Operator-pending modo
:menu! ... Insert e Comando
:imenu ... Modo Insert
:cmenu ... Modo de comando
:amenu ... todos os modos

Exemplo de menu

" cores

menu T&emas.cores.quagmire :colo quagmire<CR>
menu T&emas.cores.inkpot :colo inkpot<CR>
menu T&emas.cores.google :colo google<CR>
menu T&emas.cores.ir_black :colo ir_black<CR>
menu T&emas.cores.molokai :colo molokai<CR>
" Fontes
menu T&emas.fonte.Inconsolata :set gfn=Inconsolata:h10<CR>
menu T&emas.fonte.Anonymous :set anti gfn=Anonymous:h8<CR>
menu T&emas.fonte.Envy\ Code :set anti gfn=Envy_Code_R:h10<CR>
menu T&emas.fonte.Monaco :set gfn=monaco:h9<CR>
menu T&emas.fonte.Crisp :set anti gfn=Crisp:h12<CR>
menu T&emas.fonte.Liberation\ Mono :set gfn=Liberation\ Mono:h10<CR>

O comando

:update 

Atualiza o menu recem modificado.

Quando o comando

:amenu

É usado sem nenhum argumento o vim mostra os menus definidos atualmente

Para listar todas as opções de menu para 'Plugin' por exemplo faça:

:amenu Plugin

Outros mapeamentos

Destaca espaços e tabs redundantes
Highlight redundant whitespace and tabs.

highlight RedundantWhitespace ctermbg=red guibg=red
match RedundantWhitespace /\s\+$\| \+\ze\t/

Explicando com detalhes

\s ................ espaço
\+ ................ uma ou mais vezes
$ ................. no final da linha
\| ................ ou 
" " ............... espaço (veja imagem acima)
\+ ................ uma ou mais vezes
\ze ............... até o fim
\t ................ tabulação

Portanto a expressão regular acima localizará espaços ou tabulações no final de linha e destacará em vermelho.

"Remove espaços redundantes no fim das linhas

map <F7> <esc>mz:%s/\s\+$//g<cr>`z

Um detalhe importante

mz .............. marca a posição atual do cursor para ternornar no final do comando
`z .............. retorna à marca criada

Se não fosse feito isto o cursor iria ficar na linha da última substituição!

" Função mais elaborada para remover expaços extras

fun! CleanExtraSpaces()
   let save_cursor = getpos(".")
   let old_query = getreg('/')
   :%s/\s\+$//e
   call setpos('.', save_cursor)
   call setreg('/', old_query)
endfun
nmap <silent> <leader>c :call CleanExtraSpaces()<cr>
autocmd BufWritePre * :call CleanExtraSpaces()

Como uma função (visto acima) guardamos a posição do cursor (getpos) e a última busca efetuada (getreg) fazemos a deleção se houver de espaços extras (se não houver a opção "e" evita mensagens de erro e finalmente restauramos o registro de busca e posção do cursor, tudo isso encapsupsulado em uma função de nome "CleanExtraSpaces" que é então mapeada para ser chamada com "\c" ou executada automaticamente quando o arquivo for salvo

"Abre o vim-vim explorer

map <F6> <esc>:vne .<cr><bar>:vertical resize -30<cr><bar>:set nonu<cr>

Fazendo buscas e substituições

Podemos usar expressões regulares em buscas do Vim veja um exemplo para retirar todas as tags html

"mapeamento para retirar tags html com Ctrl+Alt+t
 nmap <C-M-t> :%s/<[^>]*>//g <cr>

" Quebra a linha atual no local do cursor com F2

nmap <F2> a<CR><Esc>

" join lines -- Junta as linhas com Shift F2

nmap <S-F2> A<Del><Space>

Complementação com tab

"Word completion
"Complementação de palavras
set dictionary+=/usr/dict/words
set complete=.,w,k

"====== complementação de palavras ====
"usa o tab em modo insert para completar palavras
function! InsertTabWrapper(direction)
    let col = col('.') - 1
    if !col || getline('.')[col - 1] !~ '\k'
        return "\<tab>"
    elseif "backward" == a:direction
        return "\<c-p>"
    else
        return "\<c-n>"
    endif
endfunction

inoremap <tab> <c-r>=InsertTabWrapper ("forward")<cr>
inoremap <s-tab> <c-r>=InsertTabWrapper ("backward")<cr>

Abreviações

Também no .vimrc você pode colocar abreviações, que são uma espécie de auto-texto para o vim

iab slas Sérgio Luiz Araújo Silva
iab Linux GNU/Linux
iab linux GNU/Linux

" Esta abreviação é legal para usar com o python

 im :<CR> :<CR><TAB>

Referências

• http://www.dicas-l.com.br/dicas-l/20050118.php