1. Metaprogramming 101
Nando Vieira

3. codeplane.com.br

4. ode.c om.br
how toc

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

6. self
sempre será o receiver padrão.

7. person.name
!"#"$%"!

8. class User
attr_accessor :first_name, :last_name
def fullname
"#{first_name} #{last_name}"
end
end

9. class User
attr_accessor :first_name, :last_name
def initialize(options = {})
options.each do |name, value|
send("#{name}=", value)
end
end
end
User.new({
:first_name => "John",
:last_name => "Doe"
})

10. self
armazena as variáveis de instância.

11. class User
attr_accessor :first_name, :last_name
end
user = User.new
user.first_name = "John"
user.last_name = "Doe"
user.instance_variables
#=> ["@last_name", "@first_name"]

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

13. class Config
@directory = "/some/directory"
@environment = :production
end
Config.instance_variables
#=> ["@environment", "@directory"]

14. singleton_class
metaclasse, eigenclass, ghostclass.

15. class Config
class << self
end
end

16. RUBY 1.9
class Config
singleton_class.class do
# your code here
end
end

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

18. class Config
def self.root_dir
@root_dir
end
def self.root_dir=(dir)
@root_dir = dir
end
end

19. class Config
class << self
attr_accessor :root_dir
end
end

20. estendendo o self
adicionando novos métodos.

21. person = Object.new
def person.name
"John Doe"
end
person.name
#=> "John Doe"

22. person.singleton_methods
#=> ["name"]

23. estendendo o self
adicionando novos métodos em classes.

24. class Config
def Config.root_dir
"/some/path"
end
end
Config.root_dir
#=> "/some/path"

25. Config.singleton_methods
#=> ["root_dir"]

26. class Config
puts self == Config
end
#=> true

27. class Config
def Config.root_dir
"/some/path"
end
end
Config.root_dir
#=> "/some/path"

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

29. métodos
lookup + dispatching.

30. method lookup
up and right.

31. BasicObject class << BasicObject
Object class << Object
Module class << Module
Class class << Class
Person class << Person
person class << person
person.name

32. NoMethodError

33. method dispatching
execução de métodos.

34. person.name

35. person.send :name

36. person.send :say, "hello"

37. person.__send__ :name

38. person.public_send :name

39. class Person
attr_accessor :name, :age, :email
def initialize(options = {})
options.each do |name, value|
send("#{name}=", value)
"#{name}="
end
end
end

40. evaluation
class_eval, instance_eval,
instance_exec, eval.

41. class_eval
a.k.a. module_eval.

42. class Person; end
Person.class_eval do
puts self == Person
end
#=> true

43. class Person; end
Person.class_eval <<-RUBY
puts self == Person
RUBY
#=> true

44. class Person; end
Person.class_eval do
def self.some_class_method
end
def some_instance_method
end
end

45. class Person; end
module Helpers
# some code here
end
Person.class_eval do
include Helpers
end

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

47. class Person
class_eval <<-RUBY, __FILE__, __LINE__
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

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

49. 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

50. instance_exec
a.k.a. instance_eval on redbull.

51. 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

52. eval
evaluation com contexto configurável.

53. 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"

54. hooks
interceptando eventos do Ruby.

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

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

57. 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

58. class Person
include Ffffffuuu
end
Person.singleton_class.included_modules
#=> [Ffffffuuu::ClassMethods, Kernel]
Person.included_modules
#=> [Ffffffuuu::InstanceMethods, Ffffffuuu, Kernel]

59. métodos
method_added, method_missing,
method_removed, method_undefined,
singleton_method_added,
singleton_method_removed,
singleton_method_undefined

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

61. 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

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

63. 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

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

65. DSLs
fuckyeah.

66. interfaces fluentes
chaining.

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

68. class Message
def to(name)
@to = name
self
end
def from(name)
@from = name
self
end
def text(message)
@text = message
self
end
end

70. module FluentAttribute
def fluent_attr(*names)
names.each do |name|
class_eval <<-RUBY, __FILE__, __LINE__
def #{name}(value) # def to(value)
@#{name} = value # @to = value
self # self
end # end
RUBY
end
end
end

71. class Message
extend FluentAttribute
fluent_attr :from, :to, :text
end

72. dúvidas?

73. obrigado
http://nandovieira.com.br.