Eu já tinha lido sobre uma opção do Vim chamada keywordprg, mas nunca havia encontrado uma serventia. Quando eu li no blog do bjori, realmente me veio à mente como eu poderia utilizá-la.

Eu instalei a última versão do pear aqui, e executei os comandos que ele cita no blog:

pear install doc.php.net/pman

Eu precisei aumentar a memória do php.ini (memory_limit), 32M não foi o suficiente.

O manual será instalado no diretório especificado em “doc_dir” da configuração da pear e o executável no “bin_dir“. Para verificar as configurações atuais:

pear config-show # Mostra todas as configurações atuais
pear config-get bin_dir # Mostra configuração atual da opção bin_dir
pear config-get doc_dir # Mostra configuração atual da opção doc_dir
# Para modificar:
pear config-set bin_dir /outro/bin
pear config-set doc_dir /outro/docs

Depois de instalado, você pode utilizar ele tanto no Vim quanto fora do Vim:

pman array_merge

Bom, se lembra que eu havia falado sobre o keywordprg ? Assim como o makeprg é o programa executado ao se executa :make no Vim e o grepprg o comando executado ao se executar :[grep|vimgrep], o keywordprg é executado quando se preciona K (k maiúsculo) sobre alguma palavra chave – que no nosso caso será uma função php.

O artigo citado ali em cima, indica para colocarmos no .vimrc, mas eu acho mais interessante por no .ftplugin/php.vim (se o arquivo não existir, crie). Assim, só será carregado caso o tipo do arquivo for php, possibilitando utilizar outros programas para outras linguagens

" Programa executado quando pressionado K
set keywordprg=pman

Agora faça o teste: abra um arquivo php, coloque o cursor sobre alguma função e pressione K. Para fechar o manual aberto, basta precionar q. Pode-se utilizar a busca com /termo e também navegar nos resultados com n/N. j/k/UP/DOWN movem o arquivo para cima e para baixo, normalmente, como se fosse um manpage.

Eai, este post ajudou em algo?

Eu já sabia da existência, mas nunca tinha visto um motivo para fazê-lo. Trata-se do vim ou gvim dentro do Eclipse. Alguns motivos que me tentaram a usá-lo:

• Compilar é muito mais simples no eclipse.
• Achar arquivos em pacotes é mais fácil com o Project Browser
• Pode-se utilizar outros plugins do Eclipse, como o de modelagem pra Swing, AWT, etc
• Integração com o SVN

Instalação

A instalação está descrita no próprio site do Vimplugin, e pode ser encontrada em http://vimplugin.org/installation.

Na configuração, ignore o campo de porta e senha, deixe como está. Apenas passe o caminho para o vim (geralmente /usr/bin/vim ou /usr/bin/gvim) e marque a opção “Embed vim to eclipse”. Pois se ela não estiver marcada, o vim é aberto externamente. Com o gvim, ao invés do vim, o eclipse coloca até os menus e toolbars, caso não estejam escondidos com o guioptions.

Pelo fato de se poder especificar argumentos opcionais para o vim, é possível fazer um .vimrc específico para utilização com o Eclipse. Muito útil.

Utilização

Para abrir um arquivo pelo vim: Botão direito sobre o arquivo > Open with > Vim.

Todas as funcionalidades estão presentes. Só não consegui fazer funcionar o DELETE, tem que ser no backspace ou x. Pode-se abrir vários arquivos em buffers e/ou abas, usar macros e substituições por expressões regulares, igual como quando independente.

Conclusão

Ainda prefiro o (g)vim sozinho, é mais leve e prático. Mas convenhamos, para java, talvez essa realmente seja a melhor opção. Alguém tem crítica sobre outros plugins?

Quando eu vou escrever em algum programa de qualquer suíte de escritório – openoffice, koffice, etc -, eu geralmente me preocupo mais com o negrito da palavra, com identação do parágrafo do que com o conteúdo em si. Isso é um pecado.

