Por curiosidade, resolvi tentar descobri todas as maneiras possíveis de se executar um loop com Ruby, e tentarei lista-las aqui.

While

Loops do tipo While no Ruby são exatamente iguais aos encontrados em Java, C# e outros. Um bloco deve ser executado enquanto uma condição for verdadeira.

x = 1
while(x <4)
	puts x
	x +=1
end

=> 1
   2
   3

O while também pode ser usado ao final de um bloco, de maneira semelhando ao “DO…WHILE” de outras linguagens.

x =1
begin
	puts x
	x+=1
end while (x<4)

=> 1
   2
   3

Irmão inverso do while, o until executa um bloco de código até que uma condição seja verdadeira.

x = 1
until(x>3)
  puts x
  x +=1
end

=> 1
   2
   3

E, como no while, também pode ser usado como condição de execução ao fim de um bloco.

x = 1
begin
  puts x
  x+=1
end until (x>3)

=> 1
   2
   3

For

Outro loop clássico das linguagens, o for assume algumas particularidades no Ruby. Os ranges de Ruby podem ser usados em um for. Tanto na versão “intervalo aberto e fechado”.

#Intervalo aberto
for i in 1..3
  puts i
end

=> 1
   2
   3
#Intervalo fechado
for i in 1...4
  puts i
end

=> 1
   2
   3

Além disso, podemos iterar sobre letra do alfabeto, como no exemplo abaixo:

for x in 'a'..'d'
  puts x
end

=> a
   b
   c
   d

Iteradores

O iterator, é um padrão de projeto que nos permite percorrer objetos agregados sem que sua verdadeira relação com o grupo ao qual pertence seja exposto. Ruby já fornece o padrão iterator através do método each.

[1,2,3].each do |i|
  puts i
end

=> 1
   2
   3

Que também pode ser usado com ranges:

(1..3).each do |i|
  puts i
end

=> 1
   2
   3

Métodos da Classe Fixnum

As opções não param nas citadas acima. Ainda temos alguns métodos da flasse Fixnum que nos fornecem comportamentos semelhante aos loops clássicos.

O método Fixnum#times recebe um bloco como parâmetro, e o executa o mesmo número de vezes do objeto Fixnum que o executou.

i = 1
3.times do
  puts i
  i+=1
end

=> 1
   2
   3

Temos também os métodos upto e downto que, como o times, também recebe um bloco e o executa, porém com um objeto de índice do bloco.

1.upto(3) {|i| puts i}

=> 1
   2
   3

3.downto(1) {|i| puts i}

=> 3
   2
   1

Outras Esquisitices

Em Ruby também temos um loop infinito, semelhante a um while(true), que deve ser quebrado mediante alguma condição definida dentro do bloco de execução. Um exemplo prático poderia ser uma verificação de senha via linha de comando:

loop do
  puts "Enter your password"
  gets
  chomp
  break if $_ =="123"
  puts "WRONG! Try again!"
end

E por fim, algumas malandragens típicas do Ruby. Como eu usei o mesmo exemplo em todo esse post, aqui vão algumas outras maneiras de imprimir na tela os números:

puts (1..3).to_a* "\n"

puts (1..3).to_a

puts *(1..3)

puts 1,2,3

Será que eu me esqueci de algum?

Pois há dois dias atrás aconteceu, o Delicious sofreu reformulações e a implementação que eu tinha foi pro espaço.

Já consertei todos os problemas e consegui implementar já algumas funções novas, como a busca por “Fresh links” que retornam páginas mais atuais, seguindo a tendência de instant search que anda sendo discutida bastante atualmente. Algumas features novas ainda não foram mapeadas, mas estas não afetam o funcionamento das atuais.

Hoje eu dei um push das correções pro Github e atualizei o readme para quem quiser usar. O código atualizado pode ser encontrado aqui:
http://github.com/tbueno/delicious-ext/tree/master

O exemplo anterior se resumia a simples GETs Http, mas nós sabemos que aplicações web são muito mais que isso, não é?

Então vamos ao que interessa.

Pré-Requisitos e Preparativos

Será necessário a instalação do sqlite3 em seu computador. Os passos para fazer isso fogem do escopo deste tutorial, mas você não encontrará dificuldades para esse procedimento(usuários de mac não precisam). Após a instalação, crie via linha de comando uma database, como no exemplo abaixo:

sqlite3 blue_eyes

SQLite version 3.4.0
Enter “.help” for instructions
sqlite> .quit

Usaremos algumas gems para nao reinventarmos a roda:

- sinatra – Nosso tão amado e querido micro-framework
- feedzirra – Parsing de RSS
- sequel – Para gerenciamento simples do sqlite com ruby – http://sequel.rubyforge.org
- Haml – Linguagem de marcação para nossos templates

Após instalarmos cada uma das gems necessárias, começaremos o desenvolvimento da aplicação.

Leitor de RSS Feito Totalmente em Ruby!

