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.

O legal ẽ que :A e :R tem versões complementares com E, S, V, T e D, sendo que D tem comportamento meio estranho e destrutivo, que eu recomendaria evitar. O que cada versão faz:

Particularmente utilizo bastante o :AV quando carrego um modelo, para abrir o teste logo ao lado

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

Uso avançado de :Emigration:

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/

Uso inteligente de :Eview:

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 tambẽm com S, V e T, como comentado antes com :A e :R:

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

Comandos dinâmicos

Para qualquer diretório app/{type}s/ contendo arquivos *_{type}.rb, um comando :E{type} é criado automaticamente. Ou seja, se você criar um diretório app/services, vai ser criado um comando :Eservice.

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

Comandos de execução

:Rails <command>           # Executa rails <command>
:Rails                     # Executa tarefa padrão baseada no arquivo atual
:Console <options>         # Lança rails console
:Generate <options>        # rails generate (carrega arquivos no quickfix)
:Generate! <options>       # Como acima, mas não pula para primeiro arquivo
:Destroy <options>         # rails destroy
:Server <options>          # rails server em background
:Server! <options>         # Mata servidor atual e inicia novo

Execução de código

:Runner <file>             # rails runner <file>
:Runner <code>             # rails runner '<code>'
:[range]Runner <file>      # Executa com range específico para testes
:Rp <code>                 # rails runner "p begin <code> end"
:Rpp <code>                # Como :Rp mas com pretty print

Comando Rake

:[range]Rake <task>        # Executa rake <task>

Comandos de log e preview

Comandos de log

:Clog [environment]        # Carrega log no quickfix, pula para última linha
:Rlog [environment]        # Abre log na janela de preview (deprecated)

No quickfix do :Clog:

• R recarrega a lista
• G recarrega e pula para última linha

Preview no navegador

:Preview [path]            # Abre path no navegador
:Preview! [path]           # Abre path dentro do Vim com netrw

O :Preview é inteligente:

• Detecta servidor rodando com netstat/lsof
• Consulta Pow se não encontrar servidor
• Usa localhost:3000 como fallback
• Determina path baseado no arquivo atual e routes

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 entender o contexto de uma aplicação Rails, permitindo:

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

Aqui temos alguns exemplos de uso do gf (o * indica posição do cursor quando o comando ẽ executado):

Pos*t.first                            # => app/models/post.rb
has_many :c*omments                   # => app/models/comment.rb
link_to 'Home', :controller => 'bl*og' # => app/controllers/blog_controller.rb
<%= render 'sh*ared/sidebar' %>       # => app/views/shared/_sidebar.html.erb
<%= stylesheet_link_tag 'appl*ication' %> # => app/assets/stylesheets/application.css
class BlogController < Applica*tionController # => app/controllers/application_controller.rb
fixtures :pos*ts                      # => test/fixtures/posts.yml
layout :pri*nt                        # => app/views/layouts/print.html.erb
<%= link_to "New", new_comme*nt_path %> # => app/controllers/comments_controller.rb (def new)

Também funciona com CTRL-W f (nova janela) e CTRL-W gf (nova aba).

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!