Meu primeiro instinto foi: vou escrever tudo no Vim, depois colo no Impress. Boa! Ok, mas e quanto às páginas?
Vou ter que por página por página? Ainda sim eu teria mais trabalho. Eu teria que refazer as listas para que ficassem com as “bolinhas” à esquerda. E teria que modificar todos os títulos para negrito?

Fui pro google e achei um plugin que já conhecia no resultado: VimOutliner. Ele dita uma sintaxe muito intuitiva para hierarquisar (existe esse verbo?) o conteúdo. Algo assim:

Título do documento
 
Tópico Nível 1
	Tópico Nível 2
	: Parágrafo com alinhamento justify
	; Parágrafo fica do jeito que foi escrito
	- Item de lista
	+ Item de lista numérica

O plugin vem com documentação e um shell script que instala automaticamente o plugin. O site tem toda documentação, é bem simples.

Em http://perens.com/FreeSoftware/Outline/ é possível encontrar vários scripts que convertem o documento para outros formatos. Um deles é o vo2odp.rb, um script em ruby para converter arquivos para o OpenOffice Presentation.

Pra fazê-lo rodar, eu sofri um pouquinho. Tive que instalar o ruby (obviamente) e o rubygems. Depois de instalado:

$ gem install builder
$ gem install rubyzip

Também alterei o script, segue o patch das modificações:

29,30c29,30
< require_gem 'builder'
< require_gem 'rubyzip'
---
> require 'builder'
> require 'zip/zip'

Copie o trecho acima em um arquivo, por exemplo: /tmp/patch_vo2odp, depois execute

$ patch /caminho/para/vo2odp.rb < /tmp/patch_vo2odp

Pronto, agora só escrever sua apresentação. Lembre-se que o plugin tem uma extenção própria, a .otl. Sempre que um arquivo for aberto com esta extenção, o Vim irá carregar o syntax highlight apropriado e algumas outras opções para melhor escrever sua apresentação.

Concluída a apresentação, você pode usar

$ ruby /caminho/para/vo2odp.rb apresentacao.otl apresentacao.odp

Abra com o OpenOffice e salve como .ppt. Pronto! Você acabou de fazer sua apresentação no PowerPoint pelo Vim.

Observações importantes

• O script não quebra as páginas dos slides automaticamente. É separado por capítulos de nível 1. Então, não escreva coisas muito longas dentro de um nível. Lembre-se que é uma apresentação e não um documento de texto.
• Quando aberto no OpenOffice, use o negrito, sublinhado, coloque imagens, etc. Crie seu layout e não pense nisso durante a criação do conteúdo. Escreva antes e formate depois

E isso ai! Gostou? Não? Comente! Dê dicas e sugestões!

Muita gente me perguntava o que eu punha no meu .vimrc, quais configurações e o que elas faziam. Então, pra ajudar o pessoal e também manter uma documentação (porque eu esqueço rápido essas coisas), eu criei o .vimrc generator.

A idéia é que se possa criar um .vimrc através da interface web, facilitando a propagação (caso você queira mostrar pro amigo, contribuínte ou seja lá quem for) do seu .vimrc! Vocês podem ler um pouco mais aqui. Também tenho plano de fazer estatísticas, como por exemplo: quais opções mais usadas, quais colorschemes mais utilizados, etc. Portanto, sinta-se a vontade de testar a ferramenta e dar um feedback!

Sugestões de opções interessantes, de coisas faltando, reclamações, são todas bem-vindas! Pode ter certeza que, se implementada, manterei os créditos da sua idéia. Por enquanto só está disponível em inglês, mas logo traduzirei pro português. Quem sabe feriado que vem? hehehe

Espero que aproveitem! Gere seu próprio .vimrc

Até!

E aquela palavra que você sempre escreve errada? Aquela função que você sempre esquece o nome?

Conheça algumas dicas para aumentar a produtividade e diminuir o trabalho dessas coisas rotineiras.

