Rodrigo Rosenfeld Rosas

Produtividade com Vim como IDE

10/09/2010 20:00 (Atualizado em 20/03/2012 21:30)

Por muito tempo insisti em tentar utilizar IDEs como Netbeans, RubyMine, Eclipse e IntelliJ IDEA. Todas têm o mesmo problema: consumem muito recurso, são lentas e implementadas em Java (leia-se: você nunca sabe quando ocorrerá a próxima coleta de lixo e normalmente isto acontecerá no momento de maior inspiração)...

No último sábado minha irritação foi tanta que resolvi investir praticamente 3 dias completos do meu feriado estudando vários plugins para o Vim na tentativa de torná-lo um ambiente produtivo para desenvolvimento. O resultado foi satisfatório e resolvi escrever sobre como obter produtividade com Vim, resumindo os recursos interessantes que aprendi nesses 3 dias.

Caso você já seja usuário do Vim, recomendo que faça um backup dos seus arquivos de configuração caso deseje testar a configuração que descrevo a seguir.

O que esperar?

Os recursos que utilizava nos IDEs e que consegui utilizar no Vim foram:

  • Velocidade da luz!
  • Auto-completar (com a configuração atual, funciona bem com HTML, CSS, XML, deixando a desejar para os outros IDEs para a linguagem Java)
  • Snippets (geração de códigos a partir de trechos pré-definidos)
  • Edição em abas
  • Gravação de sessão
  • Auto-completar de palavras contidas no documento
  • Documentação do RDoc (Ruby)
  • Navegador de arquivos
  • Localizador rápido de arquivos
  • Exibir número de linhas e "ir para a linha n";
  • Alternar para a definição da classe/método/tag sob o cursor
  • Correção ortográfica (apanhei para colocar para funcionar no Netbeans...)

Além desses recurso, conheci outros recursos que nunca cheguei a utilizar nos outros IDEs que utilizei. Seguem os detalhes.

Instalação

As instruções que descrevo foram as que utilizei com a distribuição do Linux que uso (Debian unstable) mas também deve funcionar com o Ubuntu e a maioria das distribuições Linux. No Windows, aparentemente a mudança é que o diretório de configuração do Vim chama-se "vimfiles" em vez de ".vim". Caso tenha alguma dúvida sobre o processo de instalação, é só postar um comentário.

Instale os pacotes necessários (como root, ou use "sudo" no Ubuntu):

1
2
3
4
5
6
apt-get install exuberant-ctags vim-gtk git
cd
git clone --recursive git://github.com/rosenfeld/vimfiles.git .vim
ln -s .vim/vimrc .vimrc
mkdir .vim/spell
wget -O .vim/spell/pt.utf-8.spl http://github.com/rosenfeld/git-spell-pt-br/raw/master/pt.utf-8.spl

Algumas notas (para os curiosos ou quem tiver problema em executar os passos acima):

  • Para os que utilizam o git como controle de versão, vale a pena incluir os pacotes gitk e git-gui (criei atalhos para esses programas)
  • Usuários do Gnome podem preferir instalar o vim-gnome em vez de vim-gtk. Alguns atalhos não irão funcionar em um vim não gráfico devido a alguns atalhos que serão capturados pelo console gráfico como Konsole ou gnome-terminal (Ctrl+S, por exemplo).
  • O download do dicionário pt-BR (wget) é opcional para quem pretende utilizar o corretor ortográfico
  • O pacote exuberant-ctags é o responsável pela navegação de classes/métodos/tags.

Após esses procedimentos, basta executar o Vim (sugiro utilizar o comando 'gvim' para evitar problemas com atalhos).

Recursos

O Vim tem muito mais recurso do que o que apresentarei. Para os que tem tempo disponível, recomendo a leitura de outros materiais a respeito.

Básico

Edição, gravação, navegação e saída do editor

Diferentemente de outros editores, o vim possui diferentes modos. Ele é iniciado no modo normal, aguardando uma sequência de caracteres que representem uma ação. Pressionando 'i' ou 'Insert', o vim entra no modo de inserção, a partir do qual é possível digitar qualquer coisa. Para sair do modo de inserção, basta pressionar 'Escape'.

