Blog do TaQ

Hoje Vim de Rails. ;-)

Publicado em Developer

Hoje finalmente sobrou um tempo para testar e escrever sobre o plugin Rails.vim (eita trocadilho infame no título!), feito pelo Tim Pope, que tem mais alguns plugins para o Vim também de sua autoria (inclusive eu fiz um post sobre um deles aqui).

Instalação

Para instalar o plugin podemos pegar o pacote no site do Vim ou se preferirem pegar a cópia mais recente através do Subversion:

svn co http://svn.tpope.net/rails/vim/railsvim

Nos dois casos para a instalação é só copiar os arquivos rails.vim para ~/.vim/plugin e rails.txt para ~/.vim/doc.

Criando o projeto

Logo após instalado, podemos ir para o diretório de nossa preferência, abrir o Vim e criar nosso projeto no Rails utilizando

:Rails projeto

Isso vai criar um diretório chamado projeto logo abaixo do diretório corrente com toda a estrutura necessária pelo Rails. Na verdade ele chama o comando rails com o nome do diretório que informamos, do mesmo modo que fazemos pelo console. Logo após criado o diretório ele abre o arquivo README do Rails para que possamos dar uma olhada ou solenemente ignorá-lo após estar careca de tanto ver o dito cujo. ;-)

Criando o modelo

Como primeiro passo vamos criar um modelo de uma tabela chamada, digamos, registros para o projeto. Podemos digitar no Vim:

:Rgenerate model Registro

O plugin vai criar o modelo do mesmo modo que fazemos na linha de comando, e vai abrir o primeiro arquivo gerado, nesse caso, registro.rb.

Migrations

Nosso modelo está criado, precisamos criar a tabela no banco de dados correspondente a ele, para isso vamos usar uma migration que já foi criada quando criamos o modelo. Digitamos

:Rmigration

A migration criada anteriormente foi aberta automaticamente. Nesse ponto podemos configurar e salvar essa migration com um lance MUITO interessante: se digitarmos :Rinvert na migration, o plugin vai "inverter" o conteúdo do método self.up no self.down, ou seja, se temos um create_table o plugin vai criar um drop_table (se self.up estiver vazio o processo é revertido). Porém antes de executar a migration vamos configurar nosso arquivo database.yml, que podemos editar usando

:Redit config/database.yml

O :Redit edita um arquivo levando em conta o diretório raiz da aplicação atual. Em muitos casos o :e do Vim faz a mesma coisa escrevendo-se menos. Depois de configurado o arquivo, vamos rodar nossa migration. Podemos utilizar o Rake da seguinte forma:

:Rake  

Temos que especificar a target do Rake, mas o plugin é bem esperto para saber que se estamos em uma migration e rodar a target db:migrate. Bem esperto esse carinha. :-)

Falando em esperteza, o plugin do Rails tem integração com outro plugin chamado dbext que, se estiver instalado, vai automaticamente carregar as configurações do database.yml. Isso permite que utilizemos quaisquer recursos do dbext sem nos preocuparmos em o configurar (detalhe: carrega automaticamente menos em ambientes Windows). Se por exemplo, quisermos ver como ficou o resultado da nossa migration no banco de dados, podemos posicionar o cursor em cima do símbolo :registros e digitar std (o leader no meu caso aqui no GNU/Linux é \), e a janela vai ser dividida horizontalmente mostrando

Connection: T(MYSQL)  H(localhost)  D(projeto_development)  U(taq)  
Field	Type	Null	Key	Default	Extra
id	int(11)	NO	PRI	NULL	auto_increment
descricao	varchar(255)	YES		NULL	

Controlador

Ok, já temos o modelo, vamos criar um controlador:

:Rgenerate controller Registros

Servidor

Vamos testar se o controller foi criado corretamente? Podemos iniciar o servidor web por aqui mesmo:

:Rserver

Dando uma olhada nos processos para ver se o servidor web foi corretamente iniciado:

20112 ?        S      0:00 ruby -C /home/taq/temp/projeto script/server -d

Olhem o processo dele ali. Se quisermos "matar" esse e iniciar outro, é só utilizar :Rserver! (notaram o ! "destrutivo" no nome do método? ;-)

Preview

Podemos abrir o browser no controlador que estamos e dar uma olhadinha nele. Antes de mais nada temos que configurar o browser que vamos utilizar no plugin. Para isso temos que definir um comando chamado OpenURL dessa maneira (troquem o caminho para a localização do seu browser preferido):

:command -bar -nargs=1 OpenURL :!/home/taq/firefox/firefox 

Agora que o browser está configurado corretamente, como estamos no controlador dos registros o plugin vai ser esperto o bastante para saber que queremos abrir a URL http://localhost:3000/registros quando digitarmos

