O Nyane nasceu depois que eu resolvi estudar o Rack, e me deparei com isto: Very Simple Rack Framework.

Construir um framework baseado no Rack, ao vivo, durante uma apresentação de 30 minutos? Não é possível! Olha a sintaxe, tão bonitinha, como construir isso de maneira rápida e fácil de apresentar? Aquilo me deixou muito intrigado. Passei horas procurando na internet como construir um framework que fosse capaz de aceitar aquela sintaxe. Infelizmente, a documentação do Rack para este tipo de finalidade é quase nula.

Fui atrás de alguns frameworks simples baseados no Rack. O primeiro que eu encontrei foi o Coset. Mas o código era meio difícil de entender. Quer dizer, o código do framework em si não é complicado, acontece que eu não enxergava a ligação entre aquele código e o Rack. Iria precisar de algo bem mais simples pra começar.

Foi aí que eu encontrei algumas apresentações sobre como construir aplicações Rack. Agora, todo aquele código começava a fazer sentido. Mesmo assim, eu queria algo mais simples. Foi quando eu encontrei o Invisible. A versão inicial era ainda mais simples. Ótimo! Achei meu ponto de partida.

No final de semana passado, estava em um quarto de hotel sem internet. Resolvi começar a “brincar sério” com o Rack. Foi aí que me saí com isso:

class Nyane
 
  def initialize(&block)
    @actions = []
    instance_eval(&block)
  end
 
  def get(route, &block)
    @actions << [route, block]
  end
 
  def call(env)
    action = @actions.detect { |route, block| env["PATH_INFO"].match(Regexp.new("^#{route}$")) }
 
    if action
      [200, {'Content-type' => 'text/html'}, action.last.call]
    else
      [404, {'Content-type' => 'text/plain'}, "Not found"]
    end
  end
 
end

22 linhas no total. 17 linhas de código. E mesmo assim, capaz de rodar isto:

require "nyane"
 
app = Nyane.new do
  get "/" do
    "Hello!"
  end
 
  get "/hello" do
    "Hello, hello, hello!"
  end
 
  get "/bye" do
    "Goodbye!"
  end
end
 
run app

Genial!

O código estava pronto. Queria liberar logo para que outras pessoas pudessem “brincar” com o Rack também. Conversando com o Nando, ele disse que o framework teria que ter “uma razão pra existir”. Mesmo eu dizendo que não era algo pra ser levado a sério, era só pra estudo. Aí ele disse que se fosse pra desenvolver um framework, teria que ter um motivo e se diferenciar dos outros. E eu continuava dizendo que era algo insignificante! :P

Bom, se é preciso motivos, e diferenciá-lo, então eu farei! :)

A idéia do Nyane é ser um framework extremamente simples. Nada de helpers, layouts, partial. Nem mesmo suporte à cookies, sessions. Quer saber? Vou liberar sem suporte à POST! Aí está a diferença dele pros outros. Duvido que exista um framework que não suporte POST. :P

Depois disso, faltava um nome. Mas escolher um nome para um projeto que não devia ser levado a sério? Parecia demais para mim. Resolvi brincar com o nome. Nyane, quer dizer insignificante em Sesotho. Sim, um framework insignificante. :P

Coloquei o código no GitHub no começo da semana. Mostrei apenas para alguns amigos. Apesar de ser algo bem simples e experimental, algumas pessoas se interessaram em usá-lo para alguma pequenas aplicações. Claro, você não vai construir nenhum site completo com ele, mas, quem sabe uma área do site que não necessite de sessões, cookies ou até mesmo POST. Quando eu construía este código, não via aplicação alguma, nem mesmo achava que pudesse ser usado em produção. Hoje, vejo algumas áreas (ou serviços) de sites maiores que podem ser reescritos sem a necessidade de nada acima, nem mesmo POST.

Sim, o suporte à POST pode ser algo que amplie o uso do framework, mas, qual seria a grande diferenciação dele para os outros? :P Bom, fica para uma próxima versão.

Melhor: que tal você experimentar um pouco com o código e implementar isto? Que acha? :)