O idéia é criar um leitor de RSS básico, com as features mínimas necessárias para o seu funcionamento. Melhorias futuras serão tratadas em outros posts. Para que possamos gerenciar nossos feeds, criaremos um Model simples, representando objetos “feed”. Percebam que, assim como os conhecidos exemplos do ActiveRecord usado no Rails, aqui a gente também extende uma classe model do nosso framework de acesso ao BD, o Sequel. É possível notar também a semelhança com um Migration na definição do schema da tabela.

./feed.rb

class Feed < Sequel::Model
  unless table_exists?
      set_schema do
        primary_key :id
        text :url
        text :name
      end
      create_table
    end
end

Pronto. Nosso Model já está pronto, agora vamos para o Controller. Como essa é uma implementação bem simples, usaremos apenas a raiz do site para apresentar o conteúdo. Isso pode ser comprovado nos GETS que esperam apenas um parâmetro, no caso o "id" do feed no nosso banco.

./blue_eyes.rb

require 'sinatra'
require 'feedzirra'
require 'sequel'

configure do
  Sequel.sqlite('blue_eyes.db')
end
require 'feed'

get '/style.css' do
   content_type 'text/css', :charset => 'utf-8'
   sass :style
end

get '/' do
   @feeds = Feed.all
     @feed = Feedzirra::Feed.fetch_and_parse("http://www.tbueno.com/blog/feed/")
   haml :index
end

get '/:id' do
    @feeds = Feed.all
    @model = Feed.find(:id => params[:id])
    @feed = Feedzirra::Feed.fetch_and_parse(@model.url)
    haml :index
end

post '/add_feed' do
  f = Feedzirra::Feed.fetch_and_parse(params[:feed_url])
  feed = Feed.new(:url => f.feed_url, :name => f.title)
  feed.save
  redirect '/'
end

Outra novidade em relação ao tutorial anterior é o uso do "configure", que é uma espécie de "initializer" do Rails e é executado, como o nome diz, apenas uma vez no início. Usaremos ele para conectarmos ao nosso banco.

O uso de POST Http foi adicionado para que possamos adicionar feed usando um form simples que recebe a url do feed a ser adicionado.

Camada de Apresentação com Haml e Sass

Como no tutorial anterior, usaremos o Haml e o Sass para geração de HTML e CSS respectivamente. Como esta é uma aplicação pequena, acho que fica interessante usarmos estas ferramentas para demonstrar como fica limpa a parte de apresentação usando elas.

./views/index.haml

%html
  %head
    %title Blue Eyes
    %meta{"http-equiv" => "Content-Type", :content=>"text/html; charset=UTF-8"}
    %link{:rel => 'stylesheet', :type =>'text/css', :href => 'style.css' }
  %body
    #menu
      %form{:action => 'add_feed', :method => 'post', :name => 'add_feed'}
        %input{:type =>'text', :name => 'feed_url', :id => 'feed_url' }
        %input{:type => 'submit', :value => 'Add Feed'}
      %ul
        - @feeds.each do |f|
          %li
            %a{:href => "/#{f.id}"}
              = f.name
    #content
      .feed
        %h1
          %a{:href => @feed.url}
            = @feed.title
        - @feed.entries.each do |entry|
          .entry
            %h2
              %a{:href => entry.url}
                = entry.title
            = entry.content

Sempre é bom lembrar que a identação é FUNDAMENTAL no Haml, portanto, preservem-na caso vocês forem copiar e colar estes códigos.

./views/style.sass

body
  :background-color #f0f0f0

a
  :color #B84300
  :text-decoration none

h2
  :font normal 1.2em/1.3em arial
  :margin 0
  :padding 0

.entry
  :border 1px solid #888
  :background #f9f9f9
  :padding 10px
  :width 90%
  :margin-bottom 1em

#content
  :float left
  :width 70%
  :margin 0px 0px 50px 0px
  :overflow auto

#menu
  :float left
  :width 25%
  :overflow auto
  :border 1px solid #888
  :margin-right 10px

Screenshot:

Trabalhos Futuros

Obviamente, este exemplo não é uma aplicação completamente funcional. Ele serve mais como um exemplo de como explorar os recursos do Sinatra, mas como eu me diverti fazendo ele, logo tive a idéia de criar um projeto no Github para continuar o desenvolvimento. Sintam-se a vontade para clonar o projeto e sugerir melhorias. Existe uma lista de coisas que precisam ser melhoradas que incluem gerenciamento otimizado de feeds, caches, controle de datas para que os feeds não precisem ser buscados externamente a cada refresh, etc...

Essa ploriferação do mal, fez com que o Google começasse a aprimorar a parte de segurança do site, tornando ele hoje um dos sub-sites do conglomerado mais difíceis de se acessar por vias “automatizadas”.

Mas que tipo de informação seria possível de obter do site?

Acessando o Orkut com Ruby

Uma das medidas adotadas pelo Google para evitar os bots que atazanavam a vida de todos, foi a adoção de chamadas via Ajax, muito mais difíceis de ser capturadas e entendidas. Passei um bom tempo tentando entender o fluxo de dados de login, através do firebug, mas sempre esbarrava em arquivos javascript como esse, obviamente ofuscados de propósito.

Antigamente, alguns já haviam conseguido quebrar o Orkut com Ruby e scraping, mas hoje os mesmos métodos não funcionam mais.