Lista de Abreviaturas

Sabe aquelas palavras que a gente insiste em escrever errado? Principalmente quem trabalha com e-mails, códigos e comentários em outras línguas tem dificuldades com certas palavras. Por exemplo,

vc -> você
q -> que
pq -> porque
nao -> não

Agora a pergunta que não quer calar: Porque não usarmos algo para evitar esse tipo de coisa? Às vezes nem notamos os erros, mas eles estão lá. Mantenha uma lista de abreviaturas no Vim. Cuide dela, adicione novas abreviaturas assim que vierem à sua cabeça. A sintaxe é simples, basta adicionar no seu .vimrc:

"" abbr ERRADO CORRETO, por exemplo:
abbr pq porque
abbr vc você

O Vim ainda possibilita que você crie sintaxes diferentes para arquivos diferentes. Então, seus arquivos .txt podem ter abreviaturas diferentes das de .py. Ou seja, se o nome daquela função python é muito longa ou você insiste em escrevê-la errada, ela merece uma abreviatura, no formato descrito acima (abbr ERRADO CORRETO).

$ mkdir -p ~/.vim/abreviaturas/
$ vim ~/.vim/abreviaturas/txt.vim

Adicione ao txt.vim as abreviaturas utilizadas para arquivos texto. Mesmo que poucas, coloque algumas. Um pouco de disciplina fará com que sua produtividade aumente. Tenha certeza.

Ao seu .vimrc, basta acrescentar:

autocmd BufNewFile,BufRead * source $HOME/.vim/abreviaturas/para_qualquer_linguagem.vim
autocmd BufNewFile,BufRead *.txt source $HOME/.vim/abreviaturas/txt.vim
autocmd BufNewFile,BufRead *.py source $HOME/.vim/abreviaturas/python.vim

O autocmd funciona mais ou menos igual a uma trigger. É um sistema de eventos, basicamente. Ou seja, ao abrir um arquivo novo (BufNewFile) ou um arquivo já existente (BufRead), se o nome do arquivo casar com a expressão (no caso, *, *.txt ou *.py) irá executar o código a seguir.

Vou falar mais sobre o autocmd em outro post, tem muitoooo pano pra manga, hehehe.

Templates de Arquivos

Quando se fala em programação é meio que como na arte. Não só porque programar é uma arte, mas porque nada se cria, tudo se copia. Tudo bem que, hoje em dia, com técnicas de encapsulamento, oop, etc, fica mais difícil. Mas sempre há coisas em comum entre os arquivos. Vamos começar com algo simples.

Template básico para javascript, onde será utilizado jquery.

$(document).onready(function(){
// code here
});

Simples, mas não é um saco ter que escrever isso sempre que abre um arquivo novo? Tome isso como regra: Faça uma, porém apenas uma vez. Não seria mais fácil abrir o arquivo e tcha-ram! Lá está o código que, em 90% dos casos, você irá utilizar?

Esse foi pequeninho, mas imagine um arquivo html. A trabalheira que é copiar todo o caçalho. E se você segue um padrão, pode usar inclusive o css junto. Observe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pt" lang="pt-br" dir="ltr">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<meta http-equiv="Content-Style-Type" content="text/css" />
		<meta name="keywords" content="aqui,vai,as,keywords" />
		<link rel="stylesheet" href="/style.css" />
		<link rel="shortcut icon" href="/favicon.ico" />
        </head>
        <body>
        <div id="wrapper">
                <div id="head"></div>
                <div id="content"></div>
                <div id="footer"></div>
        </div>
</body></html>

E o css:

1
2
3
4
5
6
7
8
9
10
11
12

html * {
}
body {
}
#wrapper {
}
        #wrapper #head {
        }
        #wrapper #content {
        }
        #wrapper #footer {
        }

Imagine um designers, aqueles que fazem o psd e depois passam pra xhtml, tendo que copiar isso vezes e vezes para todos os arquivos que ele faz. Faça apenas uma vez e siga o padrão!

