Esse é um guia talvez completo do plugin vim-rails, do Tim Pope, que, apesar de utilizar de maneira diária, me foge quais seriam todos os recursos apresentados pelo plugin, pelo fato de eu já utilizar como "memória muscular" (vou fazendo sem pensar), então pedi uma ajuda e grande parte desse guia foi gerado pelo Claude, me servindo de guia, e fui complementando de acordo com o que fui lembrando. Aborda bastante das opções disponibilizadas pelo plugin, mas talvez não todas, é possível ser revisado no futuro!

Navegação entre arquivos

Comandos principais de navegação

A navegação é facilitada de acordo com o arquivo atual e sua relação com outros arquivos, que podem ser indicados com as definições de alternativos ou relacionados:

Como funcionam :A e :R

Estando em um determinado arquivo, podemos digitar :A ou :R, o que nos fará alterar para os seguintes arquivos:

Por exemplo, se você estiver no arquivo app/models/user.rb e digitar :A, automaticamente vai ser alterado o arquivo corrente para o test/models/user_test.rb(ou spec/models/user_spec.rb, no caso do Rspec). Se digitar :R, vai para o db/schema.rb, posicionado onde é criada a tabela de usuários. Segue o mesmo príncipio para controllers e views, de acordo com a tabela acima.

Comandos de carregamento de arquivos

Esses comandos permitem que carreguemos os arquivos correspondentes digitando somente o comando e o nome relativo do arquivo. Se o arquivo estiver dentro de um namespace, o path relativo deverá ser informado. Por exemplo, digitando :Emodel user o arquivo app/models/user.rb será carregado. Temos a navegação separada por camadas bem definidas:

Aplicação (App)

:Econtroller <file>    # app/controllers/*_controller.rb
:Ehelper <file>        # app/helpers/*_helper.rb
:Emodel <file>         # app/models/*.rb
:Ejob <file>           # app/jobs/*_job.rb
:Emailer <file>        # app/mailers/*.rb

Banco de dados (DB)

:Emigration <file>     # db/migrations/*.rb
:Eschema               # db/schema.rb

Bibliotecas (Lib)

:Elib <file>           # lib/*.rb
:Elib                  # Gemfile
:Etask <file>          # lib/tasks/*.rake

Assets

:Estylesheet <file>    # app/assets/stylesheets/
:Ejavascript <file>    # app/assets/javascripts/

Views

:Eview <file>          # app/views/
:Elayout <file>        # app/views/layouts/

Testes

:Espec <file>          # spec/*_spec.rb
:Eunittest <file>      # test/{unit,models,helpers}/*_test.rb
:Efunctionaltest <file> # test/{functional,controllers,mailers}/*_test.rb
:Eintegrationtest <file> # test/integration/*_test.rb
:Efixtures <file>      # test/fixtures/

Configuração

:Einitializer <file>   # config/initializers/*.rb
:Elocale <file>        # config/locales/*.yml
:Eenvironment          # application.rb
:Eenvironment development # config/environments/*.rb

Variações dos comandos

Além dos comandos que já nos facilitam bastante, podemos ter variações onde são permitidos que o resultado dos comandos sejam apresentados em algum split ou em novas abas.

Prefixos para diferentes aberturas

Além de abrir no mesmo buffer, podemos especificar outros locais. Todos os comandos :E* possuem variações:

• :E* - Edita no buffer atual
• :S* - Abre em split horizontal (:split)
• :V* - Abre em split vertical (:vsplit)
• :T* - Abre em nova aba (:tabedit)

Exemplos:

:Emodel User           # Edita model no buffer atual
:Smodel User           # Abre model em split horizontal
:Vmodel User           # Abre model em split vertical
:Tmodel User           # Abre model em nova aba

Criação automática de arquivos

Adicione ! ao final para criar automaticamente o arquivo com boilerplate se não existir:

:Emodel User!          # Cria app/models/user.rb se não existir
:Econtroller Users!    # Cria app/controllers/users_controller.rb se não existir

Execução de comandos Rails

Comandos básicos

:Rails <command>       # Executa comando rails
:Rake <task>           # Executa rake task
:Rgenerate <generator> # Executa rails generate
:Rdestroy <generator>  # Executa rails destroy

Execução de testes

:Rake                  # Executa todos os testes
:Rake test:units       # Executa testes unitários
:Rake test:functionals # Executa testes funcionais
:Rake test:integration # Executa testes de integração

Extração de código

Extraindo partials e concerns

Esses são uma mão na roda para refactoring! Permitem a extração de uma parte do código do buffer/arquivo atual para outro:

# De uma view para app/views/home/_foo_partial.haml
:Rextract home/foo_partial

# De um model para app/models/concerns/foo_concern.rb
:Rextract FooConcern

Abreviações úteis

Algumas dessas abreviações podem não funcionar de acordo com algum plugin de snippets já ativo, então podem não funcionar!

Abreviações gerais

Abreviações para Models

Abreviações para Controllers

Abreviações para Views

Navegação aprimorada

O Vim/Neovim já tem o seu comando gf disponível (abreviação de "go to file"), onde quando utilizado, o conteúdo do arquivo onde se encontra o cursor será carregado. No plugin, isso foi feito de forma bem inteligente para uso com o Rails:

Comando gf aprimorado

O vim-rails aprimora o comandogf` (go to file) para:

• Pular para partials
• Navegar para arquivos de model
• Seguir referências específicas do Rails

Busca inteligente

O plugin reconhece automaticamente:

• Estrutura de diretórios Rails
• Convenções de nomenclatura
• Relacionamentos entre arquivos

Dicas de produtividade

Navegação rápida

1. Use tab completion: Todos os comandos suportam <Tab> para completar nomes
2. Combine com :A e :R: Navegue rapidamente entre arquivos relacionados
3. Use as variações S/V/T: Mantenha múltiplos arquivos abertos simultaneamente

Fluxo de trabalho sugerido

# Abrir model
:Emodel User

# Alternar para teste
:A

# Voltar ao model
:A

# Abrir controller relacionado
:R

# Abrir view em split
:Vview index

Comandos para verificar

:Rabbrev               # Lista todas as abreviações disponíveis
:help rails            # Documentação completa do plugin

Comandos menos conhecidos

Verificação de projeto

:Rlog                  # Abre o log do Rails
:Rpreview              # Preview da aplicação
:Rserver               # Inicia servidor Rails

Navegação por contexto

O vim-rails é inteligente o suficiente para:

• Detectar automaticamente o contexto atual
• Sugerir arquivos relacionados
• Completar nomes baseado na estrutura do projeto

Conclusão

O vim-rails transforma o Vim em uma IDE completa para Rails, oferecendo:

• Navegação intuitiva entre arquivos
• Execução de comandos Rails sem sair do editor
• Abreviações que aceleram a digitação
• Criação automática de arquivos com boilerplate
• Integração perfeita com a estrutura de projetos Rails

A chave para dominar o vim-rails é praticar os comandos de navegação (:A, :R) e memorizar os comandos :E* mais utilizados no seu fluxo de trabalho. Já tenho alguns slides para montar um vídeo de apresentação do Vim/Neovim, quando gravar quero mostrar várias das funcionalidades apresentadas aqui e atualizarei esse artigo com o link.

Happy Vimming!

Comentários

Sem nenhum comentário.