Boa parte dos comandos são executados a partir de uma linha de comando que surge ao pressionar a tecla ':'. Alguns comandos corriqueiros são:

  • ':q': Sair sem salvar. Se houver alguma alteração, o Vim irá te avisar em vez de sair.
  • ':w': Gravar o arquivo atual.
  • 'Ctrl+x, s': Gravar o arquivo atual, no modo de inserção.
  • ':x' ou ':wq' ou 'ZZ': Sair gravando as alterações.
  • ':q!': Sair ignorando as alterações.
  • ':qa': Fechar todos os buffers (para simplificação, leia-se arquivos em edição) e sair. Na verdade, os comandos acima não irão necessariamente sair se houver múltiplos buffers abertos, mas apenas encerrarão o buffer atual.
  • ':e caminho/para/arquivo': Abre o arquivo para edição na área atual (é possível utilizar TAB para autocompletar o caminho)
  • ',f caminho/relativo/para/arquivo': ',f' expande o caminho do arquivo atualmente aberto
  • ':tabe' e ',t': a mesma coisa que os comandos anteriores, porém abre em uma nova aba
  • 'Ctrl+PageUp/PageDown': navegação entre abas (pode não funcionar em vim modo terminal)
  • ':tabnew': Abre uma nova aba para edição
  • ':e!': Descarta as alterações atuais do arquivo desde a última gravação
  • 'w': Vai para o início da próxima palavra onde se encontra o cursor
  • 'e': Vai para o fim da palavra onde se encontra o cursor ou para o fim da próxima palavra se já estiver no fim da palavra atual
  • 'b': Vai para o início da palavra onde se encontra o cursor ou para a palavra anterior se o cursor já estiver no início
  • ',w' e ',b': Faz a mesma coisa, porém considerando o trecho "CamelCase" como duas palavras ("Camel" e "Case")
  • '0': posiciona o cursor no início da linha
  • '^': posiciona o cursor no início da linha, no primeiro caractere que não seja um espaço em branco
  • '$': posiciona o cursor no final da linha
  • '%': quando o cursor está em cima de um parênteses, chave ou colchete, navega para o par correspondente
  • 'gg': vai para o início do documento
  • 'G': vai para o fim do documento
  • '45G': vai para a linha 45
  • '~': altera a caixa da letra sob o cursor (maiúsculas/minúsculas)
  • 'u': desfaz última alteração
  • '.': repete último comando de alteração
  • 'J': junta linhas consecutivas
  • Ctrl+e: rola uma linha abaixo sem mover o cursor
  • Ctrl+y: rola uma linha acima sem mover o cursor

No modo de edição, é possível executar um comando digitando Ctrl+O e o atalho do comando no modo normal. Há várias formas de entrar no modo de edição, quando se está no modo normal:

  • i: não altera a posição atual do cursor
  • I: posiciona o cursor no início da linha
  • o: cria uma nova linha abaixo da linha em que se encontra o cursor e posiciona-o no início desta linha
  • O: cria uma nova linha acima da linha em que se encontra o cursor e posiciona-o no início desta linha
  • a: posiciona o cursor um caractere a frente da posição corrente
  • A: posiciona o cursor no fim da linha em que ele se encontra

