Module_eval for dynamic behavior in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method dynamically using module_eval.

Ruby

module Greeter
  module_eval do
    def [1]
      "Hello!"
    end
  end
end

class Person
  include Greeter
end

puts Person.new.hello

Drag options to blanks, or click blank then click option'

Agreet

Bwelcome

Csay_hello

Dhello

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name different from 'hello' causes a NoMethodError.

The method defined dynamically is hello, so calling Person.new.hello works.

2fill in blank

medium

Complete the code to dynamically add a method that returns the given name.

Ruby

module PersonModule
  module_eval do
    def name
      [1]
    end
  end
end

class Person
  include PersonModule
  def initialize(name)
    @name = name
  end
end

puts Person.new("Alice").name

Drag options to blanks, or click blank then click option'

A"Bob"

Bname

C@name

D"Alice"

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a string literal instead of the instance variable.

The method returns the instance variable @name which holds the person's name.

3fill in blank

hard

Fix the error in the code by completing the module_eval string to define a method.

Ruby

module Calculator
  module_eval "def [1](x, y); x + y; end"
end

class MathOps
  include Calculator
end

puts MathOps.new.add(5, 3)

Drag options to blanks, or click blank then click option'

Aadd

Bcalculate

Cplus

Dsum

Attempts:

3 left

💡 Hint

Common Mistakes

Defining a method with a different name than the one called causes NoMethodError.

The method called is add, so the dynamically defined method must be named add.

4fill in blank

hard

Fill both blanks to dynamically define a method that multiplies a number by a factor.

Ruby

module Multiplier
  module_eval do
    def multiply_by_[1](num)
      num [2] [1]
    end
  end
end

class Number
  include Multiplier
end

puts Number.new.multiply_by_3(4)

Drag options to blanks, or click blank then click option'

A3

B*

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' or '-' instead of '*' for multiplication.

The method name includes the factor '3', and the operation is multiplication '*'.

5fill in blank

hard

Fill all three blanks to dynamically define a method that checks if a number is greater than a threshold.

Ruby

module Checker
  module_eval do
    def greater_than_[1](num)
      num [2] [3]
    end
  end
end

class NumberCheck
  include Checker
end

puts NumberCheck.new.greater_than_10(15)

Drag options to blanks, or click blank then click option'

A10

B>

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '==' instead of '>' for the comparison.

The method name includes '10', the comparison operator is '>', and the threshold is 10.

Practice

1.

What does module_eval do in Ruby?

easy

A. It converts a module into a class.

B. It deletes all methods from a module.

C. It creates a new module with fixed methods.

D. It allows adding or changing methods inside a module dynamically.

Solution

1. Step 1: Understand the purpose of module_eval

   module_eval lets you run code inside a module's context, allowing you to add or change methods dynamically.

2. Step 2: Compare options with the definition

   Only "It allows adding or changing methods inside a module dynamically." correctly describes this dynamic behavior. Other options describe unrelated actions.

3. Final Answer:

   It allows adding or changing methods inside a module dynamically. -> Option D

4. Quick Check:

   module_eval adds or changes methods = A [OK]

Hint: Remember: module_eval changes module methods at runtime [OK]

Common Mistakes:

• Thinking module_eval deletes methods
• Confusing module_eval with module creation
• Assuming module_eval converts modules to classes

2.

Which of the following is the correct syntax to define a method greet inside a module Mod using module_eval?

module Mod
  # Your code here
end

easy

A. Mod.module_eval { def greet; 'Hi'; end }

B. Mod.module_eval def greet; 'Hi'; end

C. Mod.module_eval('def greet; 'Hi'; end')

D. Mod.module_eval :def greet; 'Hi'; end

Solution

1. Step 1: Recall correct module_eval syntax

   You can pass a block to module_eval with method definitions inside curly braces.