Usuários de django, ao criar um model, precisam escrever sempre os imports ? Se são utilizados sempre, porque não criar um template?

Agora você me pergunta, como carregar o template automagicamente no Vim ? Fácil! Utilizando nosso autocmd =). Do mesmo modo que fizemos com as abreviaturas, vamos criar os diretórios:

$ mkdir -p ~/.vim/templates/

Criei lá os arquivos com os templates que você acha útil.

autocmd BufNewFile *.html 0r ~/.vim/templates/html.tpl
autocmd BufNewFile style.css 0r ~/.vim/templates/cssstyle.tpl
autocmd BufNewFile jquery.*.js 0r ~/.vim/templates/jqueryjs.tpl

Agora, abra seu Vim e sinta a magia:

vim index.html style.css jquery.initscript.js

Executando comandos externos

g(un)zip

O manual do Vim tem um exemplo bem interessante, para abrir arquivos gzipados, editá-los, como se nada tivesse acontecido e salvá-lo no formato gzip de novo. Apesar de que aqui, não precisou acrescentar os códigos abaixo, ele já fez automático. Basta adicionar o .vimrc

augroup gzip
  autocmd!
  autocmd BufReadPre,FileReadPre	*.gz set bin
  autocmd BufReadPost,FileReadPost	*.gz '[,']!gunzip
  autocmd BufReadPost,FileReadPost	*.gz set nobin
  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " . expand("%:r")
  autocmd BufWritePost,FileWritePost	*.gz !mv <afile> </afile><afile>:r
  autocmd BufWritePost,FileWritePost	*.gz !gzip </afile><afile>:r
 
  autocmd FileAppendPre		*.gz !gunzip </afile><afile>
  autocmd FileAppendPre		*.gz !mv </afile><afile>:r </afile><afile>
  autocmd FileAppendPost		*.gz !mv </afile><afile> </afile><afile>:r
  autocmd FileAppendPost		*.gz !gzip </afile><afile>:r
augroup END
</afile>

Verificação por erro

Já deve ter acontecido com você: você salva o arquivo e quando vai testar, faltou um ponto e vírgula, ou escrever o nome de uma função errada, ou algo similar… um erro bobo, mas que não deixou seu código ser executado e exige reparo.

Para ajudar contra esse trabalho desnecessário (teste + correção + teste), que pode se repetir inúmeras vezes, você pode usar o autocmd para alertá-lo, utilizando ferramentas externas. Por exemplo:

autocmd BufWritePost *.pl !perl -c %
autocmd BufWritePost *.php !php -l %
autocmd BufWritePost *.java !javac -Xlint %

Use a criativdade

Utilize sua criatividade e seja mais produtivo na SUA rotina. Deixe as coisas serem automatizadas. Para mais eventos do autocmd, :help autocmd. Tem uma lista bem extensa. Leia a documentação e seja feliz =). Crítias, sugestões e CASES são bem vindos nos comentários =)

Essa semana eu escutei algo do tipo: ‘No notepad++, CTRL+SHIFT+UP move a linha atual pra cima, o GVim podia ter um comando que fizesse isso.’ (Citada pelo reclamão-mor, Luan). Indignados, eu e Emanuel (sim, ele me ajudou) gastamos mais ou menos 1 hora de trabalho ajeitando umas HOTKEYS para ninguém reclamar. (Chefe, eu sei que tu lê o Blog, mas dá um desconto, vai?). Eis o que surgiu:

Identação de Código

Garanto que não foram uma ou duas pessoas que já tentaram identar uma seleção com TAB no GVim (identar no modo visual). Pois é, ‘não é como o notepad++, o notepad++ deixa e blá blá blá’. Esta parte foi toda do Emanuel (créditos):

1
2
3
4
5

vnoremap < <gv
vnoremap > >gv
vmap  <TAB> >
vmap  <S-TAB> <
imap  <S-TAB> <ESC><<i