Para excluir linhas, palavras e blocos, gerenciar cercas (surrounds) e inserir comentários:

  • dd: exclui a linha atual e a transfere para a área de transferência (recorta a linha).
  • D: exclui até o final da linha
  • x ou Delete: exclui um caractere à frente
  • Backspace: exclui um caractere para trás
  • dw: exclui até o final da palavra corrente
  • diw: exclui toda a palavra corrente
  • db: exclui até o início da palavra ou a palavra anterior, se estiver no início de uma palavra
  • ds', ds", ds{, ds[, ds(: exclui "surrounds". Ou seja, remove as aspas/parênteses/etc em torno de um texto onde o cursor se encontra
  • dst: exclui a tag que engloba o texto onde o cursor se encontra
  • di', di", di{, di[, di(: exclui texto dentro do "surround" especificado. Ou seja, remove texto entre aspas/parênteses/etc
  • dit: exclui todo o texto contido na tag
  • dt", dt'... e dT", dT'...: exclui até o caracter informado (", ', ...) para frente (t) ou para trás (T). Para incluir o caracter na exclusão deve-se utilizar df e dF em vez de dt e dT (delete unTil) respectivamente.
  • cs: funciona como ds, porém substituindo o "surround". Por exemplo: aplicando ci"' em "texto", o resultado será 'texto'. Aplicando ci"t<div>, o resultado será <div>texto</div>...
  • yss*: aplica aspas/tags/etc em torno da linha. Ex.: yss' aplica aspas simples em torno da linha. Para aplicar uma tag: yss<div>
  • s*: aplica aspas/tags/etc em torno da região selecionada no modo visual (selecionado ao clicar e arrastar o mouse ou pressionando a tecla 'v' e selecionando com as setas ou comandos de movimento)
  • ys<movimento>: aplica aspas/tags/etc em torno da região descrita por <movimento>. Ex.: Com o cursor sobre "palavra" ysiw<span> resulta em <span>palavra</span>
  • C, cw, ciw, cb, ci*, etc: Funciona como a exclusão, e adicionalmente posiciona o cursor no modo de inserção
  • gv: Refaz última seleção do modo visual
  • \c<espaço>: comenta/descomenta a linha corrente
  • ggdG: exclui o documento inteiro

Copiar e colar

No modo normal (não utilizar o ':'):

  • yy: copia a linha onde se encontra o cursor para a área de transferência
  • p: cola o conteúdo da área de transferência
  • ddp: move a linha para baixo
  • yyp: duplica a linha
  • ':%y': copia o documento inteiro (para ser utilizado dentro do vim)
  • ':%y+': copia o documento inteiro para a área de transferência comum do sistema (colar com Ctrl+V)
  • ':%y*': o registro * é a área de transferência utilizada em ambientes UNIX (Linux, MacOSX, etc) para colar com o botão do meio do mouse
  • "+yy (ou Ctrl+X, c): copia a linha para a área de transferência comum (colar com Ctrl+V)
  • "*yy: copia a linha para a área de transferência de seleção do mouse (colar com botão do meio do mouse)
  • Ctrl+R,+ (ou Ctrl+X, v) e Ctrl+R * (ou Ctrl+X, b): cola das áreas de transferência comum e de seleção respectivamente no modo de inserção
  • Ctrl+C: No modo visual, copia o conteúdo selecionado

No modo visual, para copiar basta pressionar 'y' após selecionar o trecho, ou '"+y' / '"*y' para copiar para os registradores equivalentes às área de transferências comum e do mouse respectivamente.

Janelas e abas

Já comentei sobre alguns comandos básicos relacionados a abas. Seguem outros mais avançados:

  • Ctrl+w, s: (Pressiona-se Ctrl+w, e em seguida pressione 's') - divide a área de edição horizontalmente
  • Ctrl+w, v: (Pressiona-se Ctrl+w, e em seguida pressione 'v') - divide a área de edição verticalmente
  • Ctrl+w, c: Fecha a área de edição atual (com foco) ou a aba se for a única área de edição da aba.
  • Ctrl+w, o: Mantém apenas a área de edição atual, fechando as outras
  • Ctrl+w, w: Alterna para a próxima área de edição
  • Ctrl+w, seta: Alterna para a área de edição apontada pela seta
  • Ctrl+w, T: Repare no T maiúsculo. Move a área de edição atual para uma nova aba

Abertura rápida de arquivos

O atalho '<c-x><c-f>' (Ctrl+X Ctrl+F) ativa a busca rápida de arquivos para edição.

Dentro de um diretório do projeto em que você está trabalhando, o vim exibirá uma lista de arquivos que vai sendo filtrada na medida em que se digita partes do arquivo. Por exemplo, ao digitar 'a/c/uc', 'app/controllers/usuario_controller.rb' apareceria como uma possibilidade.

Selecionando com Enter, o arquivo será aberto na área atual. Pressionando Ctrl+t, o arquivo será aberto em uma nova aba.

Snippets (trechos de código)

Snippets são trechos de códigos expandidos ao se pressionar TAB. Por exemplo, div<TAB> está configurado para expandir para <div id="?">?</div>.

Para conhecer os snippets ou criar novos, verifique os diretórios snippets em ~/.vim/bundle/snipmate/snippets e ~/.vim/bundle/rosenfeld/snippets.

