Melhorando o “try()” do Ruby, a maneira “Groovy” [parte final]

class Omega
        def a
                self
        end
        def b
                self
        end
        def c
                self
        end
        def to_s
                "Omega"
        end
end

def da? 
        begin
                yield() if block_given?
        rescue => exc
                nil
        end
end

xyz = nil
a = da? { xyz.a.b.c } 

xyz = Omega.new
b = da? { xyz.a.b.c } 

puts "da? com nil -> '#{a}'"
puts "da? com Omega -> '#{b}'"

Executando:

da? com nil -> ''
da? com Omega -> 'Omega'

O que eu fiz? como a expressão xyz.a.b.c poderia retornar algum erro pois um dos métodos poderia returnar nil, bastaria executar em um bloco de código com a ajuda do método da? (péssimo nome, uma corruptela de "da para executar sem erro? se não, me retorna nil e era wilson...), que captura qualquer erro e some com ele.

Ruby é divertido. :)

ps: teste com

a = da? { xyz.a.b.c } || "nao deu..."

Melhorando o “try()” do Ruby, a maneira “Groovy” [parte 2]

Vou pedir perdão ao meu amigo Urubatan, que publicou um artigo de mesmo nome.

class Omega
   def doIt
     puts "ola"
     self
   end
end

class NullableClass
   def method_missing(*x)
      self
   end
end

class Object
   def existe?
      self
   end
end

class NilClass
   def existe? 
      NullableClass.new 
   end
end

xyz = Omega.new 
xyz . existe? . doIt . doIt

abc = nil
abc . existe? . doIt . doIt

Estou em duvida sobre o nome do metodo, por enquando fica existe? mesmo.

O que isso faz? Imagine que vc tem uma variavel ou atributo de classe que pode ser nil. Se for nil ela vai lançar um um erro em tempo de execução quando vc for tentar chamar algum método que a NilClass não possua (o que geralmente acontece, é semelhante ao NullPointerException do java).

Eu poderia resolver isso alterando o method_missing da NilClass, porém alguns scripts podem estar esperando erros desse tipo. Decidi então criar um método que, para qualquer objeto, retorna ele mesmo (self). Caso seja nil, ele vai retornar um NullableClass (outro nome infeliz, não tenho nenhuma ideia melhor) que simplesmente retorna ele para qq método requisitado.

IMHO pode ser o suficiente quando queremos fazer um teste simples: o objeto é nil? então não faz nada.

Se alguem achar isso util por favor me avise :)

Ah sim, a execução do script acima resulta em:

ola
ola

Ruby e o method_missing

Os objetos em Ruby possuem um método chamado 'respond_to?' para verificar se o objeto possui (ou melhor, se ele responde a) um determinado método. Em uma linguagem dinâmica como o ruby, onde podemos incluir um método numa classe em runtime, é um recurso muito necessário, ainda mais se pensarmos em termos de Duck Typing.

Em caso de dúvida, basta fazer um if, afinal chamar um método que não existe causa um NoMethodError, certo?

Depende. Observe:

class A
        def xxx()
                puts "xxx"
        end
        def method_missing(m, *args)
                puts "nao tenho esse metodo: #{m}"
        end
end

a = A.new
a.xxx
# aqui normalmente daria erro e o script seria abortado 
# sem o rescue adequado
a.yyy 

Resultado:

~> ruby A.rb
xxx
nao tenho esse metodo: yyy

Eu sobreescrevi o método 'method_missing', que como o próprio nome indica, intercepta uma chamada a um método inexistente. Divertido, não?

Ruby e suas travessuras

irb(main):001:0> def some(thing)
irb(main):002:1>    puts "some#{thing}"
irb(main):003:1> end
=> nil
irb(main):004:0> some "thing"
something
=> nil
irb(main):005:0> some = "thing"
=> "thing"
irb(main):006:0> some(some)
something
=> nil

Curso de Ruby on Rails em Porto Alegre

Uma oportunidade imperdível!

A Tech Office IT realiza no período de 24 a 28 de setembro de 2007 em Porto Alegre, o curso presencial Ruby on Rails, voltado a desenvolvedores Ruby que desejam conhecer mais sobre Rails e desenvolvedores de outras linguagens que tenham interesse em ingressar no RoR. O curso objetiva auxiliar o aluno a entender o Ruby on Rails e possibilitar a criação de aplicações o utilizando, além de expor suas vantagens e limitações.

Após o curso o aluno estará apto a desenvolver aplicações WEB utilizando o Ruby On Rails, saberá onde procurar mais recursos para acelerar o desenvolvimento e adicionar recursos na aplicação desenvolvida.

Com carga horária de 20 horas/aula, o treinamento será 100% prático e ministrado em laboratório. Durante o curso, os participantes desenvolverão uma loja de DVDs completa que poderá ser utilizada como exemplo ou como base para o desenvolvimento de uma aplicação mais complexa pós-curso. Mais informações poderão ser obtidas através do site www.techoffice.com.br ou e-mail contato (at) techoffice (.) com (.) br, além do telefone 51.3012.8241.

Mais detalhes sobre o curso de Ruby on Rails

Clique aqui para se inscrever no curso de Ruby On Rails

Se alguem não sabe o poder do Ruby on Rails, veja esse video:

Conheça o Incrível Ruby on Rails

Ruby é uma linguagem interpretada orientada à objetos que vem aparecendo no mercado faz tempo. Sua popularidade vem subindo graças ao framework on Rails, que pode acelerar, e muito, o desenvolvimento de aplicações para a web.

Gostou da demonstração? O ponto de partida para um entusiasta pode ser o Ruby on Br, com alguns bons artigos e um forum que une os melhores profissionais no ramo.

Dê uma olhada nos tutoriais do Taq e, se gostar, compre o livro (é muito bom, recomendo). Outro livro muito bom é o do Akita (responsável pela tradução do livro Getting Real by 37 Signals para pt_BR).

Embarque nessa vc também!

Closures em Shell

Uma das coisas mais impressionantes (pelo menos para mim) da linguagem Ruby são os Closures:

$ ruby -e 'r=0...3 ; r.each { puts "oi"}
oi
oi
oi

em um objeto do tipo Range eu tenho um método chamado each que recebe um bloco de código como argumento. Este bloco pode até ser parametrizado, por exemplo:

$ ruby -e 'r=0...3 ; r.each { |i| puts 2*i}'
0
2
4

O que o metodo each faz é passar este bloco de código para 'dentro de si' e aplica-o em cada elemento do objeto 'range'. Pode ser para imprimir o resultado ou efetuar uma operação matemática, até mesmo substituindo um laço for simples. A verdade é que os Closures são bem mais do que isso e permitem fazer scripts bem interessantes.

Sera que poderiamos ter o mesmo em BashScript ? Bem... vou simular aqui

$ each(){ 
  local F="${@}" 
  while read i ; do 
     set - $i 
     eval "${F}" 
  done 
}

$ seq 3 | each '{ echo "encontrei $1" ; }'
encontrei 1
encontrei 2
encontrei 3

Simples heim? Eu crio uma variavel local dentro de uma função e 'executo-a' para cada resultado via comando eval. Se este tipo de construção for util para alguem, fica aí a dica!