Ruby Object Model and Metaprogramming Techniques

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!

Ruby Object Model and Metaprogramming Techniques

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Ruby Object Model and Metaprogramming Techniques

Similar to Ruby Object Model and Metaprogramming Techniques (20)

Recently uploaded

Recently uploaded (20)

Ruby Object Model and Metaprogramming Techniques