Meta Programming in Ruby - Code Camp 2010

Meta Programming
in Ruby
Steven Soroka
@ssoroka

self.inspect

•@ssoroka
on twitter

self.inspect

•@ssoroka
on twitter

• github.com/ssoroka

self.inspect

•@ssoroka
on twitter

• github.com/ssoroka
• blog.stevensoroka.ca

self.inspect

• Professionally writing software for 12
years
• Ruby for 3+ years
• Taught Ruby on Rails at RRC
• My biggest site has over 1 million
users

What is Ruby?

A dynamic, open source programming language
with a focus on simplicity and productivity.
It has an elegant syntax
that is natural to read and easy to write.

http://www.ruby-lang.org

What is Ruby?

- Yukihiro Matsumoto

What is Ruby?

“Ruby is simple in appearance,
but is very complex inside”


What is Ruby?

“Ruby is simple in appearance,
but is very complex inside”

“I wanted a scripting language that was more
powerful than Perl, and more object-oriented than
Python”


What is Ruby?
• Ruby is not Ruby on Rails

What is Ruby?
• Ruby is an interpreted language

What is Ruby?
• script language

What is Ruby?
• script language
• terse

What is Ruby?
• script language
• terse
• completely Object Oriented

What is Ruby?
• script language
• terse
• completely Object Oriented
• Free, really free.

class Car
def start
puts "vroom vroom"

class Car
def start
puts "vroom vroom"
end

class Car
def start
puts "vroom vroom"
end
end

class Car
def start
puts "vroom vroom"
end
end

car = Car.new

class Car
def start
puts "vroom vroom"
end
end

car = Car.new
car.start # vroom
vroom

Does Ruby matter?
Rubinious
MacRuby JRuby
Ruby 1.8
IronRuby
Cardinal

HotRuby
IronMonkey
Ruby 1.9
Ruby Enterprise
Edition

What Can I do with
Ruby?
• Cross-platform GUI apps (WxRuby,
FXRuby, Ruby-GNOME2, Ruby Tk)

What Can I do with
Ruby?

• Mac Desktop apps with MacRuby and
Cocoa

What Can I do with
Ruby?

Cocoa

• Web Apps (Ruby on Rails, Sinatra)

What Can I do with
Ruby?

Cocoa

• Replace Javascript?

What Can I do with
Ruby?

Cocoa

• Replace Javascript?
• Soon Ruby.NET apps?

Introduction to Ruby
New Concepts

Differences from C++

• No type casting


• No type casting
• There’s only two container types:
Array and Hash


• No type casting
Array and Hash

• There’s no type conversions, you’ll
probably ﬁnd that they aren’t
necessary


• No type casting
Array and Hash

• There’s no type conversions, you’ll
probably ﬁnd that they aren’t
necessary

• Multithreading is built-in


• A unit testing lib comes standard with
Ruby


Ruby

• It’s self instead of this


Ruby

• It’s self instead of this
• Objects are strongly but dynamically
typed. The runtime discovers at
runtime if that method call actually
works

Differences from Java

• There’s no static type checking.


• Variable names are just labels. They
don’t have a type associated with
them


them
• There are no type declarations


them
• There are no type declarations
• foo = Foo.new(“hi”) instead of
Foo foo = new Foo(“hi”)

Variables

• Instance variables start with @

Variables

• Class variables start with @@

Variables

• Global variables start with $

Variables

• Global variables start with $
• Any type of object can be stored in a
given variable

Truthiness

• In Ruby, only false and nil are false
• 0 is true
• “” is true
• [] is true

if 0
puts "0 is truthy"
end

# 0 is truthy

deliver_report(:recipient => 'john@example.com')
:recipient

Symbols

• Symbols are similar to strings, but are
only allocated memory once, and are
never freed.

Symbols

• Symbols are similar to strings, but are
only allocated memory once, and are
never freed.

• Great for keys, column names, and
other strings that are repeated over
and over again.

:name.object_id == :name.object_id

# true

# true

“name”.object_id == “name”.object_id

# true

“name”.object_id == “name”.object_id
# false

