Metaprogramming Basics

🪄 Metaprogramming Basics

📞 send — Calling a Method by Name

Copyname = "ruby"

name.send(:upcase)              # => "RUBY"  -- same as name.upcase
name.send("upcase")             # => "RUBY"  -- a string works too

method_name = :reverse
name.send(method_name)          # => "ybur"  -- the whole point: the method name is a variable

send calls a method whose name is only known at runtime — as a symbol or a string, computed however you like. This is directly comparable to PHP's variable method call syntax $obj->{$methodName}() or Python's getattr(obj, name)().

❓ respond_to? — Checking Before You Call

Copyname = "ruby"

if name.respond_to?(:upcase)
  puts name.upcase
end

5.respond_to?(:upcase)   # => false  -- Integer has no upcase method

respond_to? checks whether an object has a given method — the equivalent of PHP's method_exists() or Python's hasattr(). It's especially useful paired with send, when you're calling a dynamically-chosen method name and want to confirm it's actually valid first.

🏭 define_method — Generating Methods at Runtime

Copyclass Product
  [:name, :price, :sku].each do |attribute|
    define_method(attribute) do
      @data[attribute]
    end
  end

  def initialize(data)
    @data = data
  end
end

p = Product.new(name: "Widget", price: 9.99, sku: "W-001")
p.name    # => "Widget"
p.price   # => 9.99

define_method generates a real, ordinary instance method — indistinguishable afterward from one written with def — but from inside a loop, driven by data instead of hand-typed one at a time. This is, in effect, a more flexible version of Chapter 6's attr_accessor: attr_accessor is really just a convenience method that calls something conceptually similar to define_method internally.

👻 method_missing — Handling Calls to Undefined Methods

Every method call Ruby can't find triggers a special hook method called method_missing before raising NoMethodError. Override it, and you can intercept and handle calls to methods that were never explicitly defined at all:

Copyclass GhostResponder
  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("ask_")
      "You asked about: #{method_name.to_s.sub('ask_', '')}"
    else
      super   # important -- let genuinely unhandled calls raise normally
    end
  end

  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?("ask_") || super
  end
end

ghost = GhostResponder.new
ghost.ask_weather    # => "You asked about: weather"  -- ask_weather was never defined!
ghost.respond_to?(:ask_anything)   # => true

PHP's closest equivalent is the __call/__callStatic magic methods; Python's is __getattr__. Ruby's method_missing plays the same conceptual role in each language's metaprogramming toolkit.

🌍 Where This Actually Gets Used

This isn't just a party trick. Rails' ActiveRecord famously used method_missing-based "dynamic finders" (find_by_name, find_by_email — one method handling infinitely many possible attribute names) for years before switching to define_method-based generation for better performance and clearer error messages. Ruby's standard library OpenStruct class — an object you can assign arbitrary attributes to on the fly — is built on exactly this mechanism.

📜 Metaprogramming Hooks, Side by Side

💻 Coding Challenges

🎯 What's Next

Next chapter: Object Equality & Comparable — ==, eql?, hash, the spaceship operator <=>, and mixing in the Comparable module to get <, >, and between? for free.