2. Step 2: Check each option's syntax

   Mod.module_eval { def greet; 'Hi'; end } uses a block correctly. Mod.module_eval def greet; 'Hi'; end misses braces. Mod.module_eval('def greet; 'Hi'; end') has mismatched quotes (inner single quote breaks the outer single-quoted string), causing syntax error. Mod.module_eval :def greet; 'Hi'; end uses invalid symbol syntax.

3. Final Answer:

   Mod.module_eval { def greet; 'Hi'; end } -> Option A

4. Quick Check:

   Block syntax with braces is correct = A [OK]

Hint: Use braces {} to pass a block to module_eval [OK]

Common Mistakes:

• Omitting braces for block
• Using invalid symbol syntax
• Confusing string and block syntax

3.

What will be the output of the following Ruby code?

module M
  module_eval do
    def hello
      'Hello from M'
    end
  end
end

class C
  include M
end

puts C.new.hello

medium

A. Hello from M

B. NoMethodError

C. SyntaxError

D. nil

Solution

1. Step 1: Understand method definition inside module_eval

   The method hello is defined inside module M using module_eval, so it becomes an instance method of M.

2. Step 2: Check class inclusion and method call

   Class C includes M, so instances of C have hello method. Calling C.new.hello returns 'Hello from M'.

3. Final Answer:

   Hello from M -> Option A

4. Quick Check:

   module_eval defines method, include makes it accessible = D [OK]

Hint: module_eval defines methods accessible after include [OK]

Common Mistakes:

• Assuming method is not defined
• Confusing module_eval with class_eval
• Expecting syntax error from block

4.

Identify the error in the following code snippet:

module M
  module_eval 'def greet; puts "Hi" end'
end

class C
  include M
end

C.new.greet

medium

A. The method greet is defined but calling it prints nothing.

B. No error; code runs and prints 'Hi'.

C. Syntax error due to missing semicolon in module_eval string.

D. NoMethodError because greet is not defined as an instance method.

Solution

1. Step 1: Analyze module_eval string syntax

   The string passed to module_eval defines method greet correctly with a semicolon separating statements.

2. Step 2: Check method availability and call

   Class C includes M, so greet is available to instances. Calling C.new.greet prints 'Hi'.

3. Final Answer:

   No error; code runs and prints 'Hi'. -> Option B

4. Quick Check:

   module_eval string defines method correctly = C [OK]

Hint: Check string syntax carefully; semicolon separates statements [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming greet is not instance method
• Expecting runtime error from string eval

5.

You want to dynamically add multiple methods foo and bar to a module Mod using module_eval. Which approach correctly adds both methods so they can be used by classes including Mod?

hard

A. Mod.module_eval do
def self.foo; 'foo'; end
end
Mod.module_eval do
def self.bar; 'bar'; end
end

B. All of the above

C. Mod.module_eval do
def foo; 'foo'; end
def bar; 'bar'; end
end

D. Mod.module_eval('def self.foo; "foo"; end')
Mod.module_eval('def self.bar; "bar"; end')

Solution

1. Step 1: Understand multiple method definitions with module_eval

   You can define multiple methods in one block or multiple times with separate calls to module_eval. Both ways add instance methods to the module.

2. Step 2: Evaluate each option

   Mod.module_eval do def foo; 'foo'; end def bar; 'bar'; end end defines both as instance methods (no self.) in one block, correct. All of the above "All of the above" is incorrect. Mod.module_eval do def self.foo; 'foo'; end end Mod.module_eval do def self.bar; 'bar'; end end uses separate blocks but def self. adds singleton methods to Mod, not instance methods. Mod.module_eval('def self.foo; "foo"; end') Mod.module_eval('def self.bar; "bar"; end') uses strings with def self., same issue - not accessible after include.

3. Final Answer:

   Mod.module_eval do def foo; 'foo'; end def bar; 'bar'; end end -> Option C

4. Quick Check:

   Block with plain def (no self) adds instance methods = A [OK]

Hint: module_eval block with plain def defines instance methods [OK]

Common Mistakes:

• Thinking only one method per module_eval is allowed
• Confusing string and block syntax
• Using self.def for instance methods (makes singletons)