Metaprogramming in Ruby

Things I Wish I Knew
When I Started Ruby

Who?
Joshua Hull
@jj
https://github.com/joshbuddy

What?

Writing programs that write programs.

What?

Writing programs that write programs.
NOT code generation!

Why?
We all do it.
Ruby attr_accessor :my_attribute

Why?
We all do it.

def my_attribute
@my_attribute
end

def my_attribute=(my_attribute)
@my_attribute = my_attribute
end

Why?
We all do it.

Java public int getAttribute() {
return attribute;
}

public void setAttribute(int newAttribute) {
attribute = newAttribute;
}

Why?
We all do it.
ner
in Ruby
W attr_accessor :my_attribute

Java public int getAttribute() {
return attribute;
}

public void setAttribute(int newAttribute) {
attribute = newAttribute;
}

Why?
def age
@age || 'not set'
end

def gender
@gender || 'not set'
end

def name
@name || 'not set'
end

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

Drawbacks
You can write some difﬁcult-to-understand code.

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
self.attr_accessor :name

def say_hello
puts "hello"
puts name
end
end

Method dispatch

class MyObject

Who is self self.attr_accessor :name

here? def say_hello
puts "hello"
puts name
end
end

Method dispatch

class MyObject

Who is self self.attr_accessor :name

here? def say_hello
puts "hello"
The class puts name
end
is! end

Method dispatch
Module#attr

Who is self
here?
The class
is!

Ruby classes
class NewClass
def hey
puts 'hello!'
end
end

Ruby classes
class NewClass

{
def hey
puts 'hello!'
end
end
This is normal
code!

Ruby classes
class NewClass
def hey
puts 'hello!'
end
end

is the same as

NewClass = Class.new do
def hey
puts 'hello!'
end
end

Ruby classes

class ParsingError < RuntimeError
end

Ruby classes

class ParsingError < RuntimeError
end

is the same as

ParsingError = Class.new(RuntimeError)

Ruby classes
def class_with_accessors(*attributes)
Class.new do
attr_accessor *attributes
end
end

Ruby classes
Class.new do
end
end

Returns a new class!

Ruby classes
Class.new do
end
end

Returns a new class!

class Person < class_with_accessors(:name, :age, :sex)
# ...
end

eval, instance_eval,
class_eval

class_eval
Method
eval

instance_eval

class_eval

class_eval
Method Context
eval your current context

instance_eval the object

class_eval the object’s class

class_eval
eval
eval "puts 'hello'"

# hello

class_eval
instance_eval
class MyClass
end

MyClass.instance_eval("def hi; 'hi'; end")

class_eval
instance_eval
class MyClass
end

MyClass.instance_eval("def hi; 'hi'; end")

MyClass.hi
# 'hi'

class_eval
instance_eval
class MyClass
end

MyClass.instance_eval("def hi; 'hi' end")

obj = MyClass.new
# <MyClass:0x10178aff8>
obj.hi
# NoMethodError: undefined method `hi' for #<MyClass>

class_eval
class_eval
class MyClass
end

MyClass.class_eval("def hi; 'hi' end")

class_eval
class_eval
class MyClass
end


MyClass.hi
# NoMethodError: undefined method `hi' for MyClass:Class

class_eval
class_eval
class MyClass
end


obj = MyClass.new
# <MyClass:0x101849688>
obj.hi
# "hi"

class_eval
class_eval instance_eval
class MyClass class MyClass
end end

MyClass.class_eval("def hi; 'hi'; end") MyClass.instance_eval("def hi; 'hi'; end")

obj = MyClass.new MyClass.hi
# <MyClass:0x101849688> # 'hi'
obj.hi
# "hi"

class_eval

Ninja’s will attack you if ...
you don’t use __FILE__, __LINE__

class_eval
class HiThere
end

HiThere.class_eval "def hi; raise; end"
HiThere.class_eval "def hi_with_niceness; raise; end", __FILE__, __LINE__

HiThere.new.hi
HiThere.new.hi_with_niceness

class_eval
class HiThere
end


HiThere.new.hi

(eval):1:in `hi': unhandled exception
from my_file.rb:7

my_file.rb:5:in `hi_with_niceness': unhandled exception
from my_file.rb:7

class_eval
class HiThere
end


HiThere.new.hi

(eval):1:in `hi': unhandled exception
from my_file.rb:7
So nice. <3

my_file.rb:5:in `hi_with_niceness': unhandled exception
from my_file.rb:7

class_eval

Implement attr_accessor!

class_eval
class Module
def create_attr(attribute)
class_eval("def #{attribute}; @#{attribute}; end")
end
end

class_eval
class Module
end
end

class M
create_attr :hi
end

class_eval
class Module
end
end
def M
class M def hi
create_attr :hi @hi
end end
end

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

Deﬁning methods
For an object
o = Object.new
o.just_this_object

Object.new.just_this_object
# NoMethodError: undefined method `just_this_object'

Deﬁning methods
For an object
o = Object.new
o.just_this_object

Object.new.just_this_object
# NoMethodError: undefined method `just_this_object'

o = Object.new
o.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 class

MyClass = Class.new

class MyClass
def new_method
end
end

MyClass.new.respond_to?(:new_method) # true

Deﬁning methods
For a class

MyClass = Class.new

MyClass.class_eval " MyClass.class_eval do
def new_method def new_method
end end
" end

MyClass.send(:define_method, :new_method) {
# your method body
}

Deﬁning methods
Aliasing
Module#alias_method

Scoping
module Project
class Main
def run
# ...
end
end
end

Scoping
module Project
class Main
def run
# ...
end
end
end

Class definitions
Module definitions
Method definitions

Scoping
a = 'hello'

module Project
class Main
def run
puts a
end
end
end

Project::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
end

Project::Main.new.run # => hello

Scoping
Example: Connection Sharing
module 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
end
end

Scoping
Example: Connection Sharing
module 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
end
end

Client = Class.new
AddConnections.add_connection_methods(Client, 'localhost', 8080)

Client.new.get_connection # Getting connection for localhost:8080
Client.new.host # localhost
Client.new.port # 8080

Scoping
Kernel#binding
Let’s you leak the current “bindings”

Scoping
Kernel#binding

def create_connection(bind)
eval '
connection = "I am a connection"
', bind
end

connection = nil
create_connection(binding)
connection # => I am a connection

Scoping
Kernel#binding

eval '
', bind
end

Calls connection = nil
with the create_connection(binding)
current connection # => I am a connection
state

Scoping
Kernel#binding

eval '
', bind
end

Calls connection = nil
with the create_connection(binding)
current connection # => I am a connection
state
MAGIC!

Scoping
Kernel#binding

eval '
', bind
end

# connection = nil
connection
# undefined local variable or method `connection'

Scoping
Kernel#binding

eval '
', bind
end

# connection = nil
connection

You can’t add to the local variables via binding

Scoping
Kernel#binding

eval '
', bind
end

eval "connection = nil"
connection

You can’t add to the local variables via eval

Scoping
Kernel#binding
TOPLEVEL_BINDING

Scoping
Kernel#binding
TOPLEVEL_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!
class MethodMissing
def method_missing(m, *args, &blk)
puts "method_missing #{m} #{args.inspect} #{blk.inspect}"
super
end
end

Interception!
class MethodMissing
puts "method_missing #{m} #{args.inspect} #{blk.inspect}"
super
end
end

mm = MethodMissing.new
mm.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: Timing
module MethodsWithTiming
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

Interception!
Example: Timing
respond = nil
}
respond
else
super
end
end
end

