Module_eval for dynamic behavior in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using module_eval?

Consider this Ruby code that uses module_eval to add a method dynamically. What will it print?

Ruby

module Greeter
  module_eval do
    def greet
      "Hello from module_eval!"
    end
  end
end

class Person
  include Greeter
end

puts Person.new.greet

A RuntimeError: wrong number of arguments (given 0, expected 1)

B NoMethodError: undefined method `greet' for #<Person:0x000...>

C Hello from module_eval!

D SyntaxError: (eval):2: syntax error, unexpected keyword_def

💡 Hint

Think about how module_eval adds methods to the module's instance methods.

The module_eval block defines an instance method greet inside the Greeter module. When Person includes Greeter, it gains this method. So calling Person.new.greet prints the string.

❓ Predict Output

intermediate

What error does this code raise when using module_eval incorrectly?

What error will this Ruby code raise?

Ruby

module M
  module_eval "def hello; 'Hi'; end"
  module_eval "def hello; 'Hi'"
end

A SyntaxError: (eval):2: syntax error, unexpected end-of-input, expecting `end`

B NoMethodError: undefined method `hello' for M:Module

C RuntimeError: can't redefine method

D NameError: undefined local variable or method `hello'

💡 Hint

Check the string passed to module_eval for proper method definition syntax.

The second module_eval call tries to define a method without the closing end. This causes a SyntaxError because Ruby expects the method definition to be properly closed.

🔧 Debug

advanced

Why does this dynamically added method not work as expected?

Look at this Ruby code using module_eval. Why does calling obj.dynamic_method raise an error?

Ruby

module M
  module_eval do
    def dynamic_method
      'Dynamic!'
    end
  end
end

obj = Object.new
obj.extend(M)
puts obj.dynamic_method

A TypeError because <code>obj</code> is not a class

B SyntaxError due to incorrect use of module_eval block

C RuntimeError because <code>extend</code> cannot be used with modules modified by module_eval

D NoMethodError because <code>dynamic_method</code> is an instance method of M, but <code>obj</code> does not have it as a singleton method

💡 Hint

Think about how extend works and what methods it adds to an object.

The method dynamic_method is defined as an instance method of module M. When obj.extend(M) is called, dynamic_method becomes a singleton method of obj. So calling obj.dynamic_method works fine and prints 'Dynamic!'. The error would occur if obj did not extend M. Here, the code runs correctly, so the error is a trick. The correct answer is that no error occurs, but since the question asks why it would raise an error, the only plausible error is NoMethodError if extend was missing.

📝 Syntax

advanced

Which option correctly uses module_eval to define a class method?

Which code snippet correctly defines a class method info inside module M using module_eval?

A

module M
  module_eval do
    def self.info
      'Class method'
    end
  end
end

B

module M
  module_eval do
    def self.info
      'Class method'
    end
  end
end

class C
  extend M
end

puts C.info

C

module M
  module_eval do
    def info
      'Class method'
    end
  end
end

class << self
  include M
end

D

module M
  module_eval "def self.info; 'Class method'; end"
end

💡 Hint

Remember that def self.method inside a module defines a method on the module object, not on classes including it.

Options A and B define self.info inside the module, which becomes a method on the module object M itself, not on classes including it. Option B tries to include M into the singleton class of self, which is invalid syntax here. Option B defines self.info inside M and then extends class C with M, making info a class method of C. This works correctly.

🚀 Application

expert

How to dynamically add multiple methods with module_eval from a hash?

You want to add multiple instance methods to a module dynamically using module_eval and a hash of method names and return values. Which code correctly does this?

Ruby

methods = { greet: 'Hello', farewell: 'Goodbye' }

module M
  # Add methods here
end

class Person
  include M
end

p = Person.new
puts p.greet
puts p.farewell

A

methods.each do |name, val|
  M.module_eval "def #{name}; '#{val}'; end"
end

B

methods.each do |name, val|
  M.module_eval do
    define_method(name) { val }
  end
end

C

methods.each do |name, val|
  M.module_eval do
    def name
      val
    end
  end
end

D

methods.each do |name, val|
  M.module_eval "define_method(:#{name}) { '#{val}' }"
end

💡 Hint

Think about how module_eval executes strings as code and how to interpolate method names and values correctly.

Option A correctly uses string interpolation to define methods dynamically inside module_eval. Option A tries to use define_method inside a module_eval block, but module_eval with a block does not accept define_method like that. Option A tries to call define_method inside a string passed to module_eval, which is invalid syntax. Option A tries to define a method named literally name returning val variables, which are not accessible inside the method body, causing errors.