Assim, colocando o script acima no .gvimrc, e testemos. Selecionando o texto, ele deve ajeitar a identação usando TAB (para direita) ou SHIFT+TAB (para esquerda) ou usando os famosos e não menos práticos < e >. Detalhe: Ele não desfaz a seleção. Então, pode se dar 4 tabs seguidos sem precisar re-selecionar o texto (como funcionaria se não tivesse o gv).

Movimentação de Texto

Bom, tudo começou no mover linha para cima ou para baixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

"" Move bloco de texto selecionado pra cima
function! MoveUp()
    let end=line("'>")
    let start=line("'<")
    if (start > 1)
        let dif=end - start
        exec "'<,'>d"
        exec "normal kP"
        exec "normal " . (start-1) . "GV" . (end-1) . "G" 
    else
        exec "normal " . (start) . "GV" . (end) . "G" 
    endif
endfunction 
" Move bloco de texto selecionado para baixo
function! MoveDown()
    let end=line("'>")
    let start=line("'<")
    if (end < line("$")-1)
        let dif=end - start
        exec "'<,'>d"
        exec "normal p" exec "normal " . (start+1) . "GV" . (end+1) . "G"
    else
        exec "normal " . (start) . "GV" . (end) . "G"
    endif
endfunction
" Duplica um bloco de texto
function! Duplicate()
    let end=line("'>")
    let start=line("'<")
    let dif=end - start exec "'<,'>y"
    exec "normal " . end . "G" exec "normal $p"
    exec "normal " . (start+dif+1) . "GV" . (end+dif+1) . "G"
endfunction
" Move bloco de texto selecionado pra cima 
vnoremap <C-S-UP> :<C-U>call MoveUp()<CR>
" Move bloco de texto selecionado pra baixo
vnoremap <C-S-DOWN> :<C-U>call MoveDown()<CR>
" Duplica o bloco de texto selecionado
vnoremap <C-D> :<C-U>call Duplicate()<CR>

Pois bem, virou um monstro. O script acima mapeia 3 funcionalidades de alguns editores de textos. Ao selecionar um bloco de texto, vamos supor que sejam 10 linhas, CTRL+SHIFT+CIMA te permitem que todo o código seja movido 1 linha acima, o inverso com CTRL+SHIFT+DOWN. O CTRL+D duplicaria as 10 linhas selecionadas. Mas nos 3, o texto selecionado continua selecionado.

E você?

Bom, que funcionalidade de outros editores de texto você sente falta no GVim? Só não me venha com CTRL+S, CTRL+C e CTRL+V!!! Use o notepad++ neste caso ^_____^.

Hoje vou falar sobre dicas (algumas bem simples, mas que fazem diferença) para aumentar a produtividade no GVim/Vim. Algumas delas são plugins, outras vão direto para o ~/.gvimrc!

1. Color Picker
2. Saindo sem estresse
3. Colocando Headers nos arquivos
4. Abrindo arquivos escritos no arquivo
5. Trabalhando com buffers
6. Aprimorando a busca
7. Mudando a fonte
8. Documentando o código
9. Autocomplete de código
10. Rodando comandos do Shell
11. Solução para arquivos chatos de backup
12. Removendo Linhas em Branco
13. Compilando arquivos e analizando erros
14. Mostrando a identação
15. Autorrecarregando nosso .gvimrc

1. Color Picker

Quem trabalha com web, geralmente precisa rapidamente selecionar uma cor em hexadecimal. Geralmente recorremos à sites para isso. Existe um plugin que resolve nossos problemas, você pode baixar ele aqui: http://www.vim.org/scripts/script.php?script_id=927

Para instalar é muito fácil. Baixe o arquivo colorsel.vim do site mencionado acima, jogue para dentro do diretórios de plugins, no meu caso /usr/share/vim/vim71/plugins. Ao reiniciar o gvim, basta digitar

