sábado, 4 de abril de 2009

Repeat: plugin que permite repetir comandos de outros plugins

Os plugins podem remapear comandos nativos. No entanto, o comando '.' só irá
repetir o último comando nativo, ignorando o comando remapeado por um plugin.

'repeat.vim' remapeia o comando '.' de forma que '.' possa repetir também comandos
remapeados por plugins.

Para isso o plugin deve fazer uma chamada para o plugin 'repeat', veja a
documentação.

'surround.vim' já faz isso, portanto seus comandos podem ser repetidos com '.'
depois da instalação do 'repeat.vim'.

Baixe o plugin aqui: http://www.vim.org/scripts/script.php?script_id=2136 .

Copie o arquivo 'repeat.vim' para '~/.vim/plugin'.

Reinicie o vim.

Mas não é perfeito, somente alguns comandos do 'surround' podem ser repetidos:
'cs' e 'ds' mas não 'ys'.

Exemplo, repetindo comandos do plugin 'surround':
a,b,c,d
Posicione no 'a' e use 'csw)':
(a)
Agora avance para cada letra com 'w' e pressione '.'.
O comando se repetirá em cada letra.':
(a),(b),(c),(d)

Instalando o corretor ortográfico português brasileiro do vim

Vá para esta página http://www.broffice.org/verortografico/baixar e baixe o corretor ortográfico do BrOffice.org (Vero - Verificador Ortográfico).

Descompacte o arquivo.

No vim use:
:mkspell pt pt_BR
O comando irá compilar os arquivos 'pt_BR.aff' e 'pt_BR.dic' e gerar
'pt.utf-8.spl'.

Copie o arquivo para ~/.vim/spell ou $VIMRUNTIME/spell .

Defina a opção para ativar correção ortográfica no vim:
:set spell
e o idioma:
:set spelllang=pt
Além disso, use o dicionário como base para auto-completar texto:
set complete+=kspell

Surround: plugin para colocar, alterar e excluir delimitadores em torno do texto

O plugin surround.vim é especializado em deletar, excluir e alterar toda espécie
de pares de delimitadores tais como "...", '...', <...>, etc.

Assim ele permite envolver um texto com uma tag html, ou deletar um par de '{}'
ou adicionar aspas em torno de palavras.

Baixe o plugin daqui: http://www.vim.org/scripts/script.php?script_id=1697 .

Extraia o arquivo .zip para ~/.vim. O extrator colocará arquivos no subdiretórios
'doc' e 'plugin'.
Reinicie o vim ou inclua na memória com:
:so ~/.vim/plugin/surround.vim
Regere as tags de help com:
:helptags ~/.vim/doc

Para documentação:
:help surround

Primeiro, posicione o cursor sobre a palavra que será cercada pelo delimitador

Para deletar delimitadores use o comando 'ds'+delimitador.
O delimitador determina que carácter deve ser deletado.
ds" - deleta um par de aspas duplas.
ds) - deleta um par de parenteses.
dst - deleta um par de tags html/xml.

Para alterar delimitadores use o comando 'cs'+delimitador_atual+delimitador_novo.
cs"' - troca aspas duplas por aspas simples.
cs"<q> - troca aspas duplas por uma tag.
cs)] - troca parenteses por colchetes.
cs)[ - troca parenteses por colchetes e um espaço.
cst<p> - troca uma tag html por outra tag.

Para adicionar delimitadores use 'cs'+objeto_texto+delimitador ou 'ys'+movimento+delimitador ou
'ys'+objeto_texto+delimitador.
csw' - coloca aspas simples em torno de uma palavra.
csW' - coloca aspas simples em torno de uma Palavra.
csw) - coloca parenteses em torno de uma palavra.
ysiw) - coloca parenteses em torno de uma palavra.
ysiwt<html> - coloca a tag em torno de uma palavra.
yss" - coloca aspas duplas em torno de uma sentença.
ySS" - coloca aspas duplas e 2 linhas em torno de uma sentença.

No modo inserção:
<Ctrl-S>delimitador - insere um par de delimitadores e coloca o cursor entre
eles.
<Ctrl-S><Ctrl-S>delimitador - insere o primeiro delimitador em uma linha, insere
uma linha vazia com o cursor e insere o segundo delimitador em outra linha:
<Ctrl-S><Ctrl-S><html>

O comando '.', por default, não repete os comandos do 'surround'. Para isso baixe e use o plugin repeat.vim.

sexta-feira, 3 de abril de 2009

Definindo uma função do usuário no vim

Para definir use:
:function {nome}({var1}, {var2}, ...)
: {corpo}
:endfunction