Um dos problemas que eu tinha era quando precisava usar o ruby-debug. Cheguei até a perguntar no IRC, mas ninguém sabia me dar uma resposta de como usá-lo em conjunto com o Passenger. Na época, resolvi usar o Mongrel para fazer o debugging e nem me preocupei mais.

Hoje, precisei de novo. E não queria usar o Mongrel. Então, fui novamente atrás de uma solução. Vamos à ela:

No arquivo: config/environments/development.rb coloque o seguinte código:

# Load ruby-debug
require "ruby-debug"
Debugger.start_remote

Este código ativa o modo remoto do ruby-debug.

Agora, vamos reiniciar o passenger:

$ touch tmp/restart.txt

Agora, vamos conectar remotamente ao ruby-debug através do terminal:

$ rdebug -c
Connected.

Pronto! Sempre que quiser depurar algum erro em sua aplicação, coloque a palavra chave debugger e espere o rdebug. Só não se esqueça dos testes para não depender tanto de debugging. :)

Para atualizar, é só rodar o comando:

sudo gem update --system

Pronto! Só que, aqui no Mac OS X, ele instala a nova versão, mas o comando gem ainda aponta para a versão antiga:

$ gem -v
1.1.0
$

Talvez seja porquê o RubyGems agora é incluído por padrão no Leopard. Porém, eu queria desfrutar da velocidade para instalar novas gems que a versão 1.1 possui. Aqui vai uma solução:

$ sudo gem install rubygems-update
$ sudo update_rubygems

Funciona! Para aqueles que não necessitam da versão 1.1 com urgência, recomendo esperar um update da Apple (que pode demorar).

E que venha a RailsConf Brasil! ;)

Então, mãos à obra!

O que é preciso?

Vou usar a excelente biblioteca de parser HTML chamada Hpricot.

O código HTML do Terra

Vamos analisar o código HTML da página que mostra o quadro de medalhas do Terra.

O quadro de medalhas está dentro de uma tabela com a classe: tab_med

<table width="100%" border="0" cellpadding="0" cellspacing="1" class="tab_med">

Dentro desta tabela, temos vários tr’s , com um td dentro, cuja classe é pais. É esse que nos interessa. Pois, aqui, vamos encontrar a colocação, e o nome do país.

O número de medalhas se encontra dentro de outros td’s, cuja classes são: val_ouro, val_prata, val_bronze e val_tot para medalhas de Ouro, Prata, Bronze e Totais, respectivamente.

O código Ruby

Primeiramente, vamos chamar as bibliotecas Hpricot, e Open-URI (para abrir uma página Web).

require 'rubygems'
require 'hpricot'
require 'open-uri'

Agora, vamos abrir a página que vamos fazer o parsing

doc = Hpricot(open("http://agendapan.terra.com.br/br/medalhas/medalheiro.html"))

Extraindo a colocação

Vamos então, montar um código que passa por todos os td’s com a classe pais, e encontrar um link (a), que aponta para a página específica de medalhas do Brasil.

doc.search(”td.pais”).each do |pais|
pais.search(”a[@href='/br/medalhas/BRA/medalheiro_1.html']“) do
@colocacao = pais.inner_html[0..1].to_i
end
end

puts @colocacao

As medalhas

Após ter encontrado a colocação do Brasil, vamos exibir as medalhas ganhas até agora, encontrando o enésimo tr dentro de nossa tabela, usando a colocação como referência. Após isso, é só extrair o conteúdo dos td’s cuja classe sejam as das medalhas que procuramos.

doc.search("table.tab_med").at("tr:nth-of-type(#{@colocacao})") do |medalhas|
  puts "Ouro: #{medalhas.search("td.val_ouro").inner_html}"
  puts "Prata: #{medalhas.search("td.val_prata").inner_html}"
  puts "Bronze: #{medalhas.search("td.val_bronze").inner_html}"
  puts "Total: #{medalhas.search("td.val_tot").inner_html}"
end

O código completo

require 'rubygems'
require 'hpricot'
require 'open-uri'
 
doc = Hpricot(open("http://agendapan.terra.com.br/br/medalhas/medalheiro.html"))
 