:colorSel

Ele deve aparecer algo como:



Notem, que caso o vim seja aberto pelo terminar, ele dispara um erro, dizendo que o plugin instalado é para uso com interface gráfica. Para resolver isso, na linha 24 do colorsel.vim, que começa com ’stderr’…

Apenas apague esta linha e o erro não é mais mostrado para você!

2. Saindo sem estresse

Muitos devem ficar brabos ao tentar sair do vim e digitar o Q maiúsculo

:Q

Para isso, vamos por no nosso ~/.gvimrc

cab W w
cab Q q
cab Wq wq
cab wQ wq
cab WQ wq

Isso vai fazer com que ao digitar algum comando da segunda coluna, ele deve interpretar como o da terceira, logo se for digitado :Q, ele vai entender :q. Isso nos livras de muitas dores de cabeça!

3. Colocando Headers nos arquivos

Muita gente gosta de identificar o arquivo que está escrevendo ou até mesmo ao documentar arquivos. Às vezes precisa por uma licensa, o autor do arquivo, a hora em que foi escrito. Algumas IDE’s oferecem isso normalmente, o GVim, apesar de não ser uma IDE, também oferece algo parecido. Basta acrescentar estas linhas no .gvimrc, mapeando a tecla F8 (você pode modificar à sua preferência).

map <F8> O/**<CR>
\* Descrição do arquivo<CR>
\* @author Gustavo Dutra <mechamo@gustavodutra.com><cr>
\* @created <esc>:r!date '+\%d/\%m/\%y'<cr>kJA<cr>
\*/

Ao abrir um novo arquivo, basta pressionar F8, ele acrescentará nosso header (que você pode modificar para o que você desejar!).

4. Abrindo arquivos escritos no arquivo

Algumas linguagens não usam ‘import’, porém incluem arquivos dentro de arquivos, o que salva muito a vida do programador. Mas supondo que estamos editando o arquivo X, que inclui o arquivo Y, e precisamos, por alguma eventualidade, editar algo no arquivo Y. Precisamos abrir o arquivo passando todo o caminho até ele. Para isso, facilitar isso, façamos um atalho:

nmap gf :new %:p:h/<cfile><CR>

Basta posicionar o cursor sobre o nome do arquivo, e digitar ‘gf’. Nomeei gf para significar Go to File. Você pode colocar o atalho que desejar! Basta mudar o gf para o que quiseres.

5. Trabalhando com buffers

Eu particularmente não gosto de um monte de instâncias do GVim aberta ao mesmo tempo, muito menos gosto de tabs. Eu gosto mesmo é de buffers. Para isso criei alguns atalhos para navegar entre eles

map <A-1> :b1<cr>
map <A-2> :b2<cr>
map <A-3> :b3<cr>
map <A-4> :b4<cr>
map <A-5> :b5<cr>
map <A-6> :b6<cr>
map <A-7> :b7<cr>
map <A-8> :b8<cr>
map <A-9> :b9<cr>
map <A-0> :b10<cr>
map <S-F1> :b11<cr>
map <S-F2> :b12<cr>
map <S-F3> :b13<cr>
map <S-F4> :b14<cr>
map <S-F5> :b15<cr>
map <S-F6> :b16<cr>
map <S-F7> :b17<cr>
map <S-F8> :b18<cr>
map <S-F9> :b19<cr>
map <S-F10> :b20<cr>
map <S-F11> :b21<cr>
map <S-F12> :b22<cr>
map <C-Q> :bwipeout<cr>
map <F6> :buffers<cr>

Para quem não sabe, para iniciar um buffer, utilizamos :e. Logo, para abrir nosso .gvimrc num buffer diferente, digitamos

:e ~/.gvimrc

À cada buffer aberto, o GVim da um número sequencial começando em 1. Nos mapa descrito ali em cima, ALT+1 até ALT+0 navegam nos 10 primeiros buffers. SHIFT+F1 até SHIFT+F12, navegam do buffer 11 até o 22. CTRL+Q, fecha o buffer (remove da lista) e F6 lista todos os buffers disponíveis com os nomes dos arquivos e seus respectivos números.

