Meta Programming in Ruby - Code Camp 2010

Meta Programming in Ruby Steven Soroka @ssoroka

self.inspect

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” - Yukihiro Matsumoto

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” - Yukihiro Matsumoto

What is Ruby?

What is Ruby? • Ruby is not Ruby on Rails

What is Ruby? • Ruby is not Ruby on Rails • Ruby is an interpreted language

What is Ruby? • Ruby is not Ruby on Rails • Ruby is an interpreted language • script language

What is Ruby? • Ruby is not Ruby on Rails • Ruby is an interpreted language • script language • terse

What is Ruby? • Ruby is not Ruby on Rails • Ruby is an interpreted language • script language • terse • completely Object Oriented

What is Ruby? • Ruby is not Ruby on Rails • Ruby is an interpreted language • script language • terse • completely Object Oriented • Free, really free.

puts “Hello World”

class Car

class Car def start

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?

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?

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

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

What Can I do with Ruby? • Cross-platform GUI apps (WxRuby, FXRuby, Ruby-GNOME2, Ruby Tk) • Mac Desktop apps with MacRuby and Cocoa • Web Apps (Ruby on Rails, Sinatra)

What Can I do with Ruby? • Cross-platform GUI apps (WxRuby, FXRuby, Ruby-GNOME2, Ruby Tk) • Mac Desktop apps with MacRuby and Cocoa • Web Apps (Ruby on Rails, Sinatra) • Replace Javascript?

What Can I do with Ruby? • Cross-platform GUI apps (WxRuby, FXRuby, Ruby-GNOME2, Ruby Tk) • Mac Desktop apps with MacRuby and Cocoa • Web Apps (Ruby on Rails, Sinatra) • Replace Javascript? • Soon Ruby.NET apps?

WxRuby GUI

Introduction to Ruby New Concepts

Differences from C++

Differences from C++ • No type casting

Differences from C++ • No type casting • There’s only two container types: Array and Hash

Differences from C++ • No type casting • There’s only two container types: Array and Hash • There’s no type conversions, you’ll probably ﬁnd that they aren’t necessary

Differences from C++ • No type casting • There’s only two container types: Array and Hash • There’s no type conversions, you’ll probably ﬁnd that they aren’t necessary • Multithreading is built-in

Differences from C++

Differences from C++ • A unit testing lib comes standard with Ruby

Differences from C++ • A unit testing lib comes standard with Ruby • It’s self instead of this

Differences from C++ • A unit testing lib comes standard with 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

Differences from Java • There’s no static type checking.

Differences from Java • There’s no static type checking. • Variable names are just labels. They don’t have a type associated with them

Differences from Java • There’s no static type checking. • Variable names are just labels. They don’t have a type associated with them • There are no type declarations

Differences from Java • There’s no static type checking. • Variable names are just labels. They don’t have a type associated with them • There are no type declarations • foo = Foo.new(“hi”) instead of Foo foo = new Foo(“hi”)

Variables

Variables • Instance variables start with @

Variables • Instance variables start with @ • Class variables start with @@

Variables • Instance variables start with @ • Class variables start with @@ • Global variables start with $

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

a = 5.3 b = 15 a * b # 79.5

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

:recipient

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

Symbols

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

:name.object_id == :name.object_id # true

:name.object_id == :name.object_id # true “name”.object_id == “name”.object_id

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