john = {
:name => 'John Smith',

john = {
:age => 42

john = {
:age => 42
}

john = {
:age => 42
}

john[:name] # 'John Smith'

john = {
:age => 42
}

john[:name] # 'John Smith'
john[:age] # 42

Interpolation

• Double quoted strings are
interpolated, single quoted strings are
not.

puts “five times three is #{5 * 3}”
# five times three is 15
puts ‘five times three is #{5 * 3}’
# five times three is #{5 * 3}

Everything Has a Value

• Expressions and statements are the
same thing in Ruby

Everything Has a Value

• Expressions and statements are the
same thing in Ruby
• Everything returns a value, even if
that value is nil

Implied Return Values
if 3 > 2
5
end

# returns 5

if 2 > 21
5
end

# returns nil


pass = if 3.odd?
‘odd’
else
‘even’
end
# pass == ‘odd’

Classes Are Open

• Don’t violate Open/Close Principle

Classes Are Open

• OCP says classes should be...

Classes Are Open

• open for extension

Classes Are Open

• open for extension
• closed for modiﬁcation

Classes Are Open
class Float
def round

Classes Are Open
class Float
def round
floor

Classes Are Open
class Float
def round
floor
end

Classes Are Open
class Float
def round
floor
end
end

Classes Are Open
class Float
def round
floor
end
end
5.7.round

Classes Are Open
class Float
def round
floor
end
end
5.7.round
# 5

Classes Are Open
class Float
def round_down

Classes Are Open
class Float
def round_down
floor

Classes Are Open
class Float
def round_down
floor
end

Classes Are Open
class Float
def round_down
floor
end
end

Classes Are Open
class Float
def round_down
floor
end
end
5.7.round_down

Classes Are Open
class Float
def round_down
floor
end
end
5.7.round_down
# 5

Everything’s An Object

• properties are called attributes or
instance variables

Everything’s An Object

• properties are called attributes or
instance variables

• actions are called methods

String

“I am a string”
‘I am a string’

Fixnum (Integers)
42
42.class # Fixnum

Fixnum (Integers)
42
42.class # Fixnum
42.methods

Fixnum (Integers)
42
42.class # Fixnum
42.methods
# ["&", "*", "**", "+", "-", "/",

Fixnum (Integers)
42
42.class # Fixnum
42.methods
# ["&", "*", "**", "+", "-", "/",
"abs", "between?", "even?",

Fixnum (Integers)
42
42.class # Fixnum
42.methods
# ["&", "*", "**", "+", "-", "/",
"to_f", "zero?", "|", ...]

Fixnum (Integers)
42
42.class # Fixnum
42.methods
# ["&", "*", "**", "+", "-", "/",
"to_f", "zero?", "|", ...]
42.odd? # False

Fixnum (Integers)
42
42.class # Fixnum
42.methods
# ["&", "*", "**", "+", "-", "/",
"to_f", "zero?", "|", ...]
42.odd? # False
42.to_f # 42.0

Float

42.0.class # Float
42.6.ﬂoor # 42

Float

42.0.class # Float
42.6.ﬂoor # 42
42.6.round # 43

Date (Rails)

day = Date.today # Sat, 27 Feb 2010

Date (Rails)

day.tomorrow # Sun, 28 Feb 2010

Date (Rails)

day.year # 2010

Date (Rails)

day.year # 2010
day.leap? # false

Date (Rails)

day.year # 2010
day.leap? # false
42.days.ago # Sat, 16 Jan 2010

Array

my_array = Array.new()

Array

my_array = [1, 2, 3, 4, 5]

Hash

email_settings = {
:recipients => 'mom@mom.com',
:subject => 'hi mom',
:body => "I'm at CodeCamp!",
:priority => :normal
}

Hash

email_settings = {
}

send_email(email_settings)

Hash

send_email({
:body => "I'm at Code Camp!",
})

Hash

send_email(
)

Regular Expressions

/[aeiou]/

Regular Expressions

‘scintillating!’ =~ /[aeiou]/

Regular Expressions

‘scintillating!’ =~ /[aeiou]/
#2

Regular Expressions

‘scintillating!’.gsub(/[aeiou]/, ‘*’)

Regular Expressions

‘scintillating!’.gsub(/[aeiou]/, ‘*’)
# ‘sc*nt*ll*t*ng!’

