Why metaprogramming is powerful in Ruby - See It in Action

Why metaprogramming is powerful in Ruby

📖 Scenario: Imagine you are building a simple contact list app. You want to add many similar methods to handle different contact details like phone, email, and address without writing repetitive code.

🎯 Goal: You will create a Ruby class that uses metaprogramming to dynamically add methods for different contact details. This will show how metaprogramming helps write less code and keep it flexible.

📋 What You'll Learn

Create a Ruby class called Contact with a hash to store details

Add a list of detail types in a variable called details

Use define_method inside a loop to create getter methods for each detail type

Print the values of the contact details using the dynamically created methods

💡 Why This Matters

🌍 Real World

Metaprogramming is used in Ruby frameworks like Rails to create flexible code that adapts to different data and needs without rewriting methods.

💼 Career

Understanding metaprogramming helps you work with advanced Ruby codebases and build reusable, clean code in professional Ruby development.

1

Create the Contact class with details hash

Create a Ruby class called Contact with an initialize method that sets an instance variable @details to a hash with these exact entries: phone: '123-456-7890', email: '[e-mail]', address: '123 Ruby St'.

Ruby

class Contact
  def initialize
    # Your code here
  end
end

Need a hint?

Use @details = { phone: '123-456-7890', email: '[e-mail]', address: '123 Ruby St' } inside initialize.

2

Add a details list variable

Inside the Contact class but outside any method, create a variable called details and set it to an array with these exact symbols: :phone, :email, :address.

Ruby

class Contact
  details = [:phone, :email, :address]

  def initialize
    @details = { phone: '123-456-7890', email: '[e-mail]', address: '123 Ruby St' }
  end
  # Your code here
end

Need a hint?

Define details = [:phone, :email, :address] inside the class but outside methods.

3

Use define_method to create getter methods

Use a details.each do |detail| loop inside the Contact class (but outside methods) to create getter methods dynamically. Inside the loop, use define_method(detail) that returns @details[detail].

Ruby

class Contact
  details = [:phone, :email, :address]

  def initialize
    @details = { phone: '123-456-7890', email: '[e-mail]', address: '123 Ruby St' }
  end

  # Your code here
end

Need a hint?

Use details.each do |detail| and inside it define_method(detail) { @details[detail] }.

4

Create an instance and print contact details

Create an instance of Contact called contact. Then print the values of contact.phone, contact.email, and contact.address each on its own line using puts.

Ruby

class Contact
  details = [:phone, :email, :address]

  def initialize
    @details = { phone: '123-456-7890', email: '[e-mail]', address: '123 Ruby St' }
  end

  details.each do |detail|
    define_method(detail) do
      @details[detail]
    end
  end
end

# Your code here

Need a hint?

Create contact = Contact.new and print each detail with puts contact.phone, etc.