Os snippets são lidos automaticamente de bundle/*/snippets e ~/.vim/snippets.

Atalhos para se trabalhar com HTML, XML, ERB, ASP, JSP, PHP, GSP, etc

Atalhos para se trabalhar com HTML/XML também se aplicam a arquivos PHP, ASP, ERB, JSP, etc, desde que o tipo de arquivo seja algo do tipo "html.erb". Isto pode ser obtido com o comando :set ft=html.erb, para arquivos ERB. Para configurar estes tipos automaticamente de acordo com a extensão do arquivo, veja alguns exemplos em ~/.vim/filetype.vim.

Alguns atalhos para se trabalhar com HTML já foram citados, seguem alguns outros, para o modo de inserção:

  • Ctrl+x, /: Fecha a última tag aberta.
  • Ctrl+x, espaço: transforma a palavra em tag. Ex.: div<C-x><espaço> resulta em <div>|</div>, onde '|' denota a posição final do cursor
  • Ctrl+x, enter: equivalente ao comando anterior porém com uma quebra de linha entre o início e o fim da tag
  • Ctrl+x, ': inicia um comentário, posicionando o cursor dentro
  • Ctrl+x, ": comenta a linha
  • Ctrl+x, !: abre um menu com uma escolha de um DOCTYPE para inserir
  • Ctrl+x, @: insere tag stylesheet
  • Ctrl+x, #: insere tag meta com charset=utf8
  • Ctrl+x, $: insere tag script para linguagem javascript

Para arquivos de template, como ERB, JSP, PHP, etc:

  • Ctrl+x, =: <%= | %> ou equivalente para linguagem
  • Ctrl+x, -: <% | %> ou equivalente para linguagem

Para ERB (Ruby), criei os seguintes snippets equivalentes:

  • re: <%= | %>
  • rc: <% | %>

Para escolher uma cor ao editar um arquivo CSS, com o kcolorchooser instalado (ver ~/.vim/initializers/kcolorchooser-mapping.vim para alterar programa de escolha de cor) pressione F12.

Correção ortográfica

Comandos:

  • sppt: habilita correção ortográfica em pt-BR
  • spen: habilita correção ortográfica em inglês
  • ':set nospell': desabilita correção ortográfica
  • z= ou botão direito do mouse sobre a palavra: faz surgir um menu para selecionar uma palavra da lista como a correção
  • Ctrl+x, s: mesma coisa no modo de inserção
  • ]s: próxima palavra com escrita errada
  • [s: palavra anterior com escrita errada
  • zg: marca a palavra como correta, incluindo-a em dicionário local (configurado pela variável spellfile - ':set spellfile=~/.vim/spell/personalizado')
  • zw: marca a palavra como incorreta
  • zG e zW: marca as palavras em uma lista interna que é perdida ao fechar o vim
  • zug, zuw, zuG e zuW: desfaz comando equivalente
  • ':spellr': substitui todas as palavras corrigidas com a mesma grafia errada da última corrigida com 'z='

Tags

Conheço duas formas de se trabalhar com tags no vim:

Plugin taglist

Comandos:

  • F8: Alterna janela com as tags criadas a partir do arquivo corrente ou todas as tags encontradas pelo comando abaixo, se for executado
  • ':TlistAddFilesRecursive . .rb .js': Este comando cria uma lista de tags para os arquivos ruby e javascript do projeto corrente.

Suporte nativo do Vim integrado ao ctags

Deve-se criar um arquivo tags no diretório corrente (digite 'ctags --list-languages' para ver as linguagens suportadas):

1
ctags -R --languages=Ruby,Javascript

Groovy não é suportado por padrão pelo exuberant-ctags, mas adicionar este conteúdo a ~/.ctags parece funcionar. Você pode fazê-lo com este comando (no Linux ou Mac):

1
curl https://raw.github.com/gist/2142910/ctags >> ~/.ctags

A partir daí, para pular para a definição de uma tag onde o cursor se encontra: - Ctrl+] ou Ctrl+<LeftMouse> ou g<LeftMouse>: pula para a definição na janela corrente - Ctrl+T ou Ctrl+<RightMouse> ou g<RightMouse>: Volta para a posição anterior ao pulo - Ctrl+w, ]: divide a janela horizontalmente e pula para a definição - g, Ctrl+] e Ctrl+w, g, ]: Apresentam uma lista de definições antes de pular se houverem múltiplas definições - ':tag NomeTag': Vai para a definição de 'NomeTag' - ':ts NomeTag': Abre uma lista de definições encontradas e lhe dá a opção de escolher uma - Ctrl+: vai para a definição em uma nova aba

Indentação

Comandos:

  • ==: indenta a linha corrente
  • =: no modo visual, indenta o bloco selecionado
  • gg=G: vai para o início do documento (gg) e indenta (=) até o final do documento (G)
  • < e >: indenta bloco (no modo visual) ou linha para a esquerda ou direita. Para continuar o processo de indentação, pressione '.' (repetir comando) e para cancelar uma indentação a mais pressione 'u' (desfazer).

Localizar e substituir

Comandos:

  • F4: substitui textos respondendo a questionários de modo iterativo
  • /padrao_de_pesquisa: Localiza a próxima ocorrência. Ex.: "/funcao" ou "/\d\{2}\/\d\{2}\/\d\{4}" para localizar uma data como "13/06/1981"
  • ?padrao_de_pesquisa: Localiza a ocorrência anterior. Ex.: "?funcao"
  • n: consulta a próxima ocorrência (ou anterior se a última consulta foi realizada com ?)
  • N: consulta a ocorrência anterior (ou próxima se a última consulta foi realizada com ?)
  • ':%s/texto/outro/': Substitui 'texto' por 'outro' em todo o documento (modificador %)
  • ':s/texto/outro/': Substitui 'texto' por 'outro' na linha atual. Obs.: qualquer caractere pode ser utilizado no lugar de '/'
  • ":'<,'>s/texto/outro/": Substitui 'texto' por 'outro' no último trecho selecionado. '< e '> são os marcadores para o início e fim da seleção. Ao pressionar ':' em uma seleção no modo visual, automaticamente esses marcadores são inseridos na linha de comando.
  • &: repete último comando de substituição
  • ':Rgrep palavra .rb': pesquisa por 'palavra' em todos os arquivos Ruby do projeto. O comando ':vimgrep' também pode ser utilizado, caso os comandos externos 'grep' e 'find' não estejam presentes, mas é bem mais lento. Há outras diferenças também, veja a ajuda do comando com ':h vimgrep'. Com vimgrep, é possível, por exemplo, ir para a posição em que a ocorrência foi encontrada (':cc 33' - vai para a ocorrência de número 33, os números são listados com ':cl') e também utilizar expressões como ':vimgrep palavra **/.rb'