Classes

• Single inheritance only
• but can include functionality from
modules

• can open a class at any time to add
methods

• ... are objects!

Methods

• can end in ? or !
• “apples”.is_a?(String)
• Are objects!

Operators are Methods
• Most operators are methods

• and can be redeﬁned

class Fixnum
def +(other)
self - other
end
end

class Fixnum
def +(other)
self - other
end
end

5 + 3 # => 2

Blocks

• In Ruby, a block is a namless function
that can be stored as a callable object,
called a Proc

• Blocks can be stored in variables
• Blocks can be passed to methods to
customize their behavior

@users = User.ﬁnd(:all)
@users.each { |user|

user.send_invoice!

user.send_invoice!
}

arr = [5,3,1,5,3,2,6,8,1,2]

arr.sort{|a,b| a <=> b }

arr = [5,3,1,5,3,2,6,8,1,2]

# [1, 1, 2, 2, 3, 3, 5, 5, 6, 8]

arr = [5,3,1,5,3,2,6,8,1,2]

# [1, 1, 2, 2, 3, 3, 5, 5, 6, 8]

arr.sort{|a,b| b <=> a }

arr = [5,3,1,5,3,2,6,8,1,2]

# [1, 1, 2, 2, 3, 3, 5, 5, 6, 8]

arr.sort{|a,b| b <=> a }
# [8, 6, 5, 5, 3, 3, 2, 2, 1, 1]

Block Objects are
Closures

Block Objects are
Closures
• Block Objects (Procs) can be executed
anywhere and can take their context
(called binding) with them.

Block Objects are
Closures
• Block Objects (Procs) can be executed
anywhere and can take their context
(called binding) with them.

• A closure is a block of code that, when
run, is executed within the scope it
was deﬁned (i.e. local variables are
available to the block), even after the
function has returned, and its local
scope has been destroyed.

user_total = Proc.new {
User.count

User.count
}

User.count
}

user_total.call

User.count
}

user_total.call
# 52

User.count
}

user_total.call
# 52
# user is added

User.count
}

user_total.call
# 52
# user is added
user_total.call

User.count
}

user_total.call
# 52
# user is added
user_total.call
# 53

Array#map

[1,2,3,4,5].map{|i| i * 2}

Array#map

[1,2,3,4,5].map{|i| i * 2}
# [2,4,6,8,10]

Array#inject

