Philip Sampaio

Tecnologia e opinião

Executando seus testes em uma App Rails na velocidade máxima com Vim e Zeus

Configurei meu Vim para rodar os testes da minha aplicação Rails (dependendo ou não do Rails) bem mais rápidos, através do Zeus.

O Zeus pré-carrega (faz um preload) sua aplicação Rails, e tudo que é dependência dela. Você pode instalá-lo com o comando:

1
$ gem install zeus

É importante lembrar que o Zeus não deve ser declarado no seu Gemfile.

Para executar o Zeus, vá a seu projeto Rails e execute zeus start. A partir daí, você conseguirá subir seu servidor (zeus s) ou executar comandos (zeus rake/generate/etc) de forma muito rápida!

Para rodar seus testes usando RSpec direto do seu Vim, você pode usar o plugin vim-rspec. Instale-o pela maneira mais recomendada, usando Vundle ou a que você preferir.

Em seguida é necessário configurar o comando que executa os testes. Adicione a linha abaixo ao seu .vimrc:

1
let g:rspec_command = "! zeus rspec {spec}"

O comando padrão para executar os testes (todos do arquivo) é \\t (<Leader>t) Se quiser executar um teste específico, mova o cursos para ele e execute \\s(<Leader>s). Há também um comando para executar o último teste: \\l(<Leader>l)).

Com o rspec-vim sua produtividade pode aumentar consideravelmente, evitando a mudança de abas ou terminais para executar seus códigos.

Declaração de variável no Ruby: por valor ou referência?

Toda declaração de variável na linguagem Ruby é feita por referência. Isso significa que quando declaramos uma variável, na verdade estamos declarando uma referência para um objeto em memória. Essa informação parece ser básica e dificilmente você terá problemas com isso. Mas aconteceu comigo, onde por engano eu esqueci deste pequeno detalhe.

Meu caso foi com um código mais ou menos como o abaixo.

1
2
3
4
5
6
7
8
9
a = [1, 2, 3, 4]
b = a
b << 5
puts b
#=> [1, 2, 3, 4, 5]
puts a
#=> [1, 2, 3, 4, 5]
puts a.object_id == b.object_id
#=> true

O código não era tão simples, mas o exemplo ilustra bem como aconteceu. Meu intuito era trabalhar com o conteúdo “armazenado” em b e deixar o conteúdo em a intacto. Porém quando alterei o valor de b (adicionando 5), também alterei em a. Isso causou um bug que foi corrigido no processo de code review.

Isso porque em Ruby todas as declarações são feitas através de referências para objetos.

Para resolver possíveis problemas (como alterar acidentalmente o objeto errado), você pode “clonar” ou “duplicar” (veja a diferença nos links abaixo) um objeto quando for referenciá-lo a uma variável.

Exemplo:

1
2
3
4
5
6
7
8
9
a = [1, 2, 3, 4]
b = a.dup
b << 5
puts b
#=> [1, 2, 3, 4, 5]
puts a
#=> [1, 2, 3, 4]
puts a.object_id == b.object_id
#=> false

Alguns links do Stack Overflow sobre o assunto:

Estatísticas de submissões no SPOJ

Por volta de setembro do ano passado iniciei o desenvolvimento de uma app para mostrar estatísticas e promover desafios entre usuários(equipes) do SPOJ.

Percebi que já existiam algumas pequenas aplicações para estatísticas, mas nada que promovesse desafios entre usuários(times). Eu queria unir as duas características. Mas o tempo passou e essa app acabou ficando de lado.

Foi então que decidi lançar o que foi feito, mesmo com alguns bugs.

O site fica no Heroku, e você pode acessar aqui. Não sei se vou continuar desenvolvendo essa aplicação, mas já valeu a pena pois aprendi muito com isso!

Usando tmux e vim para pair programming remoto

Há um tempo li o post do Gustavo Dutra e achei muito legal a possibilidade de fazer programação em par via terminal remoto. Usando o screen é possível compartilhar facilmente uma sessão do terminal e sair programando. Mas não consegui compartilhar informações de outras sessões abertas. Foi então que conheci o tmux.

image

Com tmux é possível criar sessões com várias “janelas”(inclusive com separação vertical e horizontal) e usar 256 cores sem problemas.

Seguindo o mesmo esquema do post do Gustavo, separei em “host” e “client”.

Host

Na máquina que servirá como servidor de desenvolvimento será preciso criar uma sessão:

1
$ tmux -2 -S /tmp/pair new-session -s PairProgramming 

Os parâmetros significam:

  • -2 : Aceita 256 cores
  • -S : Cria o socket no caminho especificado(no caso, /tmp/pair)
  • new-session -s: Cria uma nova sessão com o nome atribuido(no caso, PairProgramming)

Você vai precisar dar permissão no arquivo socket criado:

1
$ chmod 777 /tmp/pair

Feito isso, é só abrir o vim e aguardar o client =)

Client

Para que funcione, o client precisa estar conectado ao host via ssh com um usuário qualquer(o importante é ter acesso ao arquivo socket em /tmp/pair).

Depois de conectado, basta executar o comando:

1
$ tmux -2 -S /tmp/pair attach-session -t PairProgramming

O parâmetro “attach-session” faz o client se conectar à uma sessão alvo(-t nome-da-sessao)

Comandos básicos do tmux

Para ativar algum comando do tmux, por padrão(é possível mudar)você precisa precionar Ctrl+b

Comandos básicos:

  • Ctrl+b ? # Lista todos comandos
  • Ctrl+b c # Cria nova janela
  • Ctrl+b n # Vai para próxima janela
  • Ctrl+b % # Divide a janela atual em duas verticais
  • Ctrl+b “seta para direita|esquerda” # Move entre as janelas divididas
  • Ctrl+b : # Abre o modo comando do tmux

Conclusão

É possível fazer muita coisa com o tmux. Para saber mais, sugiro que siga os links:

UPDATE (01/04/2013):

Chris Hunt palestrou na LA Ruby Conf 2013 sobre o Vim e Tmux. Ele faz o que este tutorial apresentou, e muito mais: https://www.youtube.com/watch?v=vHdiXoHKSgU