Ruby
muito mais do que reflexivo!
fabio.kung@caelum.com.br

Reflexão
p = Person.new
p.class
# => Person
p.methods
# => [\"instance_variables\", \"class\", ..., \"to_s\"]
Person.instance_methods
# => [\"instance_variables\", ..., to_s\"]

Dinamismo

Metaprogramação

Metaprogramação
class Aluno
end
marcos = Aluno.new
marcos.respond_to? :programa # => false
class Professor
def ensina(aluno)
def aluno.programa
\"puts 'agora sei programar'\"
end
end
end
knuth = Professor.new
knuth.ensina marcos
marcos.respond_to? :programa
# => true
marcos.programa
# => \"puts 'agora sei programar'\"

“Skilled programmers can write
better programmers than they can
hire”
-- Giles Bowkett

Code as Data

User.detect { |u| u.name == 'John' && u.age == 22 }
# SELECT * FROM users WHERE users.name = 'John' AND users.age = 22
User.select { |u| [1, 2, 3, 4].include? u.id }
# SELECT * FROM users WHERE users.id IN (1,2,3,4)

ParseTree
class
class Person Person nil scope
def say_hi defn
puts \"hi\" say_hi scope
args
end block
end call
nil puts arglist
str
“hi”

ParseTree
s(:class,
:Person,
class Person nil,
s(:scope,
def say_hi s(:defn,
:say_hi,
puts \"hi\" s(:args),
end s(:scope,
s(:block,
end s(:call,
nil,
:puts,
s(:arglist,
s(:str,
\"hi\"))))))))

Feedback
Editores/IDEs

class
nil scope
Person
defn
say_hi args scope
block
require 'parse_tree' call
puts
nil arglist
tree = ParseTree.new.process(...)
tree[0][2][0][2] str
“hi”
# => s(:scope,
s(:block,
s(:call,
nil, :puts, s(:arglist, ...))))

SexpProcessor
class TheProcessor < SexpProcessor
def process_call(node)
# ...
process node
end
def process_class(node)
# ...
process node
end
def process_scope(node)
# ...
process node
end
end

SexpProcessor
class TheProcessor < SexpProcessor
def process_call(node)
# ...
ast = ParseTree.new.process(...)
process node
new_ast = TheProcessor.new.process(ast)
end
def process_class(node)
# ...
process node
end
def process_scope(node)
# ...
process node
end
end

class
nil scope
Person
defn
say_hi args scope
block
class RenameProcessor < SexpProcessor
call
def process_defn(node) puts
nil arglist
name = node.shift
str
args = process(node.shift)
scope = process(node.shift) “hi”
s(:defn, :\"new_#{name}\", args, scope)
end
end

Flog
Flog shows you the most
torturous code you wrote. class Test
def blah # 11.2 =
The more painful the a = eval \"1+1\" # 1.2 + 6.0 +
code, the higher the score. if a == 2 then # 1.2 + 1.2 + 0.4 +
The higher the score, the puts \"yay\" # 1.2
end
harder it is to test. end
end

roodi
Ruby Object Oriented Design Inferometer
• ClassLineCountCheck
• ClassNameCheck
• CyclomaticComplexityBlockCheck
• CyclomaticComplexityMethodCheck
• EmptyRescueBodyCheck
• MethodLineCountCheck
• MethodNameCheck
• ParameterNumberCheck
• ...

merb-action-args
class Posts < Merb::Controller
def create(post)
# post = params[:post]
@post = Post.new(post)
@post.save
end
# ...
end

Heckle
Think you write good
tests? Not bloody likely...
Put it to the test with
heckle. It’ll put your
code into submission in
seconds.

Outros
• Reek (== roodi)
• Flay
• Rufus
• ...

Ambition
User.select { |u| u.name == 'John' && u.age == 22 }
# SELECT * FROM users WHERE users.name = 'John' AND users.age = 22
# \"(&(name=jon)(age=21))\"

Ambition
User.select { |u| u.name == 'John' && u.age == 22 }
# SELECT * FROM users WHERE users.name = 'John' AND users.age = 22
# \"(&(name=jon)(age=21))\"
User.select { |u| [1, 2, 3, 4].include? u.id }
# SELECT * FROM users WHERE users.id IN (1,2,3,4)

Ambition
User.select { |u| u.name == 'John' && u.age == 22 }
# SELECT * FROM users WHERE users.name = 'John' AND users.age = 22
# \"(&(name=jon)(age=21))\"
User.select { |u| [1, 2, 3, 4].include? u.id }
# SELECT * FROM users WHERE users.id IN (1,2,3,4)
User.select { |u| u.friends.name =~ /bi/ }
# SELECT * FROM users LEFT OUTER JOIN ... WHERE friends.name ~ 'bi'

Ambition
User.select { |u| u.name == 'John' && u.age == 22 }
# SELECT * FROM users WHERE users.name = 'John' AND users.age = 22
# \"(&(name=jon)(age=21))\"
User.select { |u| [1, 2, 3, 4].include? u.id }
# SELECT * FROM users WHERE users.id IN (1,2,3,4)
User.select { |u| u.friends.name =~ /bi/ }
# SELECT * FROM users LEFT OUTER JOIN ... WHERE friends.name ~ 'bi'
User.select { |u| ... }.sort_by { |u| u.name }
# SELECT * FROM users WHERE ... ORDER BY users.name

ParseTree Manipulation
http://martinfowler.com/dslwip/ParseTreeManipulation.html

Rfactor
$$$
class Banco
def transfere(origem, destino, valor)
s(:class, puts \"iniciando transferencia\"
:Banco, puts \"por favor, aguarde...\"
nil, # ...
s(:scope, end
s(:block,
s(:defn, def incrementa_juros(taxa)
:transfere, # ...
s(:args, :origem, :destino, :valor),end
s(:scope, end
s(:block,
s(:call, nil, :puts, s(:arglist, s(:str, \"iniciando transferencia\"))),
s(:call, nil, :puts, s(:arglist, s(:str, \"por favor, aguarde...\")))))),
s(:defn,
:incrementa_juros,
s(:args, :taxa),
s(:scope,
s(:block, s(:nil)))))))

Ruby2Ruby
var bloco = function() {
alert(\"hey, I'm a function\");
}
bloco.toString();

Ruby2Ruby
var bloco = function() {
alert(\"hey, I'm a function\");
}
bloco.toString();
bloco = lambda do
puts \"hey, I'm a block\"
end
bloco.to_ruby
# => \"proc { puts(\\\"hey, I'm a block\\\") }\"

metaprogramação: como fica
o código gerado?

serialização de código

require 'mapreduce_enumerable'
(1..100).to_a.dmap do |item|
item * 2
end
http://romeda.org/blog/2007/04/mapreduce-in-36-lines-of-ruby.html

Ofuscação

Ruby2Java

Ruby2Java

• rb2js: http://rb2js.rubyforge.org
• red-js: http://wiki.github.com/jessesielaff/red

JRuby
compiler2.rb

Geradores
• Gráficos
• UML
• ...

Código Nativo
(problema)
• ruby_parser
• Ripper (1.9)
• JRuby ParseTree

Dúvidas?
Obrigado!
fabio.kung@caelum.com.br
http://fabiokung.com
twitter: fabiokung