Metaprogramming in Ruby

Things I Wish I KnewWhen I Started Ruby

Who?Joshua Hull@jjhttps://github.com/joshbuddy

What?Writing programs that write programs.

What?Writing programs that write programs. NOT code generation!

Why?We all do it.

Why? We all do it.Ruby attr_accessor :my_attribute

Why? We all do it.Ruby attr_accessor :my_attribute def my_attribute @my_attribute end def my_attribute=(my_attribute) @my_attribute = my_attribute end

Why? We all do it.Ruby attr_accessor :my_attributeJava public int getAttribute() { return attribute; } public void setAttribute(int newAttribute) { attribute = newAttribute; }

Why? We all do it. ner in RubyW attr_accessor :my_attribute Java public int getAttribute() { return attribute; } public void setAttribute(int newAttribute) { attribute = newAttribute; }

Why?def age @age || not setenddef gender @gender || not setenddef name @name || not setend

Why? def age @age || not set end def gender @gender || not set end def name @name || not set end[:age, :gender, :name].each do |attr| define_method(attr) do instance_variable_get(:"@#{attr}") || not set endend

Drawbacks

DrawbacksYou can write some difﬁcult-to-understand code.

Method dispatch

Method dispatch class MyObject attr_accessor :name def say_hello puts "hello" puts name end end

Method dispatch class MyObject attr_accessor :name def say_hello puts "hello" puts name end end This is a method call, but who receives it?

Method dispatch class MyObject attr_accessor :name def say_hello puts "hello" puts self.name end end

Method dispatch class MyObject attr_accessor :name def say_hello puts "hello" puts self.name end end self is always the implied receiver!

Method dispatch class MyObject attr_accessor :name def say_hello puts "hello" puts name end end

Method dispatch class MyObject self.attr_accessor :name def say_hello puts "hello" puts name end end

Method dispatch class MyObjectWho is self self.attr_accessor :name here? def say_hello puts "hello" puts name end end

Method dispatch class MyObjectWho is self self.attr_accessor :name here? def say_hello puts "hello"The class puts name end is! end

Method dispatch Module#attrWho is self here?The class is!

Ruby classes

Ruby classesclass NewClass def hey puts hello! endend