O nome da função deve começar com uma letra maiúscula.

Uma função que retorna o menor de dois números:
:function Min(num1, num2)
: if a:num1 < a:num2
:    let smaller = a:num1
: else
:    let smaller = a:num2
: endif
: return smaller
:endfunction
':function Min(num1, num2)' define que uma função chamada 'Min' que leva dois argumentos. ': if a:num1 < a:num2' testa qual número é menor. O prefixo 'a:' diz que a variável é um argumento de função. ': let smaller = a:num1' assinala para a variável 'smaller' o menor número. Variáveis dentro de uma função são locais, a não ser que sejam prefixadas com 'g:', 'a:' ou 's:'. ': return smaller' retorna o menor número para o usuário. Um versão reduzida da função:
:function Min(num1, num2)
: if a:num1 < a:num2
:    return a:num1
: endif
: return a:num2
:endfunction
Uma função do usuário é chamada do mesmo jeito que uma função predefinida:
:echo Min(5, 8)

Somente quando a função é usada é que os erros, se tiverem, aparecerão.

Quando uma função atinge ':endfunction' ou o ':return' não tem argumento, ela
retorna zero.

Para redefinir uma função que já existe use '!':
:function! Min(num1, num2, num3)

Grupos de funções predefinidas do vim

Manipulação de string
Manipulação de lista
Manipulação de dicionário
Cálculo de ponto-flutuante
Variáveis
Posição de cursor e de marca
Trabalhando com texto no buffer corrente
Funções de sistema e de manipulação de arquivo
Data e Hora
Buffers, janelas e lista de argumentos
Linha de comando
Quickfix e listas de localização
Autocompletar no modo inserção
Folding
Sintaxe e colorização
Ortografia
Histórico
Interativo
GUI
Servidor vim
Tamanho e posição da janela
Vários

Use:
:h functions
para ver os detalhes de cada função.

Usando funções predefinidas do vim

O vim tem uma grande quantidade de funções.

A função é chamada com o comando ':call':
:call search("Date: ", "W")

Isto chama a função 'search()', com argumentos 'Date: ' e 'W'. Esta função usa
como primeiro argumento um padrão de pesquisa e o segundo como flags.
O flag 'W' significa que a pesquisa não volta ao atingir o fim do arquivo.

Uma função pode ser chamada em uma expressão:
:let line = getline(".")
:let repl = substitute(line, '\a', "*", "g")
:call setline(".", repl)

A função getline() obtém uma linha do buffer corrente. Seu argumento é uma
especificação do número de linha. Neste caso, '.' é a linha em que está o
cursor.

A função substitute() é semelhante ao comando :substitute, o primeiro argumento
é o string aonde será feita a troca, o segundo argumento é o padrão, o terceiro
é o string de troca e o quarto as flags.

A função setline() define a linha, especificada pelo primeiro argumento, a ser
substituída por um novo string no 2º argumento.