john = {

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

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

john = { :name => 'John Smith', :age => 42 }

john = { :name => 'John Smith', :age => 42 } john[:name] # 'John Smith'

john = { :name => 'John Smith', :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

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

Implied Return Values if 3 > 2 5 end # returns 5

Implied Return Values if 2 > 21 5 end # returns nil

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

Classes Are Open

Classes Are Open • Don’t violate Open/Close Principle

Classes Are Open • Don’t violate Open/Close Principle • OCP says classes should be...

Classes Are Open • Don’t violate Open/Close Principle • OCP says classes should be... • open for extension

Classes Are Open • Don’t violate Open/Close Principle • OCP says classes should be... • open for extension • closed for modiﬁcation

Classes Are Open

Classes Are Open class Float

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

Classes Are Open class Float

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

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)

Fixnum (Integers) 42

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 # ["&", "*", "**", "+", "-", "/", "abs", "between?", "even?", "to_f", "zero?", "|", ...]

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

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

Float 42.0.class # Float

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

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

Date (Rails)

Date (Rails) day = Date.today # Sat, 27 Feb 2010

Date (Rails) day = Date.today # Sat, 27 Feb 2010 day.tomorrow # Sun, 28 Feb 2010

Date (Rails) day = Date.today # Sat, 27 Feb 2010 day.tomorrow # Sun, 28 Feb 2010 day.year # 2010

Date (Rails) day = Date.today # Sat, 27 Feb 2010 day.tomorrow # Sun, 28 Feb 2010 day.year # 2010 day.leap? # false

Date (Rails) day = Date.today # Sat, 27 Feb 2010 day.tomorrow # Sun, 28 Feb 2010 day.year # 2010 day.leap? # false 42.days.ago # Sat, 16 Jan 2010

Array my_array = Array.new()

Array my_array = []

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 = { :recipients => 'mom@mom.com', :subject => 'hi mom', :body => "I'm at CodeCamp!", :priority => :normal } send_email(email_settings)

Hash send_email({ :recipients => 'mom@mom.com', :subject => 'hi mom', :body => "I'm at Code Camp!", :priority => :normal })

Hash send_email( :recipients => 'mom@mom.com', :subject => 'hi mom', :body => "I'm at CodeCamp!", :priority => :normal )

Regular Expressions /[aeiou]/

Regular Expressions

Regular Expressions ‘scintillating!’ =~ /[aeiou]/

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

Regular Expressions

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

Operators are Methods • Most operators are methods

Operators are Methods • Most operators are methods • and can be redeﬁned

Operators are Methods • Most operators are methods • and can be redeﬁned class Fixnum def +(other) self - other end end

Operators are Methods • Most operators are methods • and can be redeﬁned 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 = User.ﬁnd(:all) @users.each { |user|

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

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

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

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

arr = [5,3,1,5,3,2,6,8,1,2] arr.sort{|a,b| a <=> b } # [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] arr.sort{|a,b| a <=> b } # [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_total = Proc.new { User.count

user_total = Proc.new { User.count }

user_total = Proc.new { User.count } user_total.call

user_total = Proc.new { User.count } user_total.call # 52

user_total = Proc.new { User.count } user_total.call # 52 # user is added

user_total = Proc.new { User.count } user_total.call # 52 # user is added user_total.call

user_total = Proc.new { User.count } user_total.call # 52 # user is added user_total.call # 53

Array#map

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

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

Array#inject class Array

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 self.inject(0){|sum, i| i + sum } end

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

Array#inject class Array def sum self.inject(0){|sum, i| i + sum } end end [1,2,3,4,5].sum

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

Array#inject

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

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

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 attr_accessor :color, :engine, :make, :model end class Object

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes)

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute|

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # deﬁne getter

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # deﬁne getter deﬁne_method(attribute) do

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # deﬁne getter deﬁne_method(attribute) do instance_variable_get("@#{attribute}")

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # deﬁne getter deﬁne_method(attribute) do instance_variable_get("@#{attribute}") end

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter define_method("#{attribute}=") do |var|

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter define_method("#{attribute}=") do |var| instance_variable_set("@#{attribute}", var)

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter define_method("#{attribute}=") do |var| instance_variable_set("@#{attribute}", var) end

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter define_method("#{attribute}=") do |var| instance_variable_set("@#{attribute}", var) end }

class Car attr_accessor :color, :engine, :make, :model end class Object def self.attr_accessor(*attributes) attributes.each{|attribute| # define getter define_method(attribute) do instance_variable_get("@#{attribute}") end # define setter define_method("#{attribute}=") do |var| instance_variable_set("@#{attribute}", var) end } end

Introspection self.inspect

.class

.class • Any object will respond to .class

.class • Any object will respond to .class • Car.new.class # Car

.class • Any object will respond to .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 # ... def method_missing(method, *args, &block) @called << method end def talk # ... end

class Elephant # ... def method_missing(method, *args, &block) @called << method end def talk # ... end suzie = Elephant.new

class Elephant # ... def method_missing(method, *args, &block) @called << method end def talk # ... end suzie = Elephant.new suzie.brush

class Elephant # ... def method_missing(method, *args, &block) @called << method end def talk # ... end suzie = Elephant.new suzie.brush suzie.do_tricks

class Elephant # ... def method_missing(method, *args, &block) @called << method end def talk # ... end suzie = Elephant.new suzie.brush suzie.do_tricks suzie.ride

class Elephant # ... def method_missing(method, *args, &block) @called << method end def talk # ... end suzie = Elephant.new 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 def self.tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end end Html.tag(‘strong’, “I’m strong!”) # I’m strong!

class Html def self.tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end def self.strong(content) tag(‘strong’, content) end end Html.strong(“I’m strong!”) # I’m strong!

class Html TAG_TYPES = [‘strong’, ‘div’, ‘span’, ‘a’, ‘ul’] def self.tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end def self.strong(content) tag(‘strong’, content) end end Html.strong(“I’m strong!”) # I’m strong!

class Html TAG_TYPES = %w(strong div span a ul) def self.tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end def self.strong(content) tag(‘strong’, content) end end Html.strong(“I’m strong!”) # I’m strong!

class Html TAG_TYPES = %w(strong div span a ul) class << self def tag(tag_name, content) "<#{tag_name}>#{content}</ #{tag_name}>" end def strong(content) tag(‘strong’, content) end end end

class Html TAG_TYPES = %w(strong div span a ul) class << self def tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end TAG_TYPES.each{|tag_type| deﬁne_method(tag_type) do |content| tag(tag_type, content) end } end end

Html.strong(‘buffalo’) # buffalo Html.span(‘distances’) # distances Html.a(‘revelation’) # <a>revelation</a>

class Html TAG_TYPES = %w(strong div span a ul) class << self def tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end def method_missing(method, *args) if TAG_TYPES.include?(method) tag(method, *args) else super end end end end

class Html class << self def tag(tag_name, content) "<#{tag_name}>#{content}</#{tag_name}>" end def method_missing(method, *args) 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.size # 75 (or more) Object.methods

Object.methods.size # 75 (or more) 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> paragraph </body> </html>

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

big_button = Button.new

big_button = Button.new little_button = Button.new

big_button = Button.new little_button = Button.new def big_button.click

big_button = Button.new little_button = Button.new def big_button.click do_big_stuff

big_button = Button.new little_button = Button.new def big_button.click do_big_stuff end

big_button = Button.new little_button = Button.new def big_button.click do_big_stuff end def little_button.click

big_button = Button.new little_button = Button.new def big_button.click do_big_stuff end def little_button.click act_important

big_button = Button.new little_button = Button.new def big_button.click do_big_stuff end def little_button.click 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

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

Operator Overloading class Fixnum def +(other) self - other end end 5 + 3 # => 2

Operator Overloading

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

Operator Overloading 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

Object Proxy class SpyProxy

Object Proxy class SpyProxy def initialize(target)

Object Proxy class SpyProxy def initialize(target) @target = target

Object Proxy class SpyProxy def initialize(target) @target = target end

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args)

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args) puts “#{method} called with args:

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args) puts “#{method} called with args: #{args.inspect}”

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args) puts “#{method} called with args: #{args.inspect}” @target.send(method, *args)

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args) puts “#{method} called with args: #{args.inspect}” @target.send(method, *args) end

