Metaprogramming With Ruby

Metaprogramming with Ruby Julie Yaunches Farooq Ali

What is Metaprogramming?

Code that writes code

Know Thyself

Reflection.kind_of? Metaprogramming

Compile-time vs. Runtime

Metaprogramming == Programming

No natural separation

Ruby is interpreted, not compiled

Everything’s an object. Even classes!

Extensible type system

"Meta, shmeta! Learning Ruby isn’t like scaling a mountain. It’s more like exploring a plain. "

- David Black

Exploring the plain define_method alias_method foo.send :bar instance_variable_get class_eval instance_eval module_eval instance_variable_set eval block.call Class.new method_missing class << self block.binding Foo.instance_methods method_added method_removed

Ruby object model I: classes, objects, modules and blocks

Object introspection

Blocks and the strategy pattern

Dynamic methods

Ruby object model II: singletons and open classes

Method aliasing and the decorator pattern

Evaluation techniques

Object lifecycle hooks and method_missing

Outline

Ruby Object Model I

Everything is an instance of Object

Every object has a number of things:

klass, superclass, methods

Developer = Class.new

julie = Developer.new

Ruby Object Model I

Module – a collection of methods and constants

Methods can be instance methods or module methods

Modules can be ‘mixedin’ to a class.

module British

def goes_to_pub

“ I love beer and geeky talk”

end

end

class Developer

include British

end

julie.goes_to_pub => “I love beer and geeky talk”

Ruby Object Model I

When you create a module, it’s methods become available to the instances of the class via a proxy class.

Dynamic methods

Outline

Object Introspection

Instance variables

Instance Methods

Class scope via singleton class

Object Introspection: Instance Variables > @event = 'Away Day' > instance_variable_get '@event' => "Away Day" > instance_variable_set '@region', 'UK' > @region => "UK" > instance_variables => ["@event", "@region"]

Object Introspection: Methods > 'Away Day’. methods => ["capitalize", "split", "strip", …] > 5. public_methods => ["+", "/", "integer?", …]

Object Introspection: Methods > 'abc'.method(:capitalize) => #<Method: String#capitalize> class method strip capitalize String gsub split class method unbind arity Method to_proc call

Introspection in Action class Person def initialize(name, age, sex) @name = name @age = age @sex = sex end end Person.new('Farooq', 23, :male) Did we just think in a for-loop?!

Introspection in Action class Person def initialize(attributes) attributes.each do |attr, val| instance_variable_set("@#{attr}", val) end end end Person.new :name => 'Farooq', :age => '23', :sex => :male

Dynamic methods

Outline

Most common usage… Loop extraction… means of iterating

Blocks are basically nameless functions. You can pass a a block to another function, and then that function can invoke the passed-in nameless function.

Callbacks and hooks (will see later)

Can be passed all over the place for really any sort of need.

Blocks

Blocks are basically nameless functions. You can pass a a block to another function, and then that function can invoke the passed-in nameless function.

def foo

yield

end

foo {puts “foo”} => “foo”

foo {puts “bar”} => “bar”

Iterating through a collection

Records.each do |record|

print_title

end

Encapsulating error prone procedures

open(“some_file”) do |input|

input.each_line do |line|

process_input_line line

end

end

Dynamic methods

Outline

Calling methods dynamically

Convention-Oriented coding

Defining them on the fly

Writing declarative code

Dynamic Methods

Calling methods dynamically

> a = "Hello World!"

=> "Hello World!"

> a.downcase

=> "hello world!"

> a.send(:downcase)

=> "hello world!"

Calling methods dynamically: Why should I care?

Parameterized method names

Callbacks and Observers

Convention-oriented code

Working with method collections

and more…

Parameterized method names

controller:

@person = Person.new('Farooq')

view:

<%= text_field :person, :name %>

def text_field(obj, method) iv = instance_variable_get "@#{obj}" val = iv.send(method) "<input type='text' value='#{val}'>" end

Callbacks

class VaultController < BankController

before_filter :authorize

private

def authorize

user.can_access?(vault)

end

end

Callbacks

class SymbolFilter < Filter

def initialize(filter)

@filter = filter

end

def call(controller, &block)

controller.send(@filter, &block)

end

end

Convention-Oriented Coding

class CreditCard

def validate

validate_number

validate_expiration

end

private

def validate_number

...

end

def validate_expiration

...

end

end

def validate

methods.grep /^validate_/ do |m|

self.send m

end

end

class CreditCard

validate :number, :expiration

end

def validate(*validations)

validations.each do |v|

self.send "validate_#{v}"

end

end

You can define methods on the fly too! define_method :say_hello do puts "Hello World!" end

define_method

Defines an instance method on a class

Can define class methods via singleton

Great for writing declarative code

Dynamic Method Definition in Action class Person attr_reader :name, sex end class Person { string name, sex; public string Name { get {return name;} } public string Sex { get {return sex;} } }