Marcadores

Comandos:

  • ma: marcar a posição atual no registro 'a'. Outros registros podem ser utilizados entre 'a' e 'z'
  • 'a: vai para a posição do registro 'a'
  • '' (duas aspas simples): vai para a última posição antes do último salto
  • Ctrl+O, Ctrl+i: vai para as posições anterior e próxima do cursor respectivamente

Listas de alterações

Comandos:

  • ':changes': lista as alterações no documento
  • g;: vai para a alteração anterior
  • g,: vai para a próxima alteração
  • 4g;: vai para a alteração de número 4 (os números são listados por ':changes')

Navegação entre buffers

Comandos:

  • Ctrl+x Ctrl+x: em qualquer modo, abre uma janela para selecionar para qual buffer alternar, na lista dos mais recentes (pressione 'q' para cancelar ou 'Enter' para abrir a opção selecionada)

Navegação de arquivos em árvore

  • Ctrl+n: alterna navegador de arquivos
  • \n: localiza o arquivo que está sendo editado no navegador de arquivos
  • ':e.': substitui a janela atual por um navegador apontando para a raiz do projeto, de onde se poderá escolher um novo arquivo a ser aberto na janela atual.
  • ':Ex': a mesma coisa porém utilizando o caminho do arquivo atualmente sendo editado.

No navegador:

  • Enter: abre o arquivo em uma nova janela, utilizando divisão horizontal, ou na mesma janela se o arquivo da janela corrente não tiver modificações
  • t: abre o arquivo em uma nova aba
  • ?: lista outros atalhos

