Se você é um desenvolvedor Ruby on Rails e um usuário dedicado do Vim, é provável
que já tenha ouvido falar (e esteja usando) este plug-in maravilhoso chamado rails.vim. É
feito por Tim Pope, um criador ou muitos plug-ins excelentes do Vim, então, se ainda não o fez
, verifique seus repositórios no GitHub . Então, o que esse plug-in
você pergunta? Em geral, faz o Vim agir e parecer que foi feito para programar
Rails. É simplesmente tão poderoso. Não
vou abordar todos os recursos do plug-in aqui, mas vou cobrir o que considero mais útil e, com
sorte, parte disso vai te impressionar.

Navegando em seu projeto

Neste primeiro post, vamos dar uma olhada em como rails.vim torna super fácil
navegar dentro do seu projeto Ruby on Rails. Este é provavelmente um dos
recursos mais básicos do plug-in, mas é muito poderoso quando você se acostuma.
Você pode argumentar que não precisa de ajuda para navegar nos
arquivos fonte do Rails . Talvez você use algo como ctrlp ou Command-T para correspondência difusa de
seus arquivos. Embora eu incentive o uso de tais métodos para abrir rapidamente seus
arquivos de origem , eu simplesmente acho que os comandos rails.vim acrescenta são mais fáceis de usar e mais
semânticos, então eu recomendo que você experimente de qualquer maneira.

O plug-in, na verdade, aprimora a maneira como você navega em seu projeto de várias
maneiras, uma delas é usar os diversos comandos Ex que ele fornece. Aqui está uma lista
dos comandos que uso mais comumente:

• :Rmodel – Abre um modelo no buffer atual
• :Rview – Abre uma visão no buffer atual
• :Rcontroller – Abre um controlador no buffer atual.
• :Rhelper – Abre um auxiliar no buffer atual.
• :Rmailer– Abre um mailer no buffer atual
• :Renvironment– Abre um arquivo de ambiente no buffer atual ou config / application.rb se nenhum for especificado.
• :Rcontroller– Abre um controlador no buffer atual

Existem muitos mais desses, mas este é um bom conjunto para começar. Como um
exemplo de uso de um deles, se você deseja abrir o modelo JoyfulUser, seu
comando seria assim:

:Rmodel User

Ou poderia ser assim:

:Rmodel user

Qualquer uma das variações funciona, rails.vim é inteligente o suficiente para mapear nomes de classes para nomes de
arquivos com base em convenções e, portanto, abre os arquivos corretos. Você pode até mesmo
usar namespaces como Administrador :: User, que seria mapeada automaticamente para o
arquivo admin / user.rb .

Esses comandos também completam automaticamente os nomes de arquivo ou de classe
(dependendo da sua entrada, ou nomes de arquivo por padrão se você não inserir nada), e
se completam automaticamente semanticamente, o que significa que o comando irá apenas sugerir nomes de arquivos no aplicativo / modelos de seu aplicativo diretório, sugeriria apenas arquivos em app / controllers e assim por diante. Embora você possa realizar algo semelhante usando outras ferramentas de pesquisa difusa, elas simplesmente não têm a funcionalidade semântica que este plug-in fornece.:Rmodel
:Rcontroller