doc.search("td.pais").each do |pais|
  pais.search("a[@href='/br/medalhas/BRA/medalheiro_1.html']") do
    @colocacao = pais.inner_html[0..1].to_i
  end
end
 
puts @colocacao
 
doc.search("table.tab_med").at("tr:nth-of-type(#{@colocacao})") do |medalhas|
  puts "Ouro: #{medalhas.search("td.val_ouro").inner_html}"
  puts "Prata: #{medalhas.search("td.val_prata").inner_html}"
  puts "Bronze: #{medalhas.search("td.val_bronze").inner_html}"
  puts "Total: #{medalhas.search("td.val_tot").inner_html}"
end

Mais um problema resolvido, usando Ruby! :)

silence_warnings do
  Date::MONTHNAMES = [nil] + %w(Janeiro Fevereiro Março Abril Maio Junho Julho Agosto Setembro Outubro Novembro Dezembro)
  Date::DAYNAMES = %w(Domingo Segunda-Feira Terça-Feira Quarta-Feira Quinta-Feira Sexta-Feira Sábado)
  Date::ABBR_MONTHNAMES = [nil] + %w(Jan Fev Mar Abr Mai Jun Jul Aug Set Out Nov Dez)
  Date::ABBR_DAYNAMES = %w(Dom Seg Ter Qua Qui Sex Sab)
 
  Time::MONTHNAMES = Date::MONTHNAMES
  Time::DAYNAMES = Date::DAYNAMES
  Time::ABBR_MONTHNAMES = Date::ABBR_MONTHNAMES
  Time::ABBR_DAYNAMES = Date::ABBR_DAYNAMES
end

Acontece, que quando usamos a função strftime, estes nomes não são traduzidos. Eles funcionam apenas nos helpers date_select, entro outros. Em um projeto meu, eu precisava usar estes nomes traduzidos, justamente com a função strftime, então, cheguei à este código:

class Time
  alias :strftime_nolocale :strftime
 
  def strftime(format)
    format = format.dup
    format.gsub!(/%a/, Date::ABBR_DAYNAMES[self.wday])
    format.gsub!(/%A/, Date::DAYNAMES[self.wday])
    format.gsub!(/%b/, Date::ABBR_MONTHNAMES[self.mon])
    format.gsub!(/%B/, Date::MONTHNAMES[self.mon])
    self.strftime_nolocale(format)
  end
end

E funcionou!

Fica aqui a dica então, para quem estiver com este mesmo problema.

Segue tradução livre:

Uma das razões para que eu ame Ruby é que o meu código normalmente pode ser lido como se fosse Inglês. Quando meu código se torna legível como uma sentença em Inglês, eu acredito que irei codificar exatamente aquilo que eu quero atingir. Código é mais fácil de entender e manter quando a intenção original do código é evidente. Eu acho que é por isso que Java e C# são tão atrativas se comparadas com C++. E porquê C++ é tão mais legal que C.

Ruby é uma grande linguagem, assim como Chicago é uma grande cidade. Porém hoje, eu gostaria de nos aventurarmos por uma rua transversal, pegar uma estrada menos usado por iniciantes em Ruby. Nós iremos aprender como usar modificadores na forma de algumas palavras reservadas Ruby muito bem conhecidas para melhorar a clareza do código.

Diga xiiis

Digamos que nós iremos escrever um código para operar uma câmera digital. Você tem métodos como capture_image, por exemplo, que captura uma imagem do sensor e gera um arquivo de imagem no cartão de memória (e se estivermos com sorte, emite um som de “click” para imitar uma câmera analógica). Vamos ver como você poderia escrever o código para quando o usuário pressionar o botão de disparar.

def botao_de_disparo_clicado
  if @camera.desligada? || @camera.cartao_de_memoria_cheio?
    return
  end
  capture_image
end

Então, se a câmera estiver desligada ou se estivermos sem memória, não fazemos nada. Se tudo estiver bem, nós tiramos a foto. Este era o meu estilo quando eu comecei com Ruby, e se este código se parece com o que você faz também, então você está pronto para algo novo e recompensante.

