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.

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

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

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

Convention-Oriented Coding def validate methods.grep /^validate_/ do |m| self.send m end end

Convention-Oriented Coding class CreditCard validate :number, :expiration end

Convention-Oriented Coding 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()

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.

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 Evaluation techniques Object lifecycle hooks and method_missing 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

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"

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

Metaprogramming With Ruby

Recommended

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Metaprogramming With Ruby (20)

Recently uploaded (20)

Metaprogramming With Ruby