Comandos externos

Para executar um comando externo:

  • ':! git gui&': executa 'git gui' em background (não funciona no Windows, claro)
  • ':.! ls .txt': substitui a linha corrente pela saída do comando 'ls .txt'

Integração com Git

  • \g: Inicia git gui no projeto atual (use ':lcd ~/caminho/projeto' para alterar a pasta do projeto na janela atual, ou ':cd' para alterar para toda a sessão do vim)
  • \k: Inicia gitk

Veja $VIMHOME/bundle/vcscommand/doc/vcscommand.txt para outros comandos. Por exemplo: - \cd: exibe as diferenças do arquivo corrente em uma nova divisão horizontal - \cr: exibe a última revisão do arquivo em uma nova divisão horizontal

Suponha que você queira saber quais são as diferenças entre suas mudanças não gravadas e o arquivo original: - \cr: exibe o arquivo original em uma nova divisão horizontal. Se você quiser que a divisão seja vertical, mova a janela para a esquerda (Ctrl+w, H) ou direita (Ctrl+w, L). H e L devem ser maiúsculas. - execute ':diffthis' em ambas as janelas: veja próximo tópico sobre as diferenças.

Você também pode dar uma olhada em $VIMHOME/bundle/fugitive/doc/fugitive.txt para mais atalhos para trabalhar com Git,como: - ':Gstatus': exibe a saída de 'git status' e permite-lhe adicionar ou remover o arquivo sob o cursor do próximo commit pressionando '-', ou ver as diferenças em uma janela vertical (pressionando 'D') ou em uma janela horizontal (pressionando 'dh'). - ':Gcommit', ':Gblame' and ':Gmove' são outros exemplos auto-explicativos. Dê uma olhada na documentação do fugitive para mais detalhes.

Visualizando as diferenças entre arquivos

Abra ao menos duas janelas com os textos que se quer comparar e digite ':diffthis' em ambas. Para desabilitar o recurso use o comando ':diffoff'. Utilize 'dp' em uma diferença destacada para por a versão corrente da diferença na outra janela ou 'do' para obter a diferença da outra janela. Use '[c' e ']c' para ir para a mudança anterior e próxima respectivamente. Veja ':h diff' para mais detalhes.

Consultando a ajuda do Vim

  • ':h' ou F1: abre ajuda principal do Vim
  • ':h comando': abre ajuda sobre o comando
  • Ctrl+]: abre um link referenciado na ajuda
  • Ctrl+T: volta para a posição anterior ao seguimento do link

Específico sobre Ruby (Rspec, RDoc, etc)

Comandos:

  • Ctrl+s, r: consulta o RDoc para a palavra sob o cursor
  • Ctrl+s, s: executa rspec na especificação aberta no buffer corrente
  • Ctrl+s, x: alterna entre especificação e modelo

Em projetos Rails (use tab para auto-completar a maioria dos comandos):

  • ':Rview usuarios/list.erb': abre a visualização
  • ':Rcontroller usuarios' e ':Rmodel usuario' são comandos similares
  • 'gf': quando pressionado em uma linha como 'render "usuarios/list"' abrirá 'usuarios/list.erb'. Quando pressionado sobre a palavra 'ApplicationController', o arquivo 'application_controller.rb' será aberto.
  • ':R': Alterna entre a ação do controlador e sua visualização correspondente quando se segue a convenção.

Depuração:

Você precisa instalar a gem 'ruby-debug-ide19' or 'ruby-debug-ide' para isto funcionar:

  • ':Rdebugger bin/ruby_script' ou 'Rdebugger script/rails server' para uma aplicação Rails
  • \db: alterna ponto de parada
  • \dn: executa a instrução corrente (step)
  • \ds: desce um nível na instrução (step into)
  • \df: sobe um nível (step out)
  • \dc: continua
  • \dv: abre a janela de variáveis
  • \dm: abre a janela de pontos de parada
  • \dt: abre a janela de pilhas de chamadas
  • \dd: remove todos os breakpoints
  • ':RdbEval User.count' avalia a expressão 'User.count'
  • ':RdbCommand where' envia o comando 'where' para o rdebug
  • ':RdbCond user.admin?' adiciona a condição 'user.admin?' para o ponto de parada
  • ':RdbCatch Errno::ENOENT' cria um breakpoint na linha em que a exceção passada (arquivo não encontrado) foi gerada, permitindo investigar a pilha de chamadas, variáveis, etc
  • ':RdbStop' pára o depurador