Dynamic Method Definition in Action class Object def Object.attr_reader(*attrs) attrs.each do |attr| define_method(attr) do instance_variable_get("@#{attr}") end end end end

Another example: Lazy Loading class Person List<Person> friends; public List<Person> Friends { get { friends = friends ?? LoadFriends(); return friends; } }

Lazy Loading class Person lazy_loaded_attr :friends end

Lazy Loading class Object def self.lazy_loaded_attr(*attrs) attrs.each do |attr| define_method(attr) do eval "@#{attr} ||= load_#{attr}" end end end end

Lazy Loading class Person lazy_loaded_attr :friends, :children, :parents end class Person List<Person> friends, children, parents; public List<Person> Friends { get { friends = friends ?? LoadFriends(); return friends; } } public List<Person> Children { get { children = children ?? LoadChildren(); return children; } } public List<Person> Parents { get { parents = parents ?? LoadParents(); return parents; } } }

Declarative code class Album < ActiveRecord::Base has_many :tracks belongs_to :artist acts_as_taggable has_many :lyrics, :through => :tracks end

Declarative code with define_method class Album < ActiveRecord::Base has_many :tracks end class Album < ActiveRecord::Base def tracks Track.find :all, :conditions => "album_id=#{id}" end end define_method :tracks …

Declarative code with define_method class ActiveRecord::Base def self.has_many(records) define_method(records) do foreign_key = "#{self.name.underscore}_id" klass = records.to_s.classify.constantize klass.find :all, :conditions => "#{foreign_key}=#{id}" end end end

Person Person walk() define_method :walk define_method :everyone ? Person everyone() Define instance method: Define class method:

Person Person walk() define_method :walk define_method :everyone Person' Person' everyone() Define instance method: Define class method:

Person Person walk() define_method :walk define_method :everyone Person' Person' everyone() Define instance method: Define class method: Person everyone()

Dynamic methods

Outline

Ruby Object Model II

You can open any object and define methods on it.

Developer = Class.new Developer.instance_eval do def pairing “julie and farooq are pairing" end end

Developer.class_eval do def write_code “type type type" end end Developer.write_code #=> undefined method ‘write_code’ for Foo:Class Developer.new. write_code #=> “type type type" Developer.pairing #=> " julie and farooq are pairing" Developer.new.pairing #=> undefined method ‘baz’ for #<Foo:0x7dce8>

Ruby Object Model II

We’ve now opened and defined methods on both the instance of Class Developer and all instances of Class Developer.

When you define methods on an instance of an object, you are defining them on it’s ‘metaclass’ or singleton.

Dynamic methods

Method aliasing

Outline

Method Aliasing

Clones a method

Popularly used in decorators

AOP "around advice"

LISP around method combinator

Monkey patches

class LoginService alias_method :original_login, :login end

Decorator Pattern with Aliasing class LoginService alias_method :original_login, :login def login(user,pass) log_event "#{user} logging in" original_login(user,pass) end end

Decorator Pattern with Aliasing class LoginService alias_method_chain :login, :logging def login_with_logging(user,pass) log_event "#{user} logging in" login_without_logging(user,pass) end end

Dynamic methods

Outline

Evaluation Techniques

Evaluate code at runtime

In instance and class scopes

With different block bindings

eval, instance_eval, class_eval, module_eval

eval

Evaluates a string

> eval "foo = 5" > foo => 5

Optional binding

def get_binding(str) return binding end str = "hello" eval "str + ' Fred'" ! "hello Fred" eval "str + ' Fred'", get_binding("bye") ! "bye Fred"

Dynamic methods

Outline

Hooks

Allow you to trap some event, such as object creation…

Example – adding a timestamp to every object created. (Taken from the pickaxe)

class Object

attr_accessor :timestamp

end

class Class

alias_method :old_new, :new

def new(*args)

result = old_new(*args)

result.timestamp = Time.now

result

end

end

Hooks

You can know when a Module was included in another Object definition.

module A

def A.included(mod)

puts "#{self} included in #{mod}“

end

end

module Enumerable

include A

end

This is done via a call to append_features on the module doing the including

Hooks

method_missing

method_added

method_removed

You can hook into any of these and perform some operation when something happens to object under consideration.

class Foo

def method_missing(methodname, *args) #log something

#handle in some way

end end

Hooks

Can allow you to hook into how your plugins are intialized with Rails.

Rails uses something called Rails::Plugin::Loader

You can hook into this

Rails::Initializer.run do |config|

config.plugin_loader = PluginLoaderWithDependencies

End

Similarly, hooking into other framework type stuff (like ActiveRecord or even Subversion) is possible

Metaprogramming with Ruby

No longer black magic

Fresh design patterns

Declarative programming

Higher level of abstraction

Tone down the YAGNI

Questions?

Metaprogramming With Ruby

1 comments

Notes on slide 1

13 Favorites