:Rpreview

E olha que coisa mais linda mais cheia de graça! O browser foi aberto com a URL do controlador que estamos.

Console

Para abrir o console:

:Rconsole

O único porém é que enquanto não fechar o console, a janela de edição não se ativa.

Extração de parciais

Essa é uma boa. Vamos supor que temos o seguinte código em uma view chamada show para o nosso controlador registros:

<h1>Registro</h1>
<div>
  <h2><%= @registro.descricao %></h2>
  <p>Esse é um registro.</p>
</div> 

E por alguma carga d'água queremos renderizar a DIV em uma parcial. Podemos selecionar as linhas que queremos com SHIFT+V (nesse caso onde começa e termina a DIV) e digitamos:

:Rextract registro

O arquivo corrente se transforma em:

<h1>Registro</h1>
<%= render :partial => 'registro' %>

E é criada uma parcial chamada registro (que foi o nome que informamos ali em cima) em app/view/registros/_registro.rhtml com o seguinte conteúdo:

<div>
  <h2><%= registro.descricao %></h2>
  <p>Esse é um registro.</p>
</div> 

UIA! :-)

Navegando nos arquivos

No Vim o comando gf é utilizado para abrir o arquivo no qual o cursor se encontra sobre o caminho. Por exemplo, se eu colocar o cursor em cima de alguma parte do texto onde está escrito /home/taq/.vimrc e apertar gf, o meu .vimrc vai ser aberto (se quisermos abrir o arquivo em uma nova janela, temos que apertar CTRL+W CTRL+F ao invés do gf).

O plugin remapeou o gf. Vamos supor que estamos no código do controlador:

  def show
    @registro = Registro.find(:first)
  end

E posicionamos o cursor bem em cima de Registro e apertamos gf. Uau! Vamos para o modelo! Se na nossa view tivermos um código assim:

<%= link_to 'Home', :controller=>'registros' %>

E posicionarmos o cursor em 'registros' e digitarmos gf, vamos parar no controlador! Alguns outros exemplos da documentação do plugin:

	Pos*t.find(: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 :partial => 'sh*ared/sidebar' %>
	app/views/shared/_sidebar.rhtml ~

	<%= stylesheet_link_tag :scaf*fold %>
	public/stylesheets/scaffold.css 

	class BlogController < Applica*tionController
	app/controllers/application.rb 

	class ApplicationController < ActionCont*roller::Base
	.../action_controller/base.rb 

	fixtures :pos*ts
	test/fixtures/posts.yml 

	layout :pri*nt
	app/views/layouts/print.rhtml 

	(In the Blog controller)
	def li*st
	app/views/blog/list.rhtml 

Também podemos trabalhar com conceitos de arquivos alternativos e relacionado, que são estabelecidos como:

Arquivo corrente Arquivo alternativo Arquivo relacionado
Modelo Teste unitário Migração relacionada
Controlador (no método) Teste funcional Template (view)
Template (view) Helper Controlador (posiciona no método)
Migration Migration anterior Próxima migration
config/routes.rb config/database.yml config/environment.rb

Para acionar o arquivo alternativo, digitamos :A (ou :AS para dividir a janela horizontalmente, :AV para dividir verticalmente e :AT para abrir em uma nova aba). Para abrir o arquivo relacionado, digitamos :R (ou :RS, :RV e :RT do mesmo modo que com :A).

Javascript

Para acessar os arquivos .js podemos utilizar o comando :Rjavascript <nome>, onde nome é o nome opcional de um arquivo, se não for passado assume application.js.

CSS

Para acessar os arquivos .css podemos utilizar o comando :Rstylesheet <nome>, onde nome é o nome opcional de um arquivo, se não for passado assume o nome do controlador corrente.

Tags

Para gerar tags com nossas classes e métodos, podemos utilizar (atenção: precisamos do ctags instalado)

:Rtags

Isso vai gerar um arquivo tags na raiz do nosso projeto. Se quisermos dar uma olhada por exemplo em onde que está a definição de ApplicationController, posicionamos o cursor em cima dessa palavra no controlador e apertamos CTRL+], onde vamos ser direcionados diretamente para o arquivo application.rb. Uma dica rápida: para voltarmos para onde estávamos anteriormente utilizamos CTRL+T, mais documentação sobre o Vim e tags pode ser encontrada aqui.

Conclusões

O plugin oferece mais opções das que estão descritas aqui, vale a pena uma conferida. Não é uma IDE visualmente falando, mas se você está usando o Vim não está se preocupando com isso, está? ;-) Eu com esse plugin e o VTreeExplorer estou bem sossegado.


Tags:


Comentários

comments powered by Disqus

Twitter