Metaprogramming 101

Metaprogramming 101
Nando Vieira

O que veremos
object model, method dispatching,
evaluation, hooks, DSLs.

self
sempre será o receiver padrão.

class User
attr_accessor :first_name, :last_name

def fullname
"#{first_name} #{last_name}"
end
end

class User

def initialize(options = {})
options.each do |name, value|
send("#{name}=", value)
end
end
end

User.new({
:first_name => "John",
:last_name => "Doe"
})

self
armazena as variáveis de instância.

class User
end

user = User.new
user.first_name = "John"
user.last_name = "Doe"

user.instance_variables
#=> ["@last_name", "@first_name"]

variáveis de instância
isso se aplica a todos os objetos.

class Config
@directory = "/some/directory"
@environment = :production
end

Config.instance_variables
#=> ["@environment", "@directory"]

singleton_class
metaclasse, eigenclass, ghostclass.

class Config
class << self
end
end

RUBY 1.9

class Config
singleton_class.class do
# your code here
end
end

RUBY 1.8

class Object
unless Object.respond_to?(:singleton_class)
def singleton_class
class << self; self; end
end
end
end

class Config
def self.root_dir
@root_dir
end

def self.root_dir=(dir)
@root_dir = dir
end
end

class Config
class << self
attr_accessor :root_dir
end
end

estendendo o self
adicionando novos métodos.

person = Object.new

def person.name
"John Doe"
end

person.name
#=> "John Doe"

person.singleton_methods
#=> ["name"]

estendendo o self
adicionando novos métodos em classes.

class Config
def Config.root_dir
"/some/path"
end
end

Config.root_dir
#=> "/some/path"

Config.singleton_methods
#=> ["root_dir"]

class Config
puts self == Config
end

#=> true

métodos de classe
eles não existem no Ruby.

métodos
lookup + dispatching.

BasicObject class << BasicObject

Object class << Object

Module class << Module

Class class << Class

Person class << Person

person class << person

person.name

method dispatching
execução de métodos.

class Person
attr_accessor :name, :age, :email

def initialize(options = {})
options.each do |name, value|
send("#{name}=", value)
"#{name}="
end
end
end

evaluation
class_eval, instance_eval,
instance_exec, eval.

class_eval
a.k.a. module_eval.

class Person; end

Person.class_eval do
puts self == Person
end

#=> true

class Person; end

Person.class_eval <<-RUBY
puts self == Person
RUBY

#=> true

class Person; end

def self.some_class_method
end

def some_instance_method
end
end

class Person; end

module Helpers
# some code here
end

include Helpers
end

class Person
class_eval <<-RUBY, __FILE__, __LINE__
def some_method
# some code
end
RUBY
end

class Person
def some_method
raise "ffffuuuuuuuuuu"
end
RUBY
end

begin
Person.new.some_method
rescue Exception => error
error.backtrace
# ["person.rb:3:in `some_method'", "person.rb:10"]
end

instance_eval
a.k.a. class_eval para instâncias.

Person = Class.new
person = Person.new

Person.respond_to?(:class_eval) #=> true
Person.respond_to?(:instance_eval) #=> true

person.respond_to?(:class_eval) #=> false
person.respond_to?(:instance_eval) #=> true

instance_exec
a.k.a. instance_eval on redbull.

require "ostruct"

john = OpenStruct.new(:name => "John Doe")

block = proc do |time = nil|
puts name
puts time
end

john.instance_eval(&block)
#=> John Doe
#=> #<OpenStruct name="John Doe">

john.instance_exec(Time.now, &block)
#=> John Doe
#=> 2011-07-08 11:44:01 -0300

eval
evaluation com contexto conﬁgurável.

def get_binding
name = "John Doe"
binding
end

eval("defined?(name)")
#=> nil

eval("defined?(name)", get_binding)
#=> "local-variable"

eval("name", get_binding)
#=> "John Doe"

hooks
interceptando eventos do Ruby.

módulos & classes
included, const_missing, extended,
inherited, initialize_clone,
initialize_copy, initialize_dup.

included
executado toda vez que um módulo é
incluído.

module Ffffffuuu
def self.included(base)
base.class_eval do
include InstanceMethods
extend ClassMethods
end
end

module InstanceMethods
# some instance methods
end

module ClassMethods
# some class methods
end
end

class Person
include Ffffffuuu
end

Person.singleton_class.included_modules
#=> [Ffffffuuu::ClassMethods, Kernel]

Person.included_modules
#=> [Ffffffuuu::InstanceMethods, Ffffffuuu, Kernel]

métodos
method_added, method_missing,
method_removed, method_undeﬁned,
singleton_method_added,
singleton_method_removed,
singleton_method_undeﬁned

method_missing
executado toda vez que um método não
for encontrado.

class Logger
attr_accessor :output

LEVELS = [
:debug, :info, :warn, :error, :critical
]

def initialize(output)
@output = output
end

def log(level, message)
output << "[#{level}] #{message}n"
end
end

logger = Logger.new(STDOUT)
logger.log :debug, "Fffffuuuuu"

class Logger
attr_accessor :output

LEVELS = [
:debug, :info, :warn, :error, :critical
]

def initialize(output)
@output = output
end

def log(level, message)
output << "[#{level}] #{message}n"
end

def method_missing(name, *args, &block)
return send(:log, name, args.first) if LEVELS.include?(name)
super
end
end

def respond_to?(method, include_private = false)
return true if LEVELS.include?(method.to_sym)
super
end

interfaces ﬂuentes
chaining.

@message = Message.new
@message.to("john").from("mary").text("bring milk.")
@message.deliver
#=> "mary said: john, bring milk."

class Message
def to(name)
@to = name
self
end

def from(name)
@from = name
self
end

def text(message)
@text = message
self
end
end

module FluentAttribute
def fluent_attr(*names)
names.each do |name|
def #{name}(value) # def to(value)
@#{name} = value # @to = value
self # self
end # end
RUBY
end
end
end

class Message
extend FluentAttribute

fluent_attr :from, :to, :text
end

obrigado
http://nandovieira.com.br.

Metaprogramming 101

More Related Content

What's hot

Viewers also liked

Similar to Metaprogramming 101

Recently uploaded

Metaprogramming 101