6. Aprimorando a busca

Para buscar por algum trecho de texto no gvim, é utilizado a barra (/).

/texto da busca

Adicionando no nosso .gvimrc o seguinte:

set incsearch
set hlsearch

É possível fazer com que à medida em que é digitado, o GVim saliente o texto (highlight), caso encontrado. Para navegar entre os resultados, utilizamos n (próxima ocorrência) ou N (ocorrência anterior). Mas, uma das coisas interessantes é sobreescrever estes comandos desta forma:

nmap n nzz
nmap N Nzz

zz é responsável por por a linha atual no centro da tela. Logo, isto permite que ao encontrar uma próxima ocorrência do texto, o texto ficará no meio da tela.

7. Mudando a fonte

No Vim a fonte utilizada é a do Terminal no qual ele foi executado. No GVim, por ser gráfico, possibilita com que seja modificada a fonte atual.

set guifont=Fonte\ Desejada\ 8

Lembre-se de escapar os espaços. Logo depois do nome da fonte, é colocado o tamanho dela. Se por alguma acaso você ficar em dúvida em qual fonte utilizar, você pode digitar o seguinte no GVim

:set guifont=*

Com isso, ele abrirá o seletor de fontes do seu OS. Basta selecionar o dar OK. Quando feito e fonte for modificada, você pode digitar somente

:set guifont

Ele retornará a sintaxe correta de como usar a fonte e o tamnho da mesma. Então, basta copiar e colar no .gvimrc!

8. Documentando o código

Todos sabem da importância que é documentar os códigos, assim como sabem a chatisse que é! Para nos ajudar com isso, seguem alguns plugins:

• PHPdoc
• Perl
  
• Javadoc

9. Autocomplete de código

Maneira simples de autocompletar o código é usando CTRL+X + CTRL+O, mas isso é difícil de assimilar, logo podemos criar uma funçãozinha para ajudar:

function! CleverTab()
if strpart( getline('.'), 0, col('.')-1 ) =~ '^\s*$'
return "\<Tab>"
else
return "\<C-X>\<C-O>"
endfunction
inoremap <Tab> <C-R>=CleverTab()<CR>
set completeopt=menu,preview

Ao digitar ‘tex<TAB>’ ele vai tentar utilizar o omnicompletition para completar a palavra, que pode ser uma função/variável criada dentro do arquivo ou nativa da linguagem.

10. Rodando comandos do Shell

Quantas vezes você já precisou ordenar algo em ordem alfabética? copiar um arquivo inteiro para o arquivo que está digitando? Para quem domina o shell, isso vai ser muito útil. No nosso .gvimrc vamos por o seguinte:

set shell=/bin/bash

Feito isso, vamos fazer alguns testes. Abra algum no gvim e cole o seguinte:

Banana
Maçã
Amora
Pêra
Batata
Melancia

Agora, vamos à mágica:

Digite o seguinte:

:%!sort

Tcharam! O % diz que é o arquivo inteiro; o ! exige que seja executado no shell. sort é comando do shell. O GVim automaticamente pega o conteúdo do arquivo, executa o comando no shell e substitui pelo resultado! Então, para copiar um arquivo no fim do nosso aberto, podemos utilizar o ‘cat’

:$!cat /meu/arquivo

Observem que eu utilizei $, ele vai começar a colar na última linha do arquivo. É legal, então, sempre ter certeza que esta linha está em branco, para que não haja perda de dados. Você também pode por numa linha específica.

:6!cat /meu/arquivo

Ele vai substituir o texto da linha 6 com o que contiver no arquivo, conservando da linha 1 até a linha 5, e da linha 7 até o fim do arquivo.

11. Solução para arquivos chatos de backup