sc = SlowClass.new
class 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: Proxy
class Proxy
def initialize(backing)
@backing = backing
end

@backing.send(m, *args, &blk)
end
end

Interception!
Example: Proxy
class LoggingProxy
def initialize(backing)
@backing = backing
end

puts "Calling method #{m} with #{args.inspect}"
@backing.send(m, *args, &blk)
end
end

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!
Example: Timing
alias_method :original_respond_to?, :respond_to?

if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and original_respond_to?(timed_method)
respond = nil
}
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)
end
end

Interception!
Example: Timing

ge ts
alias_method :original_respond_to?, :respond_to?

It

r!
if timed_method = m.to_s[/^(.*)_with_timing$/, 1] and original_respond_to?(timed_method)

te
respond = nil

et

b
}
respond
else
super
end
end

def respond_to?(sym)
original_respond_to?(timed_method.to_sym) :
original_respond_to?(sym)
end
end

Interception!
Object#respond_to_missing?(sym) (1.9 only)
Example: Timing
respond = nil
}
respond
else
super
end
end

def respond_to_missing?(sym)
respond_to?(timed_method.to_sym) :
super
end
end

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: Loader
class 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 "can't find #{file}, sorry!"
super
end
end
end

Interception!
Example: Loader
class Loader
require file
else
super
end
end
end

Interception!
Example: Loader
class Loader
require file
else
super
end
end
end

Loader::Auto
# can't find ./auto.rb, sorry!
# NameError: uninitialized constant Loader::Auto

# or, if you have an ./auto.rb
Loader::Auto
# => Auto

Callbacks
Module#method_added
class 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

Callbacks
Module#method_added
class 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

