Why metaprogramming is powerful in Ruby - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby metaprogramming code?

Consider this Ruby code that uses define_method to create methods dynamically. What will it print?

Ruby

class Greeter
  [:hello, :goodbye].each do |method_name|
    define_method(method_name) do |name|
      "#{method_name.to_s.capitalize}, #{name}!"
    end
  end
end

g = Greeter.new
puts g.hello("Alice")
puts g.goodbye("Bob")

A Hello, Alice!\nGoodbye, Bob!

B hello, Alice!\ngoodbye, Bob!

C Error: undefined method

D HELLO, Alice!\nGOODBYE, Bob!

💡 Hint

Look at how define_method uses the symbol and string interpolation.

The define_method creates methods named hello and goodbye. Each method returns a string with the method name capitalized and the given name. So it prints 'Hello, Alice!' and 'Goodbye, Bob!'.

🧠 Conceptual

intermediate

Why is metaprogramming powerful in Ruby?

Which of these best explains why metaprogramming is powerful in Ruby?

A It restricts the use of dynamic variables to prevent bugs.

B It forces all methods to be defined before the program runs, improving performance.

C It allows programs to write or modify code during runtime, enabling flexible and DRY designs.

D It automatically converts Ruby code to machine code for faster execution.

💡 Hint

Think about what it means to change code while the program is running.

Metaprogramming lets Ruby programs create or change methods and classes while running. This makes code more flexible and reduces repetition (DRY = Don't Repeat Yourself).

🔧 Debug

advanced

Find the error in this metaprogramming code

This Ruby code tries to create getter methods dynamically but raises an error. What is the cause?

Ruby

class Person
  [:name, :age].each do |attr|
    define_method(attr) do
      @attr
    end
  end
end

p = Person.new
p.name

A The instance variable should be @name or @age, not @attr.

B You cannot use define_method inside a class.

C The array [:name, :age] should be strings, not symbols.

D Missing parentheses in define_method call.

💡 Hint

Check what @attr means inside the method.

The code uses @attr literally, but it should use the variable attr to build the instance variable name dynamically, like instance_variable_get("@#{attr}").

📝 Syntax

advanced

Which option correctly defines a method dynamically with parameters?

Which Ruby code correctly defines a method greet that takes a name parameter and returns a greeting?

A define_method(:greet) |name| { "Hello, #{name}!" }

B define_method greet(name) { "Hello, #{name}!" }

C define_method(:greet) do name; "Hello, #{name}!" end

D define_method(:greet) { |name| "Hello, #{name}!" }

💡 Hint

Remember the syntax for define_method with a block and parameters.

Option D uses the correct syntax: define_method(:greet) { |name| ... }. Other options have syntax errors.

🚀 Application

expert

What is the output of this Ruby metaprogramming example?

This Ruby code uses method_missing to handle undefined methods. What will it print?

Ruby

class Dynamic
  def method_missing(name, *args)
    if name.to_s.start_with?("say_")
      word = name.to_s.split("_")[1]
      "You said: #{word} with args: #{args.join(", ")}"
    else
      super
    end
  end
end

d = Dynamic.new
puts d.say_hello("world")
puts d.say_goodbye("everyone")
puts d.unknown_method

A You said: say_hello with args: world\nYou said: say_goodbye with args: everyone\nNoMethodError

B You said: hello with args: world\nYou said: goodbye with args: everyone\nNoMethodError

C NoMethodError\nNoMethodError\nNoMethodError

D You said: hello with args: world\nYou said: goodbye with args: everyone\nYou said: unknown with args:

💡 Hint

Look at how method_missing handles method names starting with say_.

Methods starting with say_ are handled and print a message. Other methods call super, raising NoMethodError.