Mas e se você não quiser que os arquivos sejam abertos no buffer atual, mas
em uma nova guia, uma divisão vertical ou horizontal? Claro, rails.vim
cobre você. Todos os comandos usados ​​para abrir arquivos possuem equivalentes para
abrir em novos buffers, seja em qualquer tipo de divisão ou em uma nova aba. Eles são fáceis de
lembrar e rápidos de digitar também. Para abrir o modelo de usuário em uma divisão vertical,
você executaria o comando , para abrir o PagesController em uma nova guia que você executaria e para abrir a visualização sessions / new.html.erb em uma divisão horizontal, você executaria `: Rview sessions /new.html.er. Naturalmente, todos esses comandos também completam automaticamente, como as versões “aberto no buffer atual”.:RVmodel User
:RTcontroller PagesController

Por padrão, se dado um nome de arquivo (ou nome de classe) que não existe, ele exibe
uma mensagem de erro informando que o modelo especificado, controlador ou
qualquer coisa que você pediu não existe. No entanto, oferece a oportunidade
de criar automaticamente o arquivo que você deseja, com conteúdo padrão. Para fazer
isso, forneça um estrondo (ou seja, um ponto de exclamação) no final do argumento
transmitido. Isso significa que, ao executar o comando , rails.vim criará o arquivo app / models / non_existing_model.rb com o seguinte conteúdo padrão ::Rmodel NonExistingModel!

class NonExistingModel
end

No entanto, embora isso seja realmente poderoso, eu geralmente prefiro usar os
métodos do gerador Rails (neste exemplo rails g model). A razão para isso é que
o plug-in criará apenas esse arquivo, enquanto o gerador geralmente cria
muitos mais. Para modelos, o gerador criaria uma migração e um
arquivo de teste ou especificação para o modelo também, o que o torna mais poderoso. E, não surpreendentemente,
rails.vim torna ainda mais fácil rodar geradores também. Mais sobre isso em um
post posterior.

Eu gostaria de mencionar também outro recurso bastante interessante com a
navegação do comando Ex fornecida, que é a percepção do contexto. Na verdade, descobri isso
por coincidência, embora tenha certeza de que está documentado em algum lugar. Deixe-me explicar o
que quero dizer com o plug-in ciente do contexto. Digamos que você esteja visualizando um
controlador (vamos chamá-lo de UsersController) e queira verificar o modelo
associado a esse controlador (por convenção, sendo o modelo de usuário). Você poderia
ir em frente e ligar , mas, na verdade, rails.vim torna tudo ainda mais fácil do que isso. Chamar sem argumentos irá, na verdade, pesquisar o arquivo que deve conter o modelo de usuário. Se existir, ele navegará até ele. Eu:Rmodel User
:Rmodel

Sou um grande fã de splits e acho isso extremamente útil quando quero
o controlador e a visualização lado a lado, por exemplo. Eu teria o modo de exibição
aberto e, em seguida, executado sem argumentos para obter o controlador associado em um buffer de divisão vertical. É pura magia.:RVcontroller

Números de linha e métodos

Esses comandos Ex fornecidos por rails.vim também oferecem a possibilidade de pular
diretamente para um número de linha ou uma definição de método ao abrir um arquivo. Isso é
útil durante a depuração – quando você sabe o número da linha de um backtrace – ou
simplesmente tem uma classe muito grande e precisa verificar ou trabalhar com um método específico.

Digamos que você tenha um PostsController e deseja alterar a ordem em que busca
os posts para a página de índice. O código para isso está localizado na indexação
do controlador, portanto, para chegar lá rapidamente, você pode navegar até
a classe do controlador e talvez encontrar o método manualmente ou pode navegar
diretamente para o método desta forma:

:Rcontroller posts#index

Observe como separamos o nome do controlador e a ação com uma cerquilha
( # ). Isso se assemelha às convenções RDoc dos métodos de instância anteriores
com sinais de hash. No entanto, não é possível navegar para métodos de classe usando
um ponto ou dois-pontos duplos, o sinal de hash também deve ser usado lá. Lembre-
se de que os nomes dos métodos não podem ser preenchidos automaticamente. Apesar do que você possa
pensar, isso não altera suas pesquisas (para encontrar o método), portanto, seu
termo de pesquisa anterior ainda é mantido intacto.

Como mencionei, você também pode pular diretamente para um número de linha no arquivo de destino.
Para fazer isso, você usaria dois pontos para separar a classe ou o nome do arquivo e
o número da linha. Portanto, se você quiser pular para a linha 15, execute o
seguinte comando no PostsController:

:Rcontroller posts:15

Conhecendo o path

Como uma observação lateral, pode ser importante mencionar que o plug-in manipula a
configuração de “caminho” para incluir os diretórios de origem do seu projeto para realizar essas
coisas. Isso também significa que você pode usar o comando para navegar até arquivos que podem não ter comandos especiais mapeados para eles (como, por exemplo, config / database.yml ). No entanto, tendo a usar ctrlp para isso, já que os nomes dos arquivos são geralmente fáceis de identificar imediatamente.:find

Navegando usando o gfcomando do Vim

Isso deve nos aquecer para navegar em um projeto Rails usando rails.vim.
No entanto, também existem outras maneiras de navegar, que estão disponíveis porque
o plug-in altera o comportamento do gfcomando. Digamos que você esteja
exibindo atualmente o modelo de categoria em seu aplicativo, que . Com o cursor posicionado sobre a linha que associa esses modelos, pressionar a combinação de teclas leva você diretamente ao modelo Post. As postagens podem ter muitos comentários e, com o cursor na linha dizendo , pressionar irá para o modelo Comentário. Isso é especialmente poderoso quando usado junto com a lista de atalhos do Vim. Depois de pular de Post para Comentário, pressionehas_many :posts

gf
has_many :comments
gf

^oo levaria de volta ao modelo Post novamente, e pressioná-
lo novamente levaria mais um passo para trás, para o modelo de categoria.
Domine esta técnica e você será visto como um mago Vim por seus companheiros
e colegas de trabalho.

Isso não funciona apenas com classes simples de Ruby, não, rails.vim vai além
disso. Também pode ser usado para pular rapidamente para parciais que estão sendo
renderizados nas visualizações. Como uma postagem tem muitos comentários, podemos ter um show view
com algo assim:

<section class="comments">
  <h3>Something on your mind?</h3>

  <%= render "comments/form", comment: @post.comments.build %>
  <%= render "comments/list", comments: @post.comments %>
</section>

Posicionar o cursor sobre, digamos, a linha nele e pressionar o levará ao arquivo app / views / comments / _form.html.erb . E, novamente, isso funciona extremamente bem junto com a lista de atalhos para alternar entre os arquivos. Se você está impressionado com esse recurso agora, espere até experimentá-lo.render "comments/form"
gf

Arquivos alternativos e relacionados

Até agora, vimos como o rails.vim pode ajudá-lo a navegar para arquivos específicos
, especificando-os em um comando Ex, como ou usando o comando poderoso no modo normal. Há também uma terceira forma, da qual tenho certeza de que não poderia viver sem agora que a experimentei, que é usar o conceito de arquivos alternativos e relativos. Esta é mais uma funcionalidade sensível ao contexto que o plug-in fornece e, uma vez que você tenha entendido, você estará viciado.:Rmodel
gf

A forma como funciona é que rails.vim tem um conjunto de arquivos que são considerados
alternativos ou relacionados ao arquivo ativo no momento. Arquivos alternativos geralmente são arquivos de
teste, portanto, o arquivo alternativo para app / models / user.rb seria
spec / models / user_spec.rb (ou um arquivo de teste de unidade semelhante de outra
estrutura de teste ). No entanto, existem algumas exceções a esta regra. Os arquivos relacionados variam
e podem depender da posição do cursor no arquivo atual.
A seguir está uma tabela mostrando alguns tipos de arquivos juntamente com seus alternativos
e relacionados.

Por exemplo, se você estiver atualmente localizado em um modelo, o arquivo alternativo seria as especificações desse modelo. O arquivo relacionado seria a definição do esquema para esse modelo, ou seja, a linha em db / schema.rb onde ocreate_tabledeclaração para a tabela desse modelo é. Nos controladores, o arquivo alternativo também é a especificação, e o arquivo relacionado o levará para a visualização da ação em que o cursor está atualmente localizado ou, se o cursor não estiver dentro de nenhuma ação, para o assistente de visualização associado. De uma visão, o arquivo relacionado é o reverso daquele de um controlador, levando você para a ação associada a essa visão, e o arquivo alternativo é, mais uma vez, a especificação da visão. As migrações não têm especificações e o arquivo alternativo é a migração definida anteriormente (por carimbo de data / hora), enquanto o arquivo relacionado é a próxima migração. Dessa forma, você pode alternar entre as migrações, se tiver vontade de fazer isso. Existem muitos outros mapeamentos de arquivos alternativos / relacionados que você pode explorar

Então, como você começa a usar esses mapeamentos? A resposta é simples: por meio de alguns comandos Ex. Para pular para um arquivo alternativo, use o comando . Para pular para um arquivo relacionado, use . Os comandos são fáceis. A parte difícil aqui é lembrar como diferentes tipos de arquivos são mapeados juntos; no entanto, se você usá-lo com frequência, rapidamente se familiarizará com a maioria deles. Tal como acontece com os outros comandos Ex, você também pode anexar S , V ou T para abrir o arquivo alternativo ou relacionado em uma divisão horizontal, divisão vertical ou nova guia, respectivamente. Eu normalmente uso para abrir as especificações de um arquivo em uma divisão vertical ao lado dos meus arquivos de origem reais.:A:R:AV

Conclusão

Vimos como rails.vim fornece muitas maneiras de navegar em seu
projeto Rails . Ele fornece comandos Ex para navegar para tipos específicos de arquivos,
como modelos, controladores e visualizações. Também demos uma olhada no gfcomando, que
foi aprimorado para entender mais facilmente quais arquivos devem ser acessados ​​com base
no contexto em que está escrito. Por último, vimos como ele também reconhece
o contexto no sentido de que o plug-in sabe em qual arquivo navegar até os arquivos que estão de
alguma forma relacionados ao buffer aberto no momento.