Callbacks
Module#method_added
Example: 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 isn't documented" :
"This action doesn't exist"
end

desc "Start server"
def start
end

def stop
end
end

Callbacks
Module#method_added
Example: Thor! Record the description
class 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
@desc = nil
end Provide the description for a
method, or, if not found, some
method_defined?(m) ? default string.
end

desc "Start server"
def start
end

def stop
end
end

Callbacks
Module#method_added
Example: Thor! Record the description
class 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
@desc = nil
end Provide the description for a
method, or, if not found, some
method_defined?(m) ? default string.
end

desc "Start server"
def start
end
Described!
def stop
end
end

Callbacks
Module#method_added
Example: 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 isn't documented
def self.method_added(m) puts Tasks.method_description(:restart)
(@method_descs ||= {})[m] = @desc # => This action doesn't exist
@desc = nil
end

method_defined?(m) ?
end

desc "Start server"
def start
end

def stop
end
end

Callbacks
Object#singleton_method_added

Callbacks
class ClassWithMethods
def self.singleton_method_added(m)
puts "ADDING! #{m}"
end

def self.another
end
end

Callbacks
puts "ADDING! #{m}"
end

def self.another
end
end

# ADDING! singleton_method_added
# ADDING! another

Callbacks
puts "ADDING! #{m}"
end

def self.another
end
end
Holy meta!
# ADDING! singleton_method_added
# ADDING! another

Callbacks
Module#included
module Logger
def self.included(m)
puts "adding logging to #{m}"
end
end

class Server
include Logger
end

# adding logging to Server

Callbacks
Module#included
Example: ClassMethods pattern
module 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
end
end

Server.create
# `create': undefined method `log' for Server:Class (NoMethodError)

Callbacks
Module#included
Example: ClassMethods pattern
module 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
end
end

Server.create
# LOG: Creating server!

Callbacks
Module#extended
module One
def self.extended(obj)
puts "#{self} has been extended by #{obj}"
end
end

Object.new.extend(One)

# One has been extended by #<Object:0x1019614a8>

Callbacks
Class#inherited
class Parent
def self.inherited(o)
puts "#{self} was inherited by #{o}"
end
end

class Child < Parent
end

# Parent was inherited by Child

Callbacks
Guarding callbacks
Module#append_features include
Module#extend_object extend
def self.extend_object(o)
super
end

def self.append_features(o)
super
end

Callbacks
Guarding callbacks
Module#append_features include
Module#extend_object extend
def self.append_features(o)
o.instance_method(:<=>) ? super : warn('you no can uze')
end

Callbacks
Kernel#caller
def one
two
end

def two
method name
three
ﬁle name line (optional)
end

def three
p caller
end

# ["method.rb:156:in `two'", "method.rb:152:in `one'", "method.rb:163"]

https://github.com/joshbuddy/callsite

Callbacks
Module#nesting
module A
module B
module C
p Module.nesting
end
end
end

# [A::B::C, A::B, A]

There and back again, a
parsing tale

parsing tale

gem install ruby_parser
gem install sexp_processor
gem install ruby2ruby

Let’s go!

parsing tale
Parsing
require 'rubygems'
require 'ruby_parser'
RubyParser.new.process("'string'")

s(:str, "string")

Type Arguments...

parsing tale
Parsing
require 'rubygems'
RubyParser.new.process("'string'")

s(:str, "string")
[:str, "string"] # Sexp

Sexp.superclass
# Array

parsing tale
Parsing

RubyParser.new.process("'string' + 'string'")

s(:call, s(:str, "string"), :+, s(:arglist, s(:str, "string")))

Method Method
Receiver Arguments
call name

parsing tale
Parsing

RubyParser.new.process("'string' + 'string'")

s(:call, nil, :puts, s(:arglist, s(:str, "hello world")))

Method Receiver Method
Arguments
call name

parsing tale
And, back again...

require 'rubygems'
require 'ruby2ruby'

Ruby2Ruby.new.process [:str, "hello"] # => "hello"

parsing tale
And, back again...

require 'rubygems'
require 'ruby2ruby'

Ruby2Ruby.new.process [:str, "hello"] # => "hello"
Ruby2Ruby.new.process [:lit, :symbol] # => :symbol

parsing tale
Roundtrip
require 'sexp_processor'
require 'ruby2ruby'

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

parsing tale
Roundtrip
def initialize
self.strict = false
super
end

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

parsing tale
Roundtrip
def initialize
self.strict = false
Process type :str
super
end

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

Metaprogramming in Ruby

More Related Content

What's hot

Viewers also liked

Similar to Metaprogramming in Ruby

More from ConFoo

Recently uploaded

Metaprogramming in Ruby