thebushidocollective Ruby Metaprogramming
Master Ruby's powerful metaprogramming capabilities to write code that writes code. Ruby's dynamic nature makes it exceptionally good at metaprogramming.
Dynamic Method Definition
define_method
class Person
[:name, :age, :email].each do |attribute|
define_method(attribute) do
instance_variable_get("@#{attribute}")
end
define_method("#{attribute}=") do |value|
instance_variable_set("@#{attribute}", value)
end
end
end
person = Person.new
person.name = "Alice"
puts person.name # "Alice"
class_eval and instance_eval
# class_eval - Evaluates code in context of a class
class MyClass
end
MyClass.class_eval do
def hello
"Hello from class_eval"
end
end
puts MyClass.new.hello
# instance_eval - Evaluates code in context of an instance
obj = Object.new
obj.instance_eval do
def greet
"Hello from instance_eval"
end
end
puts obj.greet
module_eval
module MyModule
end
MyModule.module_eval do
def self.info
"Module metaprogramming"
end
end
puts MyModule.info
Method Missing
Basic method_missing
class DynamicFinder
def initialize(data)
@data = data
end
def method_missing(method_name, *args)
if method_name.to_s.start_with?("find_by_")
attribute = method_name.to_s.sub("find_by_", "")
@data.find { |item| item[attribute.to_sym] == args.first }
else
super
end
end
def respond_to_missing?(method_name, include_private = false)
method_name.to_s.start_with?("find_by_") || super
end
end
users = [
{ name: "Alice", age: 30 },
{ name: "Bob", age: 25 }
]
finder = DynamicFinder.new(users)
puts finder.find_by_name("Alice") # {:name=>"Alice", :age=>30}
Const Missing
class DynamicConstants
def self.const_missing(const_name)
puts "Constant #{const_name} not found, creating it..."
const_set(const_name, "Dynamic value for #{const_name}")
end
end
puts DynamicConstants::SOMETHING # "Dynamic value for SOMETHING"
send and public_send
class Calculator
def add(x, y)
x + y
end
private
def secret_method
"This is private"
end
end
calc = Calculator.new
# send can call any method (including private)
puts calc.send(:add, 3, 4) # 7
puts calc.send(:secret_method) # "This is private"
# public_send only calls public methods
puts calc.public_send(:add, 3, 4) # 7
# calc.public_send(:secret_method) # NoMethodError
Class Macros
class ActiveModel
def self.attr_with_history(attribute)
define_method(attribute) do
instance_variable_get("@#{attribute}")
end
define_method("#{attribute}=") do |value|
history = instance_variable_get("@#{attribute}_history") || []
history << value
instance_variable_set("@#{attribute}_history", history)
instance_variable_set("@#{attribute}", value)
end
define_method("#{attribute}_history") do
instance_variable_get("@#{attribute}_history") || []
end
end
end
class Person < ActiveModel
attr_with_history :name
end
person = Person.new
person.name = "Alice"
person.name = "Alicia"
puts person.name_history.inspect # ["Alice", "Alicia"]
Singleton Methods
obj = "hello"
# Define method on single instance
def obj.shout
self.upcase + "!!!"
end
puts obj.shout # "HELLO!!!"
# Using define_singleton_method
obj.define_singleton_method(:whisper) do
self.downcase + "..."
end
puts obj.whisper # "hello..."
Eigenclass (Singleton Class)
class Person
def self.species
"Homo sapiens"
end
end
# Accessing eigenclass
eigenclass = class << Person
self
end
puts eigenclass # #<Class:Person>
# Adding class methods via eigenclass
class Person
class << self
def count
@@count ||= 0
end
def increment_count
@@count ||= 0
@@count += 1
end
end
end
Person.increment_count
puts Person.count # 1
Reflection and Introspection
Object Introspection
class MyClass
def public_method; end
protected
def protected_method; end
private
def private_method; end
end
obj = MyClass.new
# List methods
puts obj.methods.include?(:public_method)
puts obj.private_methods.include?(:private_method)
puts obj.protected_methods.include?(:protected_method)
# Check method existence
puts obj.respond_to?(:public_method) # true
puts obj.respond_to?(:private_method) # false
puts obj.respond_to?(:private_method, true) # true (include private)
# Get method object
method = obj.method(:public_method)
puts method.class # Method
Class Introspection
class Parent
def parent_method; end
end
class Child < Parent
def child_method; end
end
# Inheritance chain
puts Child.ancestors # [Child, Parent, Object, Kernel, BasicObject]
# Instance methods
puts Child.instance_methods(false) # Only Child's methods
# Class variables and instance variables
class Person
@@count = 0
def initialize(name)
@name = name
end
end
puts Person.class_variables # [:@@count]
person = Person.new("Alice")
puts person.instance_variables # [:@name]
Hook Methods
Inheritance Hooks
class BaseClass
def self.inherited(subclass)
puts "#{subclass} inherited from #{self}"
subclass.instance_variable_set(:@inherited_at, Time.now)
end
end
class ChildClass < BaseClass
end
# Output: ChildClass inherited from BaseClass
Method Hooks
module Monitored
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def method_added(method_name)
puts "Method #{method_name} was added to #{self}"
end
def method_removed(method_name)
puts "Method #{method_name} was removed from #{self}"
end
end
end
class MyClass
include Monitored
def my_method
end
# Output: Method my_method was added to MyClass
end
included and extended
module MyModule
def self.included(base)
puts "#{self} included in #{base}"
base.extend(ClassMethods)
end
def self.extended(base)
puts "#{self} extended by #{base}"
end
module ClassMethods
def class_method
"I'm a class method"
end
end
def instance_method
"I'm an instance method"
end
end
class MyClass
include MyModule # Adds instance_method as instance method
end
class AnotherClass
extend MyModule # Adds instance_method as class method
end
DSL Creation
class RouteBuilder
def initialize
@routes = {}
end
def get(path, &block)
@routes[path] = { method: :get, handler: block }
end
def post(path, &block)
@routes[path] = { method: :post, handler: block }
end
def routes
@routes
end
end
# DSL usage
builder = RouteBuilder.new
builder.instance_eval do
get "/users" do
"List of users"
end
post "/users" do
"Create user"
end
end
puts builder.routes
Dynamic Class Creation
# Create class dynamically
MyClass = Class.new do
define_method :greet do
"Hello from dynamic class"
end
end
puts MyClass.new.greet
# Create class with inheritance
Parent = Class.new do
def parent_method
"From parent"
end
end
Child = Class.new(Parent) do
def child_method
"From child"
end
end
child = Child.new
puts child.parent_method
puts child.child_method
Object Extension
module Greetable
def greet
"Hello!"
end
end
obj = Object.new
obj.extend(Greetable)
puts obj.greet # "Hello!"
# Only this instance has the method
another_obj = Object.new
# another_obj.greet # NoMethodError
Binding and eval
def get_binding(param)
local_var = "local value"
binding
end
b = get_binding("test")
# Evaluate code in the binding context
puts eval("param", b) # "test"
puts eval("local_var", b) # "local value"
# instance_eval with binding
class MyClass
def initialize
@value = 42
end
end
obj = MyClass.new
puts obj.instance_eval { @value } # 42
TracePoint
trace = TracePoint.new(:call, :return) do |tp|
puts "#{tp.event}: #{tp.method_id} in #{tp.defined_class}"
end
trace.enable
def my_method
"Hello"
end
my_method
trace.disable
Best Practices
- Use metaprogramming sparingly - it can make code hard to understand
- Always implement respond_to_missing? when using method_missing
- Prefer define_method over class_eval when possible
- Document metaprogramming heavily - it's not obvious what's happening
- Use public_send over send to respect visibility
- Cache metaprogrammed methods to avoid repeated definition
- Test metaprogrammed code thoroughly - bugs can be subtle
Anti-Patterns
❌ Don't overuse method_missing - it's slow and hard to debug ❌ Don't use eval with user input - major security risk ❌ Don't metaprogram when simple code works - clarity over cleverness ❌ Don't forget to call super in method_missing ❌ Don't create methods without documenting them - IDE support breaks
Common Use Cases
- ORMs (ActiveRecord) - Dynamic finders, associations
- DSLs - Route definitions, configurations
- Decorators - Method wrapping and enhancement
- Mocking/Stubbing - Test frameworks
- Attribute definition - Custom accessors with behavior
Related Skills
- ruby-oop - Understanding classes and modules
- ruby-blocks-procs-lambdas - For callbacks and dynamic behavior
- ruby-gems - Many gems use metaprogramming extensively