Eloquent Ruby - Chapter 11: Metaprogramming

Handling Missing Methods: method_missing

The `method_missing` method is invoked when a method call cannot be found within the current object. You can use it to implement default behavior, delegate to another object, or raise an error. This is especially valuable for defining custom behavior for objects that represent external systems or data sources.

class Book
  def initialize(title, author)
    @title = title
    @author = author
  end

  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("get_")
      attribute = method_name.to_s.gsub("get_", "")
      instance_variable_get("@#{attribute}")
    else
      super
    end
  end
end

book = Book.new("The Lord of the Rings", "J.R.R. Tolkien")
puts book.get_title # Output: The Lord of the Rings

Here, we implement `method_missing` to handle methods starting with "get_", retrieving the corresponding instance variable. This allows us to access attributes using a more natural syntax like `book.get_title`.

Class Evaluation: class_eval

The `class_eval` method allows you to execute Ruby code within the context of a class or module. This gives you the flexibility to modify its definition dynamically.

class Animal
  def speak
    "Generic animal sound"
  end
end

Animal.class_eval do
  def bark
    "Woof!"
  end
end

dog = Animal.new
puts dog.bark # Output: Woof!

In this code, we use `class_eval` to add the `bark` method to the `Animal` class. Now, any instance of `Animal` can call the `bark` method, demonstrating how to extend classes dynamically.

Monkey Patching: Modifying Existing Classes

Monkey patching refers to the practice of modifying existing classes and modules at runtime. While powerful, it can be risky if not handled carefully. It's crucial to understand the potential side effects and use it judiciously.

class String
  def capitalize_words
    self.split.map(&:capitalize).join(' ')
  end
end

puts "hello world".capitalize_words # Output: Hello World

This example adds the `capitalize_words` method to the `String` class, allowing any string to be capitalized easily. Be cautious when monkey patching as it might affect other parts of your code.

Metaprogramming Techniques and Best Practices

Metaprogramming is a powerful tool, but it comes with its own set of considerations:

• Clarity and Readability: Metaprogrammed code can become complex and hard to understand. Aim for clarity and ensure your code is well-documented.
• Testing: Thoroughly test metaprogrammed code to ensure it works as expected and doesn't introduce unexpected behavior.
• Debugging: Debugging metaprogrammed code can be challenging. Use tools like `debugger` and understand how the runtime environment behaves.
• Overuse: Avoid using metaprogramming for simple tasks that can be achieved with standard Ruby syntax. Use it strategically for complex and repetitive operations.

Example: Building a Simple DSL

Let's build a simple DSL for defining and executing basic arithmetic operations using metaprogramming:

class Calculator
  def initialize
    @operations = {}
  end

  def define_operation(name, █)
    @operations[name] = block
  end

  def calculate(name, *args)
    @operations[name].call(*args)
  end
end

calc = Calculator.new

calc.define_operation(:add) { |x, y| x + y }
calc.define_operation(:subtract) { |x, y| x - y }

puts calc.calculate(:add, 5, 3)  # Output: 8
puts calc.calculate(:subtract, 10, 2) # Output: 8

This DSL allows you to define new operations using `define_operation` and then execute them using `calculate`. This illustrates how metaprogramming can simplify the creation of custom languages tailored to specific tasks.

Conclusion

Metaprogramming is a powerful technique in Ruby that unlocks a world of possibilities. It enables you to write flexible, adaptable, and reusable code, while also empowering you to create your own domain-specific languages. Remember to use it responsibly, prioritize clarity, and test your metaprogrammed code thoroughly. By mastering these principles, you can unlock the full potential of Ruby's metaprogramming capabilities.