Sabe aqueles arquivos de backup do vim? Que ficam .ext~ ? Você edita algo no projeto e o vim polui o projeto inteiro, quando você vê, já perdeu as contas de quantos arquivos novos foram criados. Ou até mesmo já commitou aqueles arquivos de swap (.swp) do vim sem querer.

Para resolver isso, podemos mudar o diretório onde eles são criados ou até mesmo desabilitá-los, basta acrescentar no .gvimrc:

set backup
set backupdir=/tmp
set dir=/tmp

Se você deseja desabilitar, utilize ’set nobackup’, caso contrário os arquivos de backup irão para o /tmp, e não mais para o diretório do seu projeto! O mesmo acontece com os .swp, especificado pelo ’set dir’.

12. Removendo Linhas em Branco

Para remover todas as linhas em branco do arquivo (vazias ou que contenham somente espaços) podemos utilizar:

:g/^\s*$/d

13. Compilando arquivos e analizando erros

Para compilar um arquivo, basta especificarmos o compilador. Vamos usar o exemplo do javac.

:compiler javac

Para compilar arquivos em java, abra ele no gvim, execute o comando acima e digite:

:make %

Ele irá compilar com o javac o arquivo atual e mostrar os erros em tempo de compilação. Por mais louco que pareça, há também como fazer isso com o php, por exemplo. Mas ao invés de compilar o código, ele checa a sintaxe.

:compiler php
:make %

Ele irá executar `php -l arquivo.php`, retornando os erros de sintaxes! É bom para testes antes de rodá-lo, evitando erros bobos como o esquecimento de 1 ponto e vírgula, um ponto ao concatenar, etc.

Ah! Caso você desejar, pode modificar o comando do make! Se quiser adicionar mais parâmetros, por exemplo, jogar todos os erros que já teve para um determinado lugar (é legal saber o quanto de erro produzimos, para que, ao programar, tentamos cometer cada vez menos e nunca os mesmos (né? ^__^)):

au FileType php set makeprg=php\ -l\ %\ >>\ /tmp/errors.log

assim, ele modificará somente se o arquivo for interpretado como php. Basta dar um :make que ele joga para o arquivo. No final do dia podemos avaliar nossos erros e ver (olha, preciso melhor em tal aspecto).

14. Mostrando a identação

Quem nunca se perguntou (o que este } está fechando? é este ou aquele if?). Pois é, bater o olho e de cara descobrir é complicado, ainda mais quando o início (if () {) não está na mesma página, digo, não é visível, é preciso rolar pra vê-lo.

set list listchars=tab:»·,trail:·,eol:$

Assim, primeiro habilitamos a exibição deles. Depois substituimos com os valores. Isso fará com que o nossa identação fique visível, e possamos ver (hmm… esse if tem 3 tabs antes, então vai fechar na } que tiver 3 tabs antes também!). O arquivo ficará mais ou menos assim:

»····»····»····if (condicao) {$
»····»····»····»····//codigo$
»····»····»····}$

Assim, o código fica claro. Você se acha no tab e consegue enxergar se há espaços desnecessários no final da linha, pois $ representa o nosso amigo \n.

15. Autorrecarregando nosso .gvimrc

Bom, apresento para vocês o autocmd bufwritepost. Ele é executado depois do arquivo ser salvo. Então ao salvar o arquivo ele executa o(s) comando(s) que seguem ali. Acrescentamos, então, ao nosso gvimrc os seguintes comandos:

autocmd! bufwritepost .gvimrc source %
autocmd! bufwritepost .vimrc source %

Assim, ao salvar .gvimrc ou .vimrc, ele recarregará as configurações automaticamente! Voltando ali na dica 13, podemos fazer isso:

autocmd! bufwritepost *.php make %

Rá! Agora, ao salvar um arquivo .php, ele executa no :make % que manda para /tmp/errors.log! Não é feitiçaria, é tecnologia.

Espero que alguma coisa seja útil para vocês! Fui!