A solução encontrada para evitar as chamadas com Ajax foi acessar o “lado sem javascript” do site, no caso, a interface para dispositívos móveis do site.

De cara, me deparei com a tela de login comum nos serviços do Google – que inclusive já possui uma api para Ruby. Como o Orkut não faz parte dos serviços cobertos pela API oficial, tive que preencher o formulário de login usando o Mechanize.

require 'mechanize'
require 'hpricot'

agent = WWW::Mechanize.new
page = @agent.get "https://www.google.com/accounts/ServiceLogin?service=orkut&hl=en-US&rm=false&continue=http%3A%2F%2Fm.orkut.com%2FRedirLogin%3Fmsg%3D0%26page%3Dhttp%253A%252F%252Fm.orkut.com%252FHome&cd=US&nui=5&btmpl=mobile&ltmpl=mobile&passive=true&skipvpage=true&sendvemail=false"

form = page.forms.first
form.Email = @email
form.Passwd = @pass
page = @agent.submit form

Não se assustem com a URL gigantesca. Ela é mostrada quando você tenta acessar algum serviço privado sem estar logado. Após o login, o site gerará uma URL intermediária de autenticação antes de redirecionar para a home do usuário propriamente dita. Esse fluxo é reproduzido da seguinte maneira:

#Call home page to get the temporary URL that google generates
page = @agent.get "http://m.orkut.com/Home"
#Try to access the temporary URL to pass the authentication token
page = @agent.get page.meta[0].uri.to_s

Lendo os Scraps Recebidos Usando Ruby

Após os passos anteriores, conseguiremos acesso ao conteúdo da página. Depois, é só questão de mandar ver no scraping para obter as informações necessárias.

O código final é mostrado abaixo, e também pode ser acessado no gist. Sempre é bom lembrar que ele foi feito às pressas e está sujeito a erros e melhorias.

require 'mechanize'
require 'hpricot'

class Orkut

  def initialize(email, pass)
    @agent = WWW::Mechanize.new
    @email = email
    @pass = pass
  end

  def print_scraps
    page = scrap_page
    scraps = page.search "div[@class='mblock']/div"
    scraps.each do |l|
      parts = Hpricot(l).inner_html.split("\n")
      puts "Name: #{parts[1]}"
      puts "Date: #{parts[3]}"
      puts "Message: "
      parts[4..parts.size-2].each {|line| puts line}
      puts "-" * 50
   end
  end

  private

  def scrap_page
    log_in
    #Call home page to get the temporary URL that google generates
    page = @agent.get "http://m.orkut.com/Home"
    #Try to access the temporary URL to pass the authentication token
    page = @agent.get page.meta[0].uri.to_s
    #Now, with authentication ready we can access the content
    page = @agent.get "http://m.orkut.com/Scrapbook"
  end

  def log_in
    page = @agent.get "https://www.google.com/accounts/ServiceLogin?service=orkut&hl=en-US&rm=false&continue=http%3A%2F%2Fm.orkut.com%2FRedirLogin%3Fmsg%3D0%26page%3Dhttp%253A%252F%252Fm.orkut.com%252FHome&cd=US&nui=5&btmpl=mobile&ltmpl=mobile&passive=true&skipvpage=true&sendvemail=false"

    form = page.forms.first
    form.Email = @email
    form.Passwd = @pass
    page = @agent.submit form
  end
end

o = Orkut.new('your_email@gmail.com', 'your_pass')
o.print_scraps

Silogismo Aristotélico

O silogismo consiste no fato de duas premissas inferirem, através de um termo em comum, na conclusão de uma terceira premissa também verdadeira.

“Todos os humanos são mortais”
“Aristóteles é humano”
-
“Logo, Aristóteles é mortal”

#Todos os humanos são mortais
class Human
	self.module_eval do
  	define_method :mortal? do
    	true
	  end
 	end
end

#Aristóteles é humano
class Aristotle < Human
end

#logo...
a = Aristotle.new
a.mortal?     #=> true

Lógica Proposicional

Segundo o wikipedia:

Em lógica e matemática, uma lógica proposicional (ou cálculo sentencial) é um sistema formal no qual as fórmulas representam proposições que podem ser formadas pela combinação de proposições atômicas usando conectivos lógicos, e um sistema de regras de derivação que permite que certas fórmulas sejam estabelecidas como “teoremas” do sistema formal.

Dessa, os teoremas clássicos que me veem à cabeça são os seguintes:

Dupla eliminação da negação

#De ¬¬p, infere-se p
p = true
(not (not p))   #=> true

Modus ponens (eliminação do condicional)

#De p, (p → q), infere-se q.
p = true
if (p) and ( q = p);end
q            #=> true

Exercícios de lógica

Uma das coisas que me divertia antes da faculdade eram as tabelas-verdades, aonde era possível analisarmos uma fórmula para descobrir se ela era válida ou não. Um bom exercício para o cérebro é tentar descobrir se o resultado de uma fórmula é verdadeiro ou falso. Qual o resultado da expressão abaixo?

p = false
q = true
r = false

(!(q & p) &(r | q) | !((p & r) |(r & q)))