A chave é saber que as palavras reservadas como return, while, if, unless e until podem ser usadas como modificadores. Isto quer dizer que você coloca a parte condicional depois da palavra reservada. Parece besta, e em algumas vezes realmente é. Porém, algumas vezes pode ser recompensador.

O código que escrevemos estava tentando verificar alguns requerimentos. Para poder tirar a foto, a câmera não pode estar desligada e o cartão de memória não pode estar cheio. Usando modificadores de forma para return, você pode reescrever o código acima assim:

def botao_de_disparo_clicado
  return if @camera.desligada? || @camera.cartao_de_memoria_cheio?
  capture_image
end

A primeira linha diz, retorne imediatamente se a câmera estiver desligada ou o cartão de memória estiver cheio. Se chegarmos até a segunda linha, nós podemos prosseguir e capturar a imagem. Leia o código acima em voz alta. Parece melhor, não?

Mas espere, nós podemos ir um passo à frente. Por exemplo, você poderia preferir isto:

def botao_de_disparo_clicado
  capture_image unless @camera.desligada? || @camera.cartao_de_memoria_cheio?
end

Agora, leia alto novamente: “Capture a imagem a não ser que a câmera esteja desligada ou o cartão de memória esteja cheio.“. Isto expressa a nossa intenção de uma maneira um pouco diferente. Quando lemos alto, a primeira coisa que ouvimos é “capture a imagem”. Eu acho mais vantajoso de ouvir isto primeiro, porquê é o que acontece em 90% dos casos em que o disparador é clicado. Escrevendo códigos desta maneira, nós emfatizamos o comportamento esperado. Nós usamos a cláusula unless para guardar o comportamento com nossas regras de negócio. O código é mais transparente, fazendo com que os requerimentos sejam mais fáceis de visualizar. Este código é mais fácil de entender e manter.

Porém, vamos voltar ao código original por um minuto. Não existe maneira certa ou errado de fazer isto, e pode ser que você não tenha gostado do meu original. Finalmente, ele tem este return desajeitado flutuando no espaço.Trocando o operador lógico de lugar, o código original poderia ficar assim:

def botao_de_disparo_clicado
  if @camera.ligada? && @camera.memoria_disponivel?
    capture_image
  end
end

Dessa maneira já se lê melhor. Porém, nós ainda temos esse sentimento if-then. Parece mais como código, e menos como Inglês. Que tal isso?

def botao_de_disparo_clicado
  capture_image if @camera.ligada? && @camera.memoria_disponivel?
end

De qualquer jeito, agora é com você. Eu escrevi código Ruby da “maneira antiga” por muito tempo, e foi somente nos últimos seis meses que eu mudei para os modificadores de formas. Somente use a forma que parece mais natural à você.

Como se fosse 1999

Agora suponha que você tem um novo requerimento que diz que a câmera deve ter a habilidade de tirar fotos sem-parar em uma maneira estroboscópica até todos os bytes da memória serem usados. (Você pede ao cliente, porquê, mas porquê alguém iria querer esta habilidade, porém é um “must-have”, uma habilidade que a câmera “absolutamente não pode deixar de ter”. Então, você prossegue.)

Na verdade, este parece ser um método fácil de escrever:

def fique_louca
  while (@camera.memoria_disponivel?)
    capture_image
  end
end

Novamente – você vem escrevendo código assim por um bom tempo, e especialmente se você vem do VB.Net ou C# ou Java, este código provavelmente parece perfeitamente legível à você. Seu problema é que está na caverna por tanto tempo, que você acredita que a tocha na parede te dá luz suficiente. E se você pudesse escapar para o mundo e ver o sol? Olhe para:

def fique_louca
    capture_image until @camera.cartao_de_memoria_cheio?
end

“Capture Imagem até o cartão de memória esteja cheio.” Ou se você preferir,

def fique_louca
  capture_image while @camera.memoria_disponivel?
end

“Capture imagem enqunato a memória estiver disponível.“.

Apenas faça isto

Os modificadores de formas não são apenas sutilezas ou reconsiderações da linguagem. Eles estão lá por algum motivo. Tente usá-los por um tempo e veja se isto não melhora o seu estilo. Use-os onde e quando parecer apropriado à você. Deixe a intenção do seu código clara e óbvia.

