Metaprogramming

Object Model and
Metaprogramming in
Ruby
Monday, November 1, 2010

Santiago Pastorino
@spastorino

Ruby
Rails

Java get/set version 1
public class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

.NET get/set version 1
class User
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
}

Ruby get/set version 1
class User
def name
@name
end
def name=(value)
@name = value
end
end

Java get/set version 2
?public property String name;

.NET get/set version 2
class User
{
public string Name { get; set; }
}

Ruby get/set version 2
The right way
class User
attr_accessor :name
end

Metaprogramming

Metaprogramming
“Metaprogramming is writing code that
writes code.”

Metaprogramming
writes code.”
manipulates language constructs at runtime.”

Metaprogramming
• Classes are always open
• Everything is an Object even classes and
modules
• All methods calls have a receiver

Classes are Open
class Hash
def except!(*keys)
keys.each { |key| delete(key) }
self
end
end
hsh = {:a => 1, :b => 2}
hsh.except!(:a) # => {:b => 2}

Everything is an Object
class User
puts self # => User
puts self.class # => Class
end
User.methods.grep /get/
=> [:const_get,
:class_variable_get,
:instance_variable_get]

All method calls have a
receiver
class User
attr_accessor :name
end

Metaprogramming
•class_eval
• deﬁne_method
• method_missing

attr_reader (class_eval)
class User
def initialize(name)
@name = name
end
attr_reader :name
end
u = User.new(‘Santiago’)
u.name # => ‘Santiago’

class Module
def attr_reader(sym)
class_eval “def #{sym}; @#{sym}; end”
end
end
class User
attr_reader :name # def name; @name; end
end

class Module
private
def attr_reader(sym)
class_eval <<-READER, __FILE__, __LINE__ + 1
def #{sym}
@#{sym}
end
READER
end
end

attr_writer (class_eval)
class Module
private
def attr_writer(sym)
class_eval <<-WRITER, __FILE__, __LINE__ + 1
def #{sym}=(value)
@#{sym} = value
end
WRITER
end
end

attr_accessor
class Module
private
def attr_accessor(*syms)
attr_reader(syms)
attr_writer(syms)
end
end

Metaprogramming
• class_eval
•deﬁne_method
• method_missing

deﬁne_method
class User
attr_accessor_with_default :age, 22
end
user = User.new
user.age # => 22
user.age = 26
user.age # => 26

deﬁne_method
class Module
def attr_accessor_with_default(sym, default)
def #{sym}
#{default}
end
# + something else
READER
end
end

deﬁne_method
class User
attr_accessor_with_default :age, 22
end
user = User.new
user.age # => 22

deﬁne_method
class USer
attr_accessor_with_default :complex_obj,
Struct.new(:x, :y)
end
user = User.new
user.complex_obj # => nil

deﬁne_method
22.to_s # => “22”
Struct.new(:x, :y).to_s # => "#<Class:0x00000100966210>"

deﬁne_method
class Module
def #{sym}
default
end
# + something else
READER
end
end

deﬁne_method
class User
Struct.new(:x, :y)
end
user = User.new
user.complex_obj
NameError: undefined local variable or method
`default' for #<User:0x00000100978050>

deﬁne_method
class Module
define_method(sym, Proc.new { default })
end
end

deﬁne_method
class Module
define_method(sym, Proc.new { default })
class_eval(<<-EVAL, __FILE__, __LINE__ + 1)
def #{sym}=(value)
class << self; attr_accessor :#{sym} end
@#{sym} = value
end
EVAL
end
end

deﬁne_method
class Person
Struct.new(:x, :y)
end
person = Person.new
person.complex_obj # => #<Class:0x00000101045c70>
person.complex_obj = Struct.new(:a, :b)
person.complex_obj # => #<Class:0x000001009be9d8>

Metaprogramming
• class_eval
• deﬁne_method
•method_missing

Method Lookup
BasicObject
Object
XMLx
KernelKernel

method_missing
(An internal DSL)
XML.generate(STDOUT) do
html do
head do
title { ‘pagetitle’ }
comment ‘This is a test’
end
body do
h1 style: ‘font-family: sans-serif‘ do
‘pagetitle’
end
ul id: ‘info’ do
li { Time.now }
li { RUBY_VERSION }
end
end
end

method_missing
(An internal DSL)
<html>
<head>
<title>pagetitle</title>

</head>
<body>
<h1 style=”font-family: sans-serif”>
pagetitle
</h1>
<ul id=”info”>
<li>2010-10-30 17:39:45 -0200</li>
<li>1.9.2</li>
</ul>
</body>
</html>

method_missing
(An internal DSL)
class XML
def initialize(out)
@out = out
end
def content(text)
@out << text.to_s
end
def comment(text)
@out << “”
end
end

method_missing
(An internal DSL)
def method_missing(tagname, attributes={})
@out << “<#{tagname}”
attributes.each { |attr, value|
@out << “#{attr}=’#{value}’”
}
if block_given?
@out << ‘>’
content = yield
if content
@out << content.to_s
end
@out << “</#{tagname}>”
else
@out << ‘/>’
end
end

method_missing
(An internal DSL)
class XML
def self.generate(out, &block)
XML.new(out).instance_eval(&block)
end
end
XML.generate(STDOUT) do
# code
end

It’s all about the self

Singleton Method
d = “9/5/1982”
def d.to_date
# code here
end
# or
class << d
def to_date
# code here
end
end

Object Model
BasicObject
Object
String
(d)d
KernelKernel

Class Methods?
class String
def self.to_date
# code here
end
# or
class << self
def to_date
# code here
end
end
end

The same
d = “9/5/1982”
def d.to_date
# code here
end
# or
class << d
def to_date
# code here
end
end

Object Model
(BasicObject)BasicObject
Object (Object)
String (String)
Module
Class

Everything about self
class User
p self # => User
class << self
p self # => <Class:User>
end
end

Real life use cases for
ﬁbers?
require 'fiber'
module Eigenclass
  def eigenclass
    class << self; self end
  end
  module_function :eigenclass
  public :eigenclass
end
class Object
  include Eigenclass
end

Real life use cases for
ﬁbers?
class EigenclassesGenerator
  def initialize(obj)
    @eigenclasses = [obj.eigenclass]
    @fiber = Fiber.new do
      loop do
        Fiber.yield @eigenclasses.last
        @eigenclasses[@eigenclasses.length] = @eigenclasses.last.eigenclass
      end
    end
  end
  def [](index)
if index >= @eigenclasses.length
(index - @eigenclasses.length + 2).times { @fiber.resume }
end
    @eigenclasses[index]
  end
end

Rails Magic?
class User < ActiveRecord::Base
belongs_to :bill_address
has_one :role
has_many :orders
validates_presence_of :name, :country
validates_acceptance_of :terms
validates_uniqueness_of :name
end

Questions?

Thank you!

Metaprogramming

More Related Content

What's hot

Similar to Metaprogramming

Recently uploaded

Metaprogramming