ruby metaprogramming method_missing define_method dsl

Metaprogramming with method_missing and define_method

Sarah Mitchell Feb 2026

3 tabs

class DynamicFinder
  def initialize(records)
    @records = records
  end

  def method_missing(method_name, *args, &block)
    if method_name.to_s =~ /^find_by_(.+)$/
      attribute = $1
      find_by_attribute(attribute, 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

  private

  def find_by_attribute(attribute, value)
    @records.find { |record| record[attribute.to_sym] == value }
  end
end

# Usage:
users = [
  { id: 1, name: 'Alice', email: 'alice@example.com' },
  { id: 2, name: 'Bob', email: 'bob@example.com' }
]

finder = DynamicFinder.new(users)
finder.find_by_name('Alice')   # => { id: 1, name: 'Alice', ... }
finder.find_by_email('bob@example.com')  # => { id: 2, ... }

class QueryBuilder
  attr_reader :conditions

  def initialize
    @conditions = []
  end

  def self.build(&block)
    builder = new
    builder.instance_eval(&block)
    builder
  end

  def where(field, value)
    @conditions << { field: field, operator: '=', value: value }
    self
  end

  def greater_than(field, value)
    @conditions << { field: field, operator: '>', value: value }
    self
  end

  def less_than(field, value)
    @conditions << { field: field, operator: '<', value: value }
    self
  end

  def to_sql
    conditions.map { |c| "#{c[:field]} #{c[:operator]} #{c[:value]}" }.join(' AND ')
  end
end

# Usage with DSL:
query = QueryBuilder.build do
  where :status, 'active'
  greater_than :age, 18
  less_than :score, 100
end

puts query.to_sql
# => "status = active AND age > 18 AND score < 100"

class Configuration
  SETTINGS = %i[database cache storage email].freeze

  SETTINGS.each do |setting|
    # Getter
    define_method(setting) do
      instance_variable_get("@#{setting}")
    end

    # Setter
    define_method("#{setting}=") do |value|
      instance_variable_set("@#{setting}", value)
    end

    # Predicate
    define_method("#{setting}?") do
      !!instance_variable_get("@#{setting}")
    end
  end

  def configure(&block)
    instance_eval(&block)
    self
  end
end

# Usage:
config = Configuration.new.configure do
  self.database = 'postgresql'
  self.cache = 'redis'
  self.email = 'sendgrid'
end

config.database?  # => true
config.storage?   # => false

3 files · ruby Explain with highlit

Ruby's metaprogramming enables dynamic method definition and interception. method_missing catches undefined method calls, allowing DSL creation and proxy patterns. I implement it carefully with respond_to_missing? for proper introspection. define_method creates methods dynamically at runtime, useful for reducing repetition. Class and instance variables can be manipulated via class_variable_set and instance_variable_set. send and public_send invoke methods dynamically. Metaprogramming powers Rails' magic—associations, validations, callbacks. I use it judiciously to create expressive APIs without sacrificing clarity. Understanding Ruby's object model—classes are objects, methods are objects—unlocks powerful patterns. Metaprogramming reduces boilerplate while maintaining Ruby's elegance and readability.