Sempre pensei em criar um feed para a seção Notas Musicais do site. Só que nunca fui atrás, por pura falta de tempo em procurar por bibliotecas que fizessem o Parsing em HTML, tanto em Python ou PHP.

Depois de conhecer Ruby, pensei em perder um tempinho, procurando alguma biblioteca que fizesse o Parsing HTML, e depois, construir o feed RSS. Fazer o Feed seria a parte mais fácil, graças à biblioteca Builder usada para gerar arquivos XML.

O parsing ficaria à cargo da excelente Hpricot. Porém, encontrei uma outra biblioteca, chamada Feedalizer que usa a Hpricot para criar feeds RSS. Menos trabalho que isso, impossível!

Então, aqui vai o código usada para gerar o feed da página:

#!/usr/bin/env ruby
 
require "rubygems"
require "feedalizer"
require "time"
 
rss = File.new("arthurgeek.net/89.xml","w")
 
feedalize("http://www.89fm.com.br/notas/") do
  feed.title = "89 FM Notas"
  feed.about = "..."
  feed.description = "Notícias do mundo musical da 89FM"
 
  scrape_items("a.formtextobranco") do |rss_item, html_element|
    rss_item.link  = "http://www.89fm.com.br" + html_element.attributes["href"]
    rss_item.date  = Time.parse(html_element.to_s)
    rss_item.title = html_element.inner_html
 
    rss_item.description = html_element.inner_html
  end
 
  output! rss
end
 
rss.close

O arquivo do feed está disponível aqui e já estou usando-o há mais de 2 meses, e acredito, que não tem mais bugs, e pode agora, ser usado por qualquer um.

Ah, como eu gosto desta linguagem…

[Update: Hoje em dia, o método preferido para deploy Rails + Apache é usando o Phusion Passenger, também conhecido como mod_rails. Para aprender como fazer um deploy com o mod_rails, leia este excelente artigo do Nando Vieira. :)]

Como eu havia dito, não achei artigos em português explicando como fazer o deploy de aplicações Rails usando mod_proxy_balancer e mongrel_cluster, por isso resolvi escrever um.

Os comandos a seguir foram testados em um Ubuntu 7.04 Server Edition, mas devem servir para qualquer distro Debian-based.

Será necessário ter instalado os seguintes programas:

• Apache 2.2.x
• mod_proxy_balancer
• mongrel
• mongrel_cluster
• Ruby
• Rails

Preparando o terreno

Instalando o compilador GCC e as ferramentas de desenvolvimento

sudo apt-get install build-essential

E agora o Ruby

sudo apt-get install ruby ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8

Apache e seus módulos

Instalando Apache

sudo apt-get install apache2

Configurando os módulos necessários

sudo a2enmod proxy_balancer
sudo a2enmod proxy
sudo a2enmod proxy_connect
sudo a2enmod proxy_ajp
sudo a2enmod proxy_ftp
sudo a2enmod proxy_http
sudo a2enmod rewrite

Reiniciando o Apache para que os módulos sejam habilitados

sudo /etc/init.d/apache2 force-reload

MySQL

Primeiramente, instale o MySQL

sudo apt-get install mysql-server

E agora, instale os bindings do MySQL para o Ruby

sudo apt-get install libmysql-ruby1.8

RubyGems e Rails

Vamos baixar a última versão do RubyGems e instalar

wget http://rubyforge.org/frs/download.php/20585/rubygems-0.9.3.tgz
tar xvzf rubygems-0.9.3.tgz
cd rubygems-0.9.3
sudo ruby setup.rb

Agora, o Rails

sudo gem install rails -y

Mongrel e mongrel_cluster

Ao ser perguntado por qual versão instalar, escolha a versão mais nova, que não seja a mswin32

sudo gem install mongrel mongrel_cluster -y

Criando uma nova aplicação Rails e configurando o cluster

Vamos criar uma aplicação Rails para teste:

rails teste
cd teste

E agora, vamos configurar o cluster mongrel

mongrel_rails cluster::configure -e production -p 8000 -a 127.0.0.1 -N 3 -c /sua/app/rails/teste/