[1,2,3,4,5].inject(0){|sum, i|

Array#inject

[1,2,3,4,5].inject(0){|sum, i|
i + sum

Array#inject

[1,2,3,4,5].inject(0){|sum, i|
i + sum
}

Array#inject

[1,2,3,4,5].inject(0){|sum, i|
i + sum
}
# 15

Array#inject
class Array
def sum

Array#inject
class Array
def sum
self.inject(0){|sum, i| i + sum }

Array#inject
class Array
def sum
end

Array#inject
class Array
def sum
end
end

Array#inject
class Array
def sum
end
end

[1,2,3,4,5].sum

Array#inject
class Array
def sum
end
end

[1,2,3,4,5].sum
# 15

Array#inject

[1,2,3,4,5].inject(0){|best, i|

Array#inject

[1,2,3,4,5].inject(0){|best, i|
i % 2 == 0 ? i : best

Array#inject

[1,2,3,4,5].inject(0){|best, i|
i % 2 == 0 ? i : best
}

Array#inject

[1,2,3,4,5].inject(0){|best, i|
i % 2 == 0 ? i : best
}
#4

Array#select

[1,2,3,4,5].select{| i|

Array#select

[1,2,3,4,5].select{| i|
i % 2 == 0

Array#select

[1,2,3,4,5].select{| i|
i % 2 == 0
}

Array#select

[1,2,3,4,5].select{| i|
i % 2 == 0
}
# [2, 4]

Array#reject

[1,2,3,4,5].reject{| i|

Array#reject

[1,2,3,4,5].reject{| i|
i % 2 == 0

Array#reject

[1,2,3,4,5].reject{| i|
i % 2 == 0
}

Array#reject

[1,2,3,4,5].reject{| i|
i % 2 == 0
}
# [1, 3, 5]

Extending Classes
• Make a module
• include it in to a class

Extending Classes
• Make a module
• include it in to a class
module Awesomeness
end

class Mundane
include Awesomeness
end

Meta Programming
Meta programming is writing code that
writes code

class Car
def color
@color
end

def color=(color)
@color = color
end
...

class Car
def color
@color

class Car
end

def color=(color)

def color
@color = color
end

@color
def engine
@engine
end

def engine=(engine)
@engine = engine
end
end

def make
@make
end
def color=(color)
def make=(make)
@make = make
end @color = color
def model
@model
end
end
def model=(model)
@model = model
...
end
end

class Car
attr_accessor :color, :engine, :make, :model
end

class Car
end
class Object

class Car
end
class Object
def self.attr_accessor(*attributes)

class Car
end
class Object
attributes.each{|attribute|

class Car
end
class Object
# deﬁne getter

class Car
end
class Object
# deﬁne getter
deﬁne_method(attribute) do

class Car
end
class Object
# deﬁne getter
instance_variable_get("@#{attribute}")

class Car
end
class Object
# deﬁne getter
end

class Car
end
class Object
# deﬁne getter
end
# deﬁne setter

class Car
end
class Object
# define getter
end
# define setter
define_method("#{attribute}=") do |var|

class Car
end
class Object
# deﬁne getter
end
# deﬁne setter
instance_variable_set("@#{attribute}", var)

class Car
end
class Object
# deﬁne getter
end
# deﬁne setter
end

class Car
end
class Object
# deﬁne getter
end
# deﬁne setter
end
}

class Car
end
class Object
# deﬁne getter
end
# deﬁne setter
end
}
end

.class

• Any object will respond to .class

.class

• Car.new.class # Car

.class

• Car.new.class # Car
• Car.class # Class

.ancestors

• class BMW < Car
...
end

• BMW.ancestors # [Car, Object,
Kernel]

.methods

• Every object responds to .methods

.instance_variable_set

• object.instance_variable_set(“@quantity”, 51)

.instance_variable_get

• object.instance_variable_get(“@quantity”)
# 25

.instance_variables

• Gem.instance_variables
# [“@gem_home”, “@ruby”,
“@gem_path”, ...]
• Gem.instance_variable_get(
“@gem_home”)
# [“/Library/Ruby/Gems/1.8”, ...]

.constants
• Math.constants # [“PI”, “E”]
• Math::PI # 3.14159265358979
• Math::E # 2.71828182845905
• Math.const_get(“PI”)
# 3.14159265358979
• Math.const_set(“GOOGOL”, 10 **
100)

.respond_to?

• Tells you if objects will respond to a
certain method.

• ‘string’.respond_to?(:size) # true

.inspect

• Car.new.inspect
# => "#<Car:0x123d9e8>"

• ﬁsh = :tuna
ﬁsh.inspect
# => ":tuna"
• 5.inspect
# => "5"

Dynamically Calling
Methods

• car.respond_to?(:start_engine)
• car.send(:start_engine)

Method Missing

• You can deﬁne ghost methods that
don’t actually exist, but pretend to
when requested

class Elephant
def initialize
@called = []
end

def method_missing(method, *args, &block)
@called << method
end

def talk
puts @called.inspect
end
end

class Elephant
# ...
@called << method
end

def talk # ...
end

class Elephant
# ...
@called << method
end

def talk # ...
end
suzie = Elephant.new

class Elephant
# ...
@called << method
end

def talk # ...
end
suzie.brush

class Elephant
# ...
@called << method
end

def talk # ...
end
suzie.brush
suzie.do_tricks

class Elephant
# ...
@called << method
end

def talk # ...
end
suzie.brush
suzie.do_tricks
suzie.ride

class Elephant
# ...
@called << method
end

def talk # ...
end
suzie.brush
suzie.do_tricks
suzie.ride
suzie.talk # [‘brush’, ‘do_tricks’, ‘ride’]

deﬁne_method()

class Html
def self.tag(tag_name, content)
"<#{tag_name}>#{content}</#{tag_name}>"
end
end

class Html
end
end

Html.tag(‘strong’, “I’m strong!”)
# <strong>I’m strong!</strong>

class Html
end

def self.strong(content)
tag(‘strong’, content)
end
end

Html.strong(“I’m strong!”)

class Html
TAG_TYPES = [‘strong’, ‘div’, ‘span’, ‘a’, ‘ul’]

end

end
end


class Html
TAG_TYPES = %w(strong div span a ul)

end

end
end


class Html

class << self
def tag(tag_name, content)
"<#{tag_name}>#{content}</
#{tag_name}>"
end

def strong(content)
end
end
end

class Html

class << self
end

TAG_TYPES.each{|tag_type|
deﬁne_method(tag_type) do |content|
tag(tag_type, content)
end
}
end
end

Html.strong(‘buffalo’) # <strong>buffalo</strong>

Html.span(‘distances’) # <span>distances</span>

Html.a(‘revelation’) # <a>revelation</a>

class Html

class << self
end

def method_missing(method, *args)
if TAG_TYPES.include?(method)
tag(method, *args)
else
super
end
end
end
end

class Html
class << self
end

tag(method, *args)
end
end
end

Html.li(‘list item 1’) # <li>list item 1</li>

Html.think(‘test’) # <think>test</think>

Html.name(‘Steven Soroka’)
# <name>Steven Soroka</name>

Object.methods.size # 75 (or more)


Object.methods


Object.methods
# ["inspect", "private_class_method",
"const_missing", ...]

undef_method()

class Html
class << self
methods.each{|method|
undef_method(method)
}
end
end

undef_method()

Html.methods # [] ?

undef_method()

NoMethodError: undeﬁned
method `methods' for
#<Class:0x408bc>

XML Builder
xml.instruct!
xml.html {
xml.head {
xml.title("History")
}
xml.body {
xml.h1("Header")
xml.p("paragraph")
}
}

XML Builder
<?xml version="1.0" encoding="UTF-8"?
>
<html>
<head>
<title>History</title>
</head>
<body>
<h1>Header</h1>
<p>paragraph</p>
</body>
</html>

Singleton Methods

•methods deﬁned on a
single instance of a class.
•unrelated to class
singletons

big_button = Button.new
little_button = Button.new


def big_button.click


do_big_stuff


do_big_stuff
end


do_big_stuff
end

def little_button.click


do_big_stuff
end

act_important


do_big_stuff
end

act_important
end

Domain-Speciﬁc
Language (DSL)

eval

• eval
• class_eval
• instance_eval
• module_eval

module ActiveRecord
class RecordCannotBeDestroyed < ActiveRecordError
end

module Associations
module ClassMethods
def refuse_to_destroy!
module_eval %Q{
before_destroy do |record|
raise RecordCannotBeDestroyed, "You cannot destroy
#{record.class.name} records." unless record.new_record?
end
}
end
end
end
end

class User < ActiveRecord::Base
refuse_to_destroy!
end

# @user.destroy now raises an exception

def refuse_to_destroy!
module_eval %Q{
before_destroy do |record|
raise RecordCannotBeDestroyed, "You cannot destroy
#{record.class.name} records." unless record.new_record?
end
}
end

car.start
car.reverse
car.wheel.turn
car.gas_pedal.press
car.brake_pedal.press

with car do
start
reverse
wheel.turn
gas_pedal.press
brake_pedal.press
end

car.instance_eval {
start
reverse
wheel.turn
gas_pedal.press
brake_pedal.press
}

class Object
def with(obj, &block)
obj.instance_eval &block
end
end

with car do
start
reverse
wheel.turn
gas_pedal.press
brake_pedal.press
end

Aliasing Methods

• basically copies a method with a new
name
• alias chaining
• aka: alias method chaining

['apple', 'lobster', 'fish', 'balloons'].include?('fish')
# true

['apple', 'lobster', 'fish', 'balloons'].include?(/(lobster|fish)/)
# false

class Array
def include_with_regexp?(matcher)
if matcher.is_a?(Regexp)
any?{|i| i =~ matcher }
else
include_without_regexp?(matcher)
end
end

alias :include_without_regexp? :include?
alias :include? :include_with_regexp?
end

class Array
def include_with_regexp?(matcher)
if matcher.is_a?(Regexp)
any?{|i| i =~ matcher }
else
include_without_regexp?(matcher)
end
end

alias_method_chain :include?, :regexp
end

['apple', 'lobster', 'ﬁsh', 'balloons'].include?(
/(lobster|ﬁsh)/)
# true

Operator Overloading
class Fixnum
def +(other)
self - other
end
end

class Fixnum
def +(other)
self - other
end
end

5 + 3 # => 2

class Fixnum
def +(other)
(self.to_s + other.to_s).to_i
end
end

class Fixnum
def +(other)
(self.to_s + other.to_s).to_i
end
end

5 + 3 # => 53

More Examples

• Object Proxies
• Code that rewrites itself
• Optimization
• Caching

Object Proxy
class SpyProxy
def initialize(target)

Object Proxy
class SpyProxy
@target = target

Object Proxy
class SpyProxy
@target = target
end

Object Proxy
class SpyProxy
@target = target
end

puts “#{method} called with args:

Object Proxy
class SpyProxy
@target = target
end

#{args.inspect}”

Object Proxy
class SpyProxy
@target = target
end

#{args.inspect}”
@target.send(method, *args)

Object Proxy
class SpyProxy
@target = target
end

#{args.inspect}”
end

Object Proxy
class SpyProxy
@target = target
end

#{args.inspect}”
end
end

Object Proxy
paul = Person.new

Object Proxy
paul = Person.new
steve = Person. new

Object Proxy
paul = Person.new
steve = Person. new
bmw = BMW. new

Object Proxy
paul = Person.new
steve = Person. new
bmw = BMW. new

paul.start(bmw) # “clunk clunk”

Object Proxy
paul = Person.new
steve = Person. new
bmw = BMW. new

steve.start(bmw) # “vroom vroom”

Object Proxy
paul = Person.new
steve = Person. new
bmw = BMW. new

steve.start(bmw) # “vroom vroom”

spy_bmw = SpyProxy.new(bmw)

Object Proxy

Object Proxy

steve.start(spy_bmw)

Object Proxy

# press_clutch called with args: [1.0]

Object Proxy

# turn_key called with args: []

Object Proxy

# “vroom vroom”

Object Proxy

# “vroom vroom”

paul.start(spy_bmw)

Object Proxy

# “vroom vroom”

paul.start(spy_bmw)
# “clunk clunk”

Self-Optimization

def get_random_user_id

Self-Optimization

user_count = sql("select count(*) from users")

Self-Optimization

sql("select id from users

Self-Optimization

offset #{rand(user_count)} limit 1")

Self-Optimization

end

Self-Optimization

@user_count ||= sql("select count(*) from users")
offset #{rand(@user_count)} limit 1")
end

Self-Optimization

class_eval {

Self-Optimization

class_eval {
deﬁne_method(‘get_random_user_id’) do

Self-Optimization

class_eval {

Self-Optimization

class_eval {
end

Self-Optimization

class_eval {
end
}

Self-Optimization

class_eval {
end
}
get_random_user_id

Self-Optimization

class_eval {
end
}
get_random_user_id
end

Self-Optimization

offset #{rand(1052023)} limit 1")
end

Caching by rewriting
methods?

methods?
• You can rewrite a method as a form of
caching

methods?
caching

• Downside is cache invalidation
becomes messy (doable, think alias)

methods?
caching


• There’s easier ways

methods?
caching


• @var ||= ...

methods?
caching


• @var ||= ...
• memoization (memoize in Rails)

Try Ruby in Your
Browser
http://TryRuby.org/

Download Ruby
http://www.ruby-lang.org/en/downloads/

Resources

• http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html

• http://www.ruby-lang.org/en/about

• http://www.artima.com/intv/closures2.html

• http://silverlight.net/learn/dynamic-languages/

• http://blog.headius.com/2008/04/promise-and-peril-for-alternative-ruby.html

Questions?

@ssoroka - twitter

Meta Programming in Ruby - Code Camp 2010

More Related Content

What's hot

Viewers also liked

Similar to Meta Programming in Ruby - Code Camp 2010

Recently uploaded

Meta Programming in Ruby - Code Camp 2010

Editor's Notes