Refatoração

Embora Vim não lhe permita refatorar uma variável diretamente (ao menos, eu não sei como fazê-lo no Vim), ele pode ajudá-lo a refatorar seu código de diversos modos, usando comandos de substituição até extração de variáveis como no exemplo abaixo:

Suponha que você queira refatorar o código abaixo como segue:

1
2
3
  if User.find(params[:id]) and current_user.admin?
  # ...
  end

para:

1
2
3
  @user = User.find(params[:id])
  raise NotFoundException unless @user and current_user.admin?
  # ...

Para extrair a parte "User.find(params[:id])" para a variável "@user", você pode posicionar o cursor sobre o "U" e executar os comandos "c% @user" (alterar o conteúdo "User.find(params[:id])" com "@user"), "Ctrl+o, O" (executar o comando 'O' no modo de inserção [Ctrl+o] - criando uma linha acima da atual), digitando "@user = " e 'Ctrl+R "' (colando o conteúdo recortado anteriormente).

Com todas essas explicações, pode ter parecido complicado, mas veja como podemos alcançar o objetivo com apenas algumas combinações de teclas: c% @user <Ctrl+O>O @user = <Ctrl+R>".

Aprender a utilizar o Vim em sua expressão máxima permitir-lhe-á realizar várias tarefas mais rapidamente que qualquer outro editor ou IDE de um modo geral. Por exemplo, RubyMine permitir-lhe-á fazer o mesmo com provavelmente menos combinações para este caso específico, mas para casos especiais o Vim ainda lhe será bastante útil e não muito menos produtivo que o RubyMine para o caso comum. Na verdade, recortar "User.find(params[:id])" é muito mais rápido no Vim ("c%") do que selecionar o texto inteiro no RubyMine ou qualquer outra IDE. O mesmo se aplica para se alterar o conteúdo dentro de aspas, parênteses, tags XML, etc entre outros recursos.

O que não funciona?

Infelizmente, nem tudo são flores. Alguns recursos interessantes dos IDEs tradicionais ainda não consegui colocar para funcionar no Vim. Alguns exemplos incluem:

  • Com exceção de Ruby, não há suporte para depuração integrada para a maioria das linguagens
  • Navegação entre tabs recentes utilizando Ctrl+Tab do modo como costuma acontecer na maioria dos IDEs
  • Integração transparente com a área de transferência do sistema, a menos que utilizado no modo fácil (Easy) com o comando 'evim' ou 'vim -y'
  • Para desenvolvimento em Java, os IDEs tradicionais como Netbeans, Eclipse e IntelliJ IDEA são mais competentes com auto-completação e outros recursos da linguagem (eu não testei plugins como Jde e cppcomplete)
  • Pular para uma tag em uma aba existente ou abrir em uma nova (atualmente só consegui fazer abrir em uma nova). Aparentemente é melhor se acostumar a trabalhar com buffers em vez de abas no Vim...
  • Integração com arquitetura de internacionalização do Rails com backend padrão. O RubyMine tem uma integração excelente. Para o Netbeans, eu recomendo o plugin de um amigo.

Mais por vir

Ainda há diversos outros comandos úteis como os de recolher/expandir (folding) e outros recursos interessantes que comentarei assim que tiver mais tempo disponível.

Já falei sobre vários comandos e sugiro que se comece tentando aprender aqueles que vocês mais utilizem, como Snippets, busca e substituição simples, abertura rápida de arquivos, uso de abas e navegação entre buffers. Para os que trabalham com HTML, também recomendo estudar os comandos do plugin "surround", que são especialmente úteis para trabalhar com tags.

Como uma última nota, este artigo foi escrito no Vim no formato Markdown. Muitos dos exemplos envolvem tags e para escapá-las no documento, utilizei o comando ':%HTMLSpecialChars' de um plugin incluído recentemente: htmlspecialchars.

Bom proveito!

comentários gerenciados por Disqus