Define_method for dynamic methods in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of dynamic method using define_method

What is the output of this Ruby code that uses define_method to create a dynamic method?

Ruby

class Greeter
  def initialize(name)
    @name = name
  end

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

g = Greeter.new("Alice")
puts g.greet

A SyntaxError

B Hello, @name!

C undefined method `greet' for #<Greeter:0x0000>

D Hello, Alice!

💡 Hint

Remember that define_method creates an instance method that can access instance variables.

The define_method block is evaluated in the context of the instance, so @name refers to the instance variable. Calling g.greet returns "Hello, Alice!".

🧠 Conceptual

intermediate

Understanding scope in define_method blocks

Which statement about the scope of variables inside a define_method block is true?

A The block has access to local variables from the surrounding method where <code>define_method</code> is called.

B The block cannot access any variables and must use global variables only.

C The block runs in the context of the instance, so it can access instance variables but not local variables from outside the block.

D The block can only access instance variables and method parameters, but not local variables from outside.

💡 Hint

Think about where the block is executed when the dynamic method is called.

The block passed to define_method runs in the context of the instance, so it can access instance variables. However, it does not have access to local variables from the surrounding method where define_method was called.

🔧 Debug

advanced

Why does this define_method code raise an error?

This Ruby code raises an error. What is the cause?

Ruby

class Calculator
  define_method(:add) do |a, b|
    a + b
  end
end

calc = Calculator.new
puts calc.add(5)

A NoMethodError: undefined method `add' for #<Calculator:0x0000>

B ArgumentError: wrong number of arguments (given 1, expected 2)

C SyntaxError: unexpected `|'

D TypeError: nil can't be coerced into Integer

💡 Hint

Check how many arguments the method expects versus how many are given.

The dynamically defined method add expects two arguments, but only one is given when calling calc.add(5). This causes an ArgumentError.

📝 Syntax

advanced

Identify the syntax error in define_method usage

Which option contains a syntax error when using define_method?

Ruby

class Person
  define_method(:say_hello) do
    puts "Hello!"
  end
end

A define_method(:say_hello) do puts "Hello!" end

B define_method :say_hello { puts "Hello!" }

C define_method(:say_hello) { puts "Hello!" }

D define_method(:say_hello) do || puts "Hello!" end

💡 Hint

Check the block syntax used with define_method.

Option A contains a syntax error: define_method(:say_hello) do puts "Hello!" end used inline without block parameters (e.g. do ||) or newline after do fails to parse. do...end blocks require parameters or newline for body when not multiline. Use { ... } for inline blocks.

🚀 Application

expert

Create dynamic getter methods with define_method

Given the following Ruby class, which option correctly uses define_method to create getter methods for each attribute in ATTRIBUTES?

Ruby

class Product
  ATTRIBUTES = [:name, :price, :stock]

  def initialize(name, price, stock)
    @name = name
    @price = price
    @stock = stock
  end

  # Define getter methods dynamically here
end

A

ATTRIBUTES.each do |attr|
  define_method(attr) { instance_variable_get("@#{attr}") }
end

B

ATTRIBUTES.each do |attr|
  define_method(attr) { @attr }
end

C

ATTRIBUTES.each do |attr|
  define_method(attr) { self.attr }
end

D

ATTRIBUTES.each do |attr|
  define_method(attr) { instance_variable_get(attr) }
end

💡 Hint

Use instance_variable_get with the correct instance variable name string.

Option A correctly defines getter methods by calling instance_variable_get with the instance variable name as a string, e.g., "@name". Other options either use the symbol directly or incorrect variable references.