O efeito dos três comandos é igual a:
:substitute/\a/*/g

Avaliando e executando uma expressão no vim

Use :
:execute {expressão}
A expressão é avaliada pelo vim e o string resultante é executado como um comando Ex.

Exemplo, saltar para uma tag cujo valor está dentro de uma variável:
:execute "tag " . tag_name
O comando concatena ('.') 'tag ' com o valor em 'tag_name'. Supondo que a variável tem 'get_cmd', o comando que será executado é:
:tag get_cmd
O comando ':execute' só pode executar comandos dois-pontos (':').
O comando ':normal' executa comandos no modo normal. No entanto, seu argumento não é uma expressão mas caracteres de comando literais:
:normal gg=G
Isto salta para a primeira linha, e formata todo arquivo com o comando '='.

Para fazer o comando ':normal' trabalhar com uma expressão, combine-o com o ':execute':
:execute "normal " . normal_commands
A variável 'normal_commands' deve conter os comandos do modo normal.
Esteja certo que o comando normal esteja completo, caso contrário o vim abortará o comando.

Exemplo:
:execute "normal Inew text \<Esc>"
isto insere 'new text' na linha corrente. Note o uso da chave especial '\<Esc>'. Isso evita de entrar o caracter real <Esc> dentro do script.

Se não quiser executar o string, mas avalia-lo para obter o valor da expressão, você pode usar a função 'eval()':
:let optname = "path"
:let optval = eval('&' . optname)
Um '&' é colocando antes de 'path', assim o argumento para 'eval()' é '&path'. O resultado é o valor da opção 'path'.

O mesmo pode ser feito com:
:exe 'let optval = &' . optname

Suspendendo a execução do vim por um período de tempo

Use:
:sleep 50m
fará o vim ficar suspenso por 50 milissegundos.
:sleep 4
suspende por 4 segundos.
:sleep 
suspende por 1 segundo.
Pode ser interrompido com
<Ctrl-C>

Saindo de um loop no vim script

Saltar de volta para o início do loop; o loop continua:
:continue

Saltar para frente para o ':endwhile'; o loop termina:
:break

Exemplo:
:while contador < 40
: call faz_algo()
: if flag_salto
: continue
: endif
: if flag_fim
: break
: endif
: sleep 50m
:endwhile

O case nas comparações dentro de um vim script

A opção 'ignorecase' é usada quando comparando strings.

Quando você não quer isso, use '#' para considerar o case e '?' para ignorar o case.

Assim '==?' compara se dois strings são iguais ignorando o case, '!~#' verifica se um padrão não tem ocorrência, considerando o case das letras.

Usando expressão regular no vim script

Os strings tem mais 2 operadores:

a =~ b tem ocorrencia
a !~ b não tem ocorrencia

O item a esquerda é usado como string e o a direita como um padrão.
Exemplo:
:if str =~ " "
: echo "str contains a space"
:endif
:if str !~ '\.$'
: echo "str does not end in a full stop"
:endif
Note o uso do padrão com aspas simples. Isso é útil pois os backslashes precisariam ser duplicados dentro das aspas duplas e os padrões tendem a ter muito backslashes.

Comparando strings e números no vim script

Quando comparando strings, a diferença matemática é usada. Isto compara valores
de bytes, o qual pode não ser o correto para algumas linguagens.

Quando comparando string com número, o string primeiro é convertido para um
número. Isto é um pouco complicado, pois quando um string não se parece com um
número, o número zero é usado.

Exemplo:
:if 0 == "one"
: echo "yes"
:endif
Isto imprimirá 'yes', pois 'one' não se parece com um número.

A versão do vim na variável v:version

Ela tem o valor da versão do vim: 600 para a versão 6.0, 601 para a versão 6.1.

Isto é útil para scripts que trabalham com diversas versões do vim.

:if v:version >= 700

Operações lógicas no vim script

Eis algumas das mais comuns:
a == b igual a
a != b diferente de
a > b maior que
a >= b maior ou igual que
a < b menor que
a <= b menor ou igual a

O resultado é um, ser for verdade ou zero, se for falso.
Exemplo:
:if v:version >= 700
: echo "congratulações"
:else
: echo "você, está usando uma versão antiga, atualize!"
:endif
Os operadores lógicos funcionam com números e strings.

quinta-feira, 2 de abril de 2009

Condições no vim script

A expressão condicional:
a ? b : c

Se 'a' avalia para verdadeiro então 'b' é usado, caso contrário 'b' é usado:
  :let i = 4
  :echo i > 5 ? "i is big" : "i is small"
< i is small
Os comandos ':if' executam os comandos seguintes até o ':endif' correspondente,
somente quando uma condição acontece:
:if {condição}
   {comandos}
:endif
Pode ser usado também:
:if {condição}
  {comandos}
:else
  {comandos}
:endif
E também:
:if {condição}
  {comandos}
:elseif {condição}
  {comandos}
:endif
Um exemplo de condição, que testa a opção 'term' e faz algo dependendo do seu
valor:
:if &term == "xterm"
: " Faça coisas para o xterm
:elseif &term == "vt100"
: " Faça coisas para o vt100
:else
: " Faça algo para outros terminais
:endif

terça-feira, 31 de março de 2009

Operação matemática, precedência e agrupamento no Vim script

Operações com números:
a + b soma
a − b subtração
a * b multiplicação
a / b divisão
a % b módulo

As regras de precedência se aplicam:
  :echo 10 + 5 * 2
  < 20
Agrupamento é feito com parenteses:
  :echo (10 + 5) * 2
  < 30

Expressões no vim script

O vim usa números, strings e variáveis nas expressões.

Strings podem ser concatenados com '.':
:echo "foo" . "bar"
< foobar

Além disso usa:
variáveis de ambiente - $NAME
opção - &name
registrador - @r

:echo "The value of 'tabstop' is" &tsusr_doc.txt
:echo "Your home directory is" $HOME
:if @a > 5

A forma &name pode ser usada para salvar uma opção de valor, defini-la com um
novo valor ou fazer alguma coisa e restaurar o valor antigo.

Exemplo:
:let save_ic = &ic
:set noic
:/The Start/,$delete
:let &ic = save_ic

Este código faz com que a pesquisa seja feita com a opção 'ignorecase'
desligada.
Todavia, ele mantém o valor que o usuário definiu.
(Um outro modo de fazer isso é adicionar '\C' ao padrão).

segunda-feira, 30 de março de 2009

Variáveis e constantes string em scripts vim

O tipo no vim script é dinâmico. Ele é definido cada vez que um valor é
assinalado por ':let'.
Aqui usando strings com aspas duplas:
:let name = "peter"
:echo name
< peter

Se quiser incluir uma aspa dupla dentro do string, use o backslash na frente:
:let name = "\"peter\""
:echo name
< "peter"

Strings de aspas duplas suportam caracteres especiais. Eis alguns:
\t <Tab>
\n <NL>, quebra de linha
\r <CR>, <Enter>
\e <Esc>
\b <BS>, backspace
\" "
\\ \, backslash

E dois exemplos de entrar teclas:
\<Esc> <Esc>
\<C−W> CTRL−W

Para entrar palavras-chave de script:
\<name>

Para evitar o uso de backslash, use o string de aspas simples:
:let name = '"peter"'
:echo name
< "peter"

Todos caracteres entre backslash são considerados literalmente, exceto o
backslash. Para incluir uma aspa simples no string, use duas aspas simples.

Testando se uma variável já está definida no script

Quando um script termina, as variáveis locais usadas ainda existirão pois não
liberadas automaticamente. A próxima vez que usar o script, ele poderá ainda
usar o valor antigo:

:if !exists("s:call_count")
: let s:call_count = 0
:endif
:let s:call_count = s:call_count + 1
:echo "called" s:call_count "times"

A função 'exists()' verifica se a variável está definida. O seu argumento é o
nome da variável, e não a variável em si !
Se usar, a variável, o seu valor é que será verificado pela existência.

Deletando variáveis

Use:
:unlet s:count
isto deleta a variável local para o script 's:count'.

Se não tiver certeza que a variável existe, e não quiser a mensagem de erro use:
:unlet! s:count

Listando todas variáveis de script

Para ver uma lista de variáveis correntemente definidas use:
:let

Lista o valor de cada variável e o tipo :
String
# - Número
* - Funcref

Variáveis no script vim

O nome da variável consiste letras ASCII, dígitos e underscore.
Não pode iniciar com um dígito.

Nomes de variáveis válidas:
counter
_aap3
very_long_variable_name_with_underscores
FuncLength
LENGTH

Estas variáveis são globais. Elas podem ser usadas em qualquer arquivo script.
Isto leva a confusão.
Para evitar isso, prefixe o nome da variável com 's:':
:let s:count = 1
:while s:count < 5
: source other.vim
: let s:count += 1
:endwhile

Desde que 's:count' é local do script, voce tem certeza que 's:count' em outros
scripts serão diferentes e não interfirão com a variável.

Outros tipos de variáveis:

b:name variável local para um buffer
w:name variável local para uma janela
g:name variável global (também em uma função)
v:name variável pré-definida Vim

Os tipos de números no script vim

Os números pode ser decimal, hexadecimal e octal.

O hexadecimal começa com '0x' ou '0X'. '0x1f' = 31.
O octal começa com '0'. '017' = 15. Não ponha um zero antes de um número
decimal, ele será interpretado como octal.

O comando ':echo' sempre imprime decimais:
:echo 0x7f 036
< 127 30

uma subtração.
:echo 0x7f − 036
< 97

domingo, 29 de março de 2009

Executando o conteúdo de um registrador

Copie o script vim (yank) e use:
:@registrador
aonde o registrador é {0-9a-z".=*}

Isso é útil para copiar exemplos de scripts vim e executa-los logo em seguida.

Um vim script de exemplo

Exemplos de vim script são o arquivo de startup .vimrc e os arquivos de sintaxe.
Macros complicados podem ser definidas como scripts vim.

Exemplo:
:let i = 1
:while i < 5
: echo "count is" i
: let i += 1
:endwhile

Os ':' são opcionais. Eles são só necessários quando digitando comandos. No vim
script eles podem ficar de fora. Deixaremos eles para ficar claro que são
comandos de dois-pontos, e para destaca-los dos comandos do modo normal.

A primeira linha assinala um valor a uma variável.
O formato geral é:
:let {variável} = {expressão}

Neste caso o nome da variável é 'i' e a expressão é um valor simples, 1.
O comando ':while' inicia um loop. A forma genérica é :
:while {condição}
: {comandos}
:endwhile
Os comandos até o ':endwhile' correspondente são executados enquanto a condição
é verdadeira. A condição é 'i < 5'.
Se quiser interromper um loop cuja condição não a termine, use <Ctrl-C>.

O comando ':echo' imprime seus argumentos. Neste caso o string 'count is' e o
valor da variável i.

O comando ':let i += 1' soma 1 na variável 'i' e assinala o novo valor para a
mesma variável.

Ignorando eventos do Vim

Ao ignorar eventos, os autocomandos correspondentes serão ignorados.
Use a opção:
:set eventignore=WinEnter,WinLeave
para ignorar certos eventos
:set eventignore=all
para ignorar todos eventos
:set eventignore=
para voltar o comportamento normal.

Usando comandos do modo normal nos autocomandos

Os comandos executados por um autocomando são comandos de linha de comando.
Se quiser usar um comando do modo normal, use o comando ':normal':

:autocmd BufReadPost *.log normal G

Isto fará com que o cursor salte para a última linha de arquivos *.log quando
voce começar a edita-lo.

Não esqueça de completar o comandos do modo normal:
'i', para entrar em modo inserção, deve ser seguido por <Esc> para sair.
'/' deve ser terminado com um <CR> para executa-lo.

O comando ':normal' usa todo o texto que o segue como comandos. Assim não pode haver
um '|' e um comando seguinte. Para evitar isso, use o comando ':normal' dentro
de um comando ':execute'.

Isto também torna possível passar caracteres não-imprimíveis de um modo
conveniente:

:autocmd BufReadPost *.chg execute "normal ONew entry:\<Esc>" |
\ 1read !date

Executando autocomandos

O comando 'doautocmd' simula um evento:
:doautocmd grupo evento nome-do-arquivo
Ele executa o autocomando 'grupo' se fazendo de arquivo 'nome-de-arquivo' simulando o evento 'evento'.

Se 'grupo' for omitido, todos os grupos são usados.
Se 'nome-de-arquivo' for omitido, o nome corrente é usado.
O 'evento' é obrigatório.

Exemplo:
Suponhamos que você tem um tipo de arquivo 'cx' que você gostaria que usasse os
mesmos autocomandos do tipo de arquivo 'c'.
Você faria assim:
:doautocmd cprograms FileReadPost foo.c
Isso faz com que execute o autocomando 'cprograms' como se o arquivo se chamasse 'foo.c' no evento 'FileReadPost'.

Um autocomando disparando outro autocomando:
:autocmd BufReadPost *.new execute "doautocmd BufReadPost " . expand(":r")
Isto define um autocomando que é disparado quando de uma nova edição. O nome do
arquivo deve terminar com '*.new'.
O comando 'execute' avalia a expressão para formar um novo comando e executa-lo.

Quando for editar um arquivo 'tryout.c.new' o comando executado será:
:doautocmd BufReadPost tryout.c

A função 'expand()' leva o argumento '', o qual tem o nome do arquivo que
o autocomando foi executado, e leva a raíz do nome do arquivo com ':r':

':doautocmd' executa sobre o buffer corrente.
':doautoall' executa em todos buffers.

Permitindo aninhamento de eventos dentro de um autocomando

Por default, comandos executados como resultado de um evento de autocomando não disparam novos eventos.

Se você lê um arquivo em resposta ao evento 'FileChangedShell', ele não irá
disparar eventos que de definição de sintaxe, por exemplo.

Para ter os eventos disparados, adicione o argumento 'nested':
:autocmd FileChangedShell * nested edit

Definindo grupos de autocomandos

Grupos servem para associar autocomandos relacionados com um nome. Isto pode ser
usado para deletar todos os autocomandos de um certo grupo.

Por exemplo, definindo um grupo de autocomandos para programas C:
:augroup cprograms
: autocmd BufReadPost *.c,*.h :set sw=4 sts=4
: autocmd BufReadPost *.cpp :set sw=3 sts=3
:augroup END
Isso fará o mesmo:
:autocmd cprograms BufReadPost *.c,*.h :set sw=4 sts=4
:autocmd cprograms BufReadPost *.cpp :set sw=3 sts=3

Se quiser adicionar um novo comando nesse grupo para os headers, você pode usar
o comando ':augroup' ou simplesmente adiciona-lo ao grupo:
:autocmd cprograms FileReadPost *.h :set cindent
Para deletar todos os autocomandos do grupo use:
:autocmd! cprograms

Listando autocomandos

Para listar os autocomandos definidos:
:autocmd
Para filtrar a lista por evento use:
:autocmd BufNewFile
Para filtrar a lista por padrão de arquivo:
:autocmd * *.c
O primeiro '*' significa listar todos eventos do padrão. Para listar todos autocomandos do grupo 'cprograms':
:autocmd cprograms