Ruby classes class NewClass { def hey puts hello! end endThis is normal code!

Ruby classesclass NewClass def hey puts hello! endend is the same asNewClass = Class.new do def hey puts hello! endend

Ruby classesclass ParsingError < RuntimeErrorend

Ruby classesclass ParsingError < RuntimeErrorend is the same asParsingError = Class.new(RuntimeError)

Ruby classesdef class_with_accessors(*attributes) Class.new do attr_accessor *attributes endend

Ruby classesdef class_with_accessors(*attributes) Class.new do attr_accessor *attributes endend Returns a new class!

Ruby classesdef class_with_accessors(*attributes) Class.new do attr_accessor *attributes endend Returns a new class!class Person < class_with_accessors(:name, :age, :sex) # ...end

eval, instance_eval, class_eval

eval, instance_eval, class_evalMethodevalinstance_evalclass_eval

eval, instance_eval, class_evalMethod Contexteval your current contextinstance_eval the objectclass_eval the object’s class

eval, instance_eval, class_evalevaleval "puts hello"# hello

eval, instance_eval, class_evalinstance_evalclass MyClassendMyClass.instance_eval("def hi; hi; end")

eval, instance_eval, class_evalinstance_evalclass MyClassendMyClass.instance_eval("def hi; hi; end")MyClass.hi# hi

eval, instance_eval, class_evalinstance_evalclass MyClassendMyClass.instance_eval("def hi; hi end")obj = MyClass.new# <MyClass:0x10178aff8>obj.hi# NoMethodError: undefined method `hi for #<MyClass>

eval, instance_eval, class_evalclass_evalclass MyClassendMyClass.class_eval("def hi; hi end")

eval, instance_eval, class_evalclass_evalclass MyClassendMyClass.class_eval("def hi; hi end")MyClass.hi# NoMethodError: undefined method `hi for MyClass:Class

eval, instance_eval, class_evalclass_evalclass MyClassendMyClass.class_eval("def hi; hi end")obj = MyClass.new# <MyClass:0x101849688>obj.hi# "hi"

eval, instance_eval, class_evalclass_eval instance_evalclass MyClass class MyClassend endMyClass.class_eval("def hi; hi; end") MyClass.instance_eval("def hi; hi; end")obj = MyClass.new MyClass.hi# <MyClass:0x101849688> # hiobj.hi# "hi"

eval, instance_eval, class_evalNinja’s will attack you if ...you don’t use __FILE__, __LINE__

eval, instance_eval, class_evalclass HiThereendHiThere.class_eval "def hi; raise; end"HiThere.class_eval "def hi_with_niceness; raise; end", __FILE__, __LINE__HiThere.new.hiHiThere.new.hi_with_niceness

eval, instance_eval, class_evalclass HiThereendHiThere.class_eval "def hi; raise; end"HiThere.class_eval "def hi_with_niceness; raise; end", __FILE__, __LINE__HiThere.new.hiHiThere.new.hi_with_niceness(eval):1:in `hi: unhandled exception from my_file.rb:7my_file.rb:5:in `hi_with_niceness: unhandled exception from my_file.rb:7

eval, instance_eval, class_evalclass HiThereendHiThere.class_eval "def hi; raise; end"HiThere.class_eval "def hi_with_niceness; raise; end", __FILE__, __LINE__HiThere.new.hiHiThere.new.hi_with_niceness(eval):1:in `hi: unhandled exception from my_file.rb:7 So nice. <3my_file.rb:5:in `hi_with_niceness: unhandled exception from my_file.rb:7

eval, instance_eval, class_eval Implement attr_accessor!

eval, instance_eval, class_evalclass Module def create_attr(attribute) class_eval("def #{attribute}; @#{attribute}; end") endend

eval, instance_eval, class_evalclass Module def create_attr(attribute) class_eval("def #{attribute}; @#{attribute}; end") endendclass M create_attr :hiend

eval, instance_eval, class_evalclass Module def create_attr(attribute) class_eval("def #{attribute}; @#{attribute}; end") endend def Mclass M def hi create_attr :hi @hiend end end

Deﬁning methods

Deﬁning methods For an objecto = Object.newo.instance_eval("def just_this_object; end")o.just_this_object

Deﬁning methods For an objecto = Object.newo.instance_eval("def just_this_object; end")o.just_this_objectObject.new.just_this_object# NoMethodError: undefined method `just_this_object

Deﬁning methods For an objecto = Object.newo.instance_eval("def just_this_object; end")o.just_this_objectObject.new.just_this_object# NoMethodError: undefined method `just_this_objecto = Object.newo.instance_eval { def just_this_object end}

Deﬁning methods For an object o = Object.new o.extend(Module.new { def just_this_object end })

Deﬁning methods For a classMyClass = Class.newclass MyClass def new_method endendMyClass.new.respond_to?(:new_method) # true

Deﬁning methods For a classMyClass = Class.newMyClass.class_eval " MyClass.class_eval do def new_method def new_method end end" endMyClass.send(:define_method, :new_method) { # your method body}

Deﬁning methods AliasingModule#alias_method

Scoping

Scopingmodule Project class Main def run # ... end endend

Scoping module Project class Main def run # ... end end end Class definitionsModule definitionsMethod definitions

Scopinga = hellomodule Project class Main def run puts a end endendProject::Main.new.run

Scoping a = hello module Project class Main def run puts a end end end Project::Main.new.run# undefined local variable or method `a for #<Project::Main> (NameError)

Scoping module Project class Main end end a = hello Project::Main.class_eval do define_method(:run) do puts a end endProject::Main.new.run # => hello

ScopingExample: Connection Sharingmodule AddConnections def self.add_connection_methods(cls, host, port) cls.class_eval do define_method(:get_connection) do puts "Getting connection for #{host}:#{port}" end define_method(:host) { host } define_method(:port) { port } end endend

ScopingExample: Connection Sharingmodule AddConnections def self.add_connection_methods(cls, host, port) cls.class_eval do define_method(:get_connection) do puts "Getting connection for #{host}:#{port}" end define_method(:host) { host } define_method(:port) { port } end endendClient = Class.newAddConnections.add_connection_methods(Client, localhost, 8080)Client.new.get_connection # Getting connection for localhost:8080Client.new.host # localhostClient.new.port # 8080

ScopingKernel#bindingLet’s you leak the current “bindings”

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end connection = nil create_connection(binding) connection # => I am a connection

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end Calls connection = nilwith the create_connection(binding)current connection # => I am a connection state

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end Calls connection = nilwith the create_connection(binding)current connection # => I am a connection state MAGIC!

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end # connection = nil create_connection(binding) connection # undefined local variable or method `connection

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end # connection = nil create_connection(binding) connection # undefined local variable or method `connection You can’t add to the local variables via binding

ScopingKernel#bindingLet’s you leak the current “bindings” def create_connection(bind) eval connection = "I am a connection" , bind end eval "connection = nil" create_connection(binding) connection # undefined local variable or method `connection You can’t add to the local variables via eval

ScopingKernel#bindingTOPLEVEL_BINDING

ScopingKernel#bindingTOPLEVEL_BINDING a = hello module Program class Main def run puts eval("a", TOPLEVEL_BINDING) end end end Program::Main.new.run # => hello

Interception!(aka lazy magic)

Interception!method_missing(method, *args, &blk)

Interception!method_missing(method, *args, &blk)class MethodMissing def method_missing(m, *args, &blk) puts "method_missing #{m} #{args.inspect} #{blk.inspect}" super endend

Interception!method_missing(method, *args, &blk)class MethodMissing def method_missing(m, *args, &blk) puts "method_missing #{m} #{args.inspect} #{blk.inspect}" super endendmm = MethodMissing.newmm.i_dont_know_this(1, 2, 3)# method_missing i_dont_know_this [1, 2, 3] nil# NoMethodError: undefined method `i_dont_know_this for #<MethodMissing>

Interception!Example: Timingmodule MethodsWithTiming def method_missing(m, *args, &blk) if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and respond_to?(timed_method) respond = nil measurement = Benchmark.measure { respond = send(timed_method, *args, &blk) } puts "Method #{m} took #{measurement}" respond else super end endend

Interception! Example: Timing module MethodsWithTiming def method_missing(m, *args, &blk) if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and respond_to?(timed_method) respond = nil measurement = Benchmark.measure { respond = send(timed_method, *args, &blk) } puts "Method #{m} took #{measurement}" respond else super end end end sc = SlowClass.newclass SlowClass sc.slow include MethodsWithTiming def slow sleep 1 sc.slow_with_timing end # Method slow_with_timing took 0.000000 0.000000 0.000000 ( 1.000088)end

Interception!Example: Proxyclass Proxy def initialize(backing) @backing = backing end def method_missing(m, *args, &blk) @backing.send(m, *args, &blk) endend

Interception!Example: Proxyclass LoggingProxy def initialize(backing) @backing = backing end def method_missing(m, *args, &blk) puts "Calling method #{m} with #{args.inspect}" @backing.send(m, *args, &blk) endend

Interception!Example: Simple DSL class NameCollector attr_reader :names def initialize @names = [] end def method_missing(method, *args, &blk) args.empty? ? @names.push(method.to_s.capitalize) : super end end nc = NameCollector.new nc.josh nc.bob nc.jane nc.names.join( ) # => Josh Bob Jane

Interception!Object#respond_to?(sym)

Interception! Object#respond_to?(sym) Example: Timingmodule MethodsWithTiming alias_method :original_respond_to?, :respond_to? def method_missing(m, *args, &blk) if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and original_respond_to?(timed_method) respond = nil measurement = Benchmark.measure { respond = send(timed_method, *args, &blk) } puts "Method #{m} took #{measurement}" respond else super end end def respond_to?(sym) (timed_method = sym.to_s[/^(.*)_with_timing$/, 1]) ? original_respond_to?(timed_method.to_sym) : original_respond_to?(sym) endend

Interception! Object#respond_to?(sym) Example: Timingmodule MethodsWithTiming ge ts alias_method :original_respond_to?, :respond_to? It def method_missing(m, *args, &blk) r! if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and original_respond_to?(timed_method) te respond = nil et measurement = Benchmark.measure { b respond = send(timed_method, *args, &blk) } puts "Method #{m} took #{measurement}" respond else super end end def respond_to?(sym) (timed_method = sym.to_s[/^(.*)_with_timing$/, 1]) ? original_respond_to?(timed_method.to_sym) : original_respond_to?(sym) endend

Interception! Object#respond_to_missing?(sym) (1.9 only) Example: Timingmodule MethodsWithTiming def method_missing(m, *args, &blk) if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and respond_to?(timed_method) respond = nil measurement = Benchmark.measure { respond = send(timed_method, *args, &blk) } puts "Method #{m} took #{measurement}" respond else super end end def respond_to_missing?(sym) (timed_method = sym.to_s[/^(.*)_with_timing$/, 1]) ? respond_to?(timed_method.to_sym) : super endend

Interception!const_missing(sym)

Interception!const_missing(sym)MyClass::MyOtherClass# MyClass.const_missing(:MyOtherClass)

Interception!const_missing(sym)MyClass::MyOtherClass# MyClass.const_missing(:MyOtherClass)Example: Loaderclass Loader def self.const_missing(sym) file = File.join(File.dirname(__FILE__), "#{sym.to_s.downcase}.rb") if File.exist?(file) require file Object.const_defined?(sym) ? Object.const_get(sym) : super else puts "cant find #{file}, sorry!" super end endend

Interception!Example: Loaderclass Loader def self.const_missing(sym) file = File.join(File.dirname(__FILE__), "#{sym.to_s.downcase}.rb") if File.exist?(file) require file Object.const_defined?(sym) ? Object.const_get(sym) : super else puts "cant find #{file}, sorry!" super end endend

Interception!Example: Loaderclass Loader def self.const_missing(sym) file = File.join(File.dirname(__FILE__), "#{sym.to_s.downcase}.rb") if File.exist?(file) require file Object.const_defined?(sym) ? Object.const_get(sym) : super else puts "cant find #{file}, sorry!" super end endendLoader::Auto# cant find ./auto.rb, sorry!# NameError: uninitialized constant Loader::Auto# or, if you have an ./auto.rbLoader::Auto# => Auto

Callbacks

CallbacksModule#method_added

CallbacksModule#method_addedclass MyClass def self.method_added(m) puts "adding #{m}" end puts "defining my method" def my_method two end puts "done defining my method"end

CallbacksModule#method_addedclass MyClass defining my method def self.method_added(m) adding my_method puts "adding #{m}" done defining my method end puts "defining my method" def my_method two end puts "done defining my method"end

CallbacksModule#method_addedExample: Thor!class Tasks def self.desc(desc) @desc = desc end def self.method_added(m) (@method_descs ||= {})[m] = @desc @desc = nil end def self.method_description(m) method_defined?(m) ? @method_descs[m] || "This action isnt documented" : "This action doesnt exist" end desc "Start server" def start end def stop endend

CallbacksModule#method_addedExample: Thor! Record the descriptionclass Tasks def self.desc(desc) @desc = desc When a method is added, end record the description associated def self.method_added(m) with that method (@method_descs ||= {})[m] = @desc @desc = nil end Provide the description for a def self.method_description(m) method, or, if not found, some method_defined?(m) ? default string. @method_descs[m] || "This action isnt documented" : "This action doesnt exist" end desc "Start server" def start end def stop endend

CallbacksModule#method_addedExample: Thor! Record the descriptionclass Tasks def self.desc(desc) @desc = desc When a method is added, end record the description associated def self.method_added(m) with that method (@method_descs ||= {})[m] = @desc @desc = nil end Provide the description for a def self.method_description(m) method, or, if not found, some method_defined?(m) ? default string. @method_descs[m] || "This action isnt documented" : "This action doesnt exist" end desc "Start server" def start end Described! def stop endend

CallbacksModule#method_addedExample: Thor! Query your methods!class Tasks puts Tasks.method_description(:start) def self.desc(desc) # => Start server @desc = desc puts Tasks.method_description(:stop) end # => This action isnt documented def self.method_added(m) puts Tasks.method_description(:restart) (@method_descs ||= {})[m] = @desc # => This action doesnt exist @desc = nil end def self.method_description(m) method_defined?(m) ? @method_descs[m] || "This action isnt documented" : "This action doesnt exist" end desc "Start server" def start end def stop endend

CallbacksObject#singleton_method_added

CallbacksObject#singleton_method_addedclass ClassWithMethods def self.singleton_method_added(m) puts "ADDING! #{m}" end def self.another endend

CallbacksObject#singleton_method_addedclass ClassWithMethods def self.singleton_method_added(m) puts "ADDING! #{m}" end def self.another endend# ADDING! singleton_method_added# ADDING! another

CallbacksObject#singleton_method_addedclass ClassWithMethods def self.singleton_method_added(m) puts "ADDING! #{m}" end def self.another endend Holy meta!# ADDING! singleton_method_added# ADDING! another

CallbacksModule#includedmodule Logger def self.included(m) puts "adding logging to #{m}" endendclass Server include Loggerend# adding logging to Server

CallbacksModule#includedExample: ClassMethods patternmodule Logger class Server def self.included(m) include Logger puts "adding logging to #{m}" end def self.create log("Creating server!") def self.log(message) end puts "LOG: #{message}" end endendServer.create# `create: undefined method `log for Server:Class (NoMethodError)

CallbacksModule#includedExample: ClassMethods patternmodule Logger class Server def self.included(m) include Logger m.extend(ClassMethods) end def self.create log("Creating server!") module ClassMethods end def log(message) end puts "LOG: #{message}" end endendServer.create# LOG: Creating server!

CallbacksModule#extendedmodule One def self.extended(obj) puts "#{self} has been extended by #{obj}" endendObject.new.extend(One)# One has been extended by #<Object:0x1019614a8>

CallbacksClass#inheritedclass Parent def self.inherited(o) puts "#{self} was inherited by #{o}" endendclass Child < Parentend# Parent was inherited by Child

CallbacksGuarding callbacksModule#append_features includeModule#extend_object extend def self.extend_object(o) super end def self.append_features(o) super end

CallbacksGuarding callbacksModule#append_features includeModule#extend_object extenddef self.append_features(o) o.instance_method(:<=>) ? super : warn(you no can uze)end

CallbacksKernel#callerdef one twoenddef two method name three ﬁle name line (optional)enddef three p callerend# ["method.rb:156:in `two", "method.rb:152:in `one", "method.rb:163"] https://github.com/joshbuddy/callsite

CallbacksModule#nestingmodule A module B module C p Module.nesting end endend# [A::B::C, A::B, A]

There and back again, a parsing tale

There and back again, a parsing tale gem install ruby_parser gem install sexp_processor gem install ruby2ruby Let’s go!

There and back again, a parsing taleParsing require rubygems require ruby_parser RubyParser.new.process("string") s(:str, "string") Type Arguments...

There and back again, a parsing taleParsing require rubygems require ruby_parser RubyParser.new.process("string") s(:str, "string") [:str, "string"] # Sexp Sexp.superclass # Array

There and back again, a parsing taleParsing RubyParser.new.process("string + string")s(:call, s(:str, "string"), :+, s(:arglist, s(:str, "string"))) Method Method Receiver Arguments call name

There and back again, a parsing taleParsing RubyParser.new.process("string + string") s(:call, nil, :puts, s(:arglist, s(:str, "hello world"))) Method Receiver Method Arguments call name

There and back again, a parsing taleAnd, back again... require rubygems require ruby2ruby Ruby2Ruby.new.process [:str, "hello"] # => "hello"

There and back again, a parsing taleAnd, back again... require rubygems require ruby2ruby Ruby2Ruby.new.process [:str, "hello"] # => "hello" Ruby2Ruby.new.process [:lit, :symbol] # => :symbol

There and back again, a parsing taleRoundtrip require sexp_processor require ruby2ruby require ruby_parser class JarJarify < SexpProcessor def initialize self.strict = false super end def process_str(str) new_string = "YOUZA GONNA SAY #{str[-1]}" str.clear s(:str, new_string) end end

There and back again, a parsing taleRoundtrip class JarJarify < SexpProcessor def initialize self.strict = false super end def process_str(str) new_string = "YOUZA GONNA SAY #{str[-1]}" str.clear s(:str, new_string) end end ast = RubyParser.new.process(puts "hello") Ruby2Ruby.new.process(JarJarify.new.process(ast)) # => puts("YOUZA GONNA SAY hello")

There and back again, a parsing taleRoundtrip class JarJarify < SexpProcessor def initialize self.strict = false Process type :str super end def process_str(str) new_string = "YOUZA GONNA SAY #{str[-1]}" str.clear s(:str, new_string) Consume the current sexp end end Return a new one ast = RubyParser.new.process(puts "hello") Ruby2Ruby.new.process(JarJarify.new.process(ast)) # => puts("YOUZA GONNA SAY hello")

IT’S OVER!

Metaprogramming in Ruby

by ConFoo

Accessibility

Categories

Upload Details

Usage Rights

Statistics