Esta linha escreverá um arquivo chamado mongrel_cluster.yml dentro da pasta config, configurando nosso cluster para rodar em modo de produção (-e production), começando na porta 8000 (-p 8000), no endereço 127.0.0.1 (-a 127.0.0.1) com 3 instâncias do mongrel (-N 3). Dessa maneira, nossas instâncias só estarão disponíveis para ser acessadas através da máquina local, não é necessário expor o mongrel para toda a internet, já que é apenas o Apache rodando na máquina local que deverá ter acesso à eles.

Agora, vamos colocar nosso mongrel como um serviço que iniciará junto com nosso sistema. Primeiro, vamos copiar o arquivo de inicialização que a gem do mongrel_cluster disponibiliza pra gente

sudo ln -s /usr/lib/ruby/gems/1.8/gems/mongrel_cluster-0.2.1/resources/mongrel_cluster /etc/init.d/
sudo chmod +x /etc/init.d/mongrel_cluster

Agora, vamos adicionar nosso script como um serviço do sistema

sudo /usr/sbin/update-rc.d mongrel_cluster defaults

O script de inicialização, procura por todos .yml dentre de: /etc/mongrel_cluster/, então, vamos criar este diretório e linkar nosso arquivo de configuração para lá

sudo mkdir -p /etc/mongrel_cluster
sudo ln -s /sua/app/rails/teste/config/mongrel_cluster.yml /etc/mongrel_cluster/teste.yml

Configurando o Apache

Vamos criar um novo VirtualHost no apache

touch /etc/apache2/sites-available/rails
sudo a2ensite rails

Use esta configuração para o arquivo que o apache acabou de criar em: /etc/apache2/sites-enabled/rails:

<VirtualHost *>
  ServerName exemplorails.com.br
  ErrorLog /sua/app/rails/teste/log/errors.log
  CustomLog /sua/app/rails/teste/log/apache.log combined
 
  <Directory "/sua/app/rails/teste/public/">
    Options FollowSymLinks
    AllowOverride None
    Order allow,deny
    Allow from all
  </Directory>
 
  RewriteEngine On
 
  # Check for maintenance file and redirect all requests
  #  ( this is for use with Capistrano's disable_web task )
  RewriteCond %{DOCUMENT_ROOT}/system/maintenance.html -f
  RewriteCond %{SCRIPT_FILENAME} !maintenance.html
  RewriteRule ^.*$ /system/maintenance.html [L]
 
  # Rewrite index to check for static
  RewriteRule ^/$ /index.html [QSA]
 
  # Rewrite to check for Rails cached page
  RewriteRule ^([^.]+)$ $1.html [QSA]
 
  # Redirect all non-static requests to cluster
  RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
  RewriteRule ^/(.*)$ balancer://mongrel_cluster%{REQUEST_URI} [P,QSA,L]
 
  # Deflate
  AddOutputFilterByType DEFLATE text/html text/plain text/css
  # ... text/xml application/xml application/xhtml+xml text/javascript
  BrowserMatch ^Mozilla/4 gzip-only-text/html
  BrowserMatch ^Mozilla/4.0[678] no-gzip
  BrowserMatch bMSIE !no-gzip !gzip-only-text/html
 
  <Proxy *>
    Order allow,deny
    Allow from all
  </Proxy>
 
  <Proxy balancer://mongrel_cluster>
    BalancerMember http://127.0.0.1:8000
    BalancerMember http://127.0.0.1:8001
    BalancerMember http://127.0.0.1:8002
  </Proxy>
 
</VirtualHost>

Finalização

Agora vamos reiniciar o apache

sudo /etc/init.d/apache2 force-reload

E iniciar nosso cluster mongrel

sudo /etc/init.d/mongrel_cluster start

Já podemos acessar nosso domínio, que nossa aplicação Rails deverá funcionar. Caso não funcione, dê uma olhada nos logs do Apache e de sua aplicação Rails.

Fonte:
Apache 2.2, mod_proxy_balancer, & Mongrel on Ubuntu 6.06
Time For A Grown-Up Server: Rails, Mongrel, Apache, Capistrano and You