Object Proxy class SpyProxy def initialize(target) @target = target end def method_missing(method, *args) puts “#{method} called with args: #{args.inspect}” @target.send(method, *args) end end

Object Proxy

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 paul.start(bmw) # “clunk clunk” steve.start(bmw) # “vroom vroom”

Object Proxy paul = Person.new steve = Person. new bmw = BMW. new paul.start(bmw) # “clunk clunk” steve.start(bmw) # “vroom vroom” spy_bmw = SpyProxy.new(bmw)

Object Proxy

Object Proxy spy_bmw = SpyProxy.new(bmw)

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw)

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0]

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0] # turn_key called with args: []

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0] # turn_key called with args: [] # “vroom vroom”

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0] # turn_key called with args: [] # “vroom vroom” paul.start(spy_bmw)

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0] # turn_key called with args: [] # “vroom vroom” paul.start(spy_bmw) # turn_key called with args: []

Object Proxy spy_bmw = SpyProxy.new(bmw) steve.start(spy_bmw) # press_clutch called with args: [1.0] # turn_key called with args: [] # “vroom vroom” paul.start(spy_bmw) # turn_key called with args: [] # “clunk clunk”

Self-Optimization

Self-Optimization def get_random_user_id

Self-Optimization def get_random_user_id user_count = sql("select count(*) from users")

Self-Optimization def get_random_user_id user_count = sql("select count(*) from users") sql("select id from users

Self-Optimization def get_random_user_id user_count = sql("select count(*) from users") sql("select id from users offset #{rand(user_count)} limit 1")

Self-Optimization def get_random_user_id user_count = sql("select count(*) from users") sql("select id from users offset #{rand(user_count)} limit 1") end

Self-Optimization

Self-Optimization def get_random_user_id @user_count ||= sql("select count(*) from users") sql("select id from users offset #{rand(@user_count)} limit 1") end

Self-Optimization

Self-Optimization def get_random_user_id

Self-Optimization def get_random_user_id class_eval {

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users")

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users offset #{rand(user_count)} limit 1")

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users offset #{rand(user_count)} limit 1") end

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users offset #{rand(user_count)} limit 1") end }

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users offset #{rand(user_count)} limit 1") end } get_random_user_id

Self-Optimization def get_random_user_id class_eval { user_count = sql("select count(*) from users") deﬁne_method(‘get_random_user_id’) do sql("select id from users offset #{rand(user_count)} limit 1") end } get_random_user_id end

Self-Optimization

Self-Optimization def get_random_user_id sql("select id from users offset #{rand(1052023)} limit 1") end

Caching by rewriting methods?

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

Caching by rewriting methods? • You can rewrite a method as a form of caching • Downside is cache invalidation becomes messy (doable, think alias)

Caching by rewriting methods? • You can rewrite a method as a form of caching • Downside is cache invalidation becomes messy (doable, think alias) • There’s easier ways

Caching by rewriting methods? • You can rewrite a method as a form of caching • Downside is cache invalidation becomes messy (doable, think alias) • There’s easier ways • @var ||= ...

Caching by rewriting methods? • You can rewrite a method as a form of caching • Downside is cache invalidation becomes messy (doable, think alias) • There’s easier ways • @var ||= ... • memoization (memoize in Rails)

Try Ruby in Your Browser http://TryRuby.org/ Download Ruby http://www.ruby-lang.org/en/downloads/

http://www.TeachMeToCode.com

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

Merci @ssoroka - twitter

Meta Programming in Ruby - Code Camp 2010

by ssoroka

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 35

Statistics

Meta Programming in Ruby - Code Camp 2010 Presentation Transcript

http://www.slideshare.net	33
http://www.techgig.com	2