Module_eval for dynamic behavior in Ruby - Step-by-Step Execution

Concept Flow - Module_eval for dynamic behavior

Define Module

↓

Call module_eval with code string

↓

Evaluate code inside module context

↓

Add methods or variables dynamically

↓

Use new methods on module or including classes

↓

End

This flow shows how module_eval runs code inside a module to add methods dynamically, then those methods can be used.

Execution Sample

Ruby

module Greeter
  module_eval do
    def hello
      "Hello!"
    end
  end
end

puts Greeter.new.hello rescue 'No instance method'

Defines a method dynamically inside a module using module_eval, then tries to call it on an instance.

Execution Table

Step	Action	Evaluation	Result
1	Define module Greeter	Module Greeter created	Greeter module exists
2	Call module_eval with block defining method hello	Method hello defined inside Greeter	Greeter has method hello
3	Try to call Greeter.new.hello	Greeter.new raises NoMethodError	Rescue prints 'No instance method'
4	Include Greeter in a class Person	Person includes Greeter methods	Person instances have hello method
5	Create Person.new.hello call	hello method returns 'Hello!'	Output: Hello!

💡 Greeter module alone cannot be instantiated; methods added via module_eval are available when included in a class.

Variable Tracker

Variable	Start	After module_eval	After include in Person	After Person.new
Greeter	module defined	method hello added	unchanged	unchanged
Person	undefined	undefined	includes Greeter	instance created
person_instance	undefined	undefined	undefined	object with hello method

Key Moments - 2 Insights

Why does calling Greeter.new.hello fail even after defining hello with module_eval?

Because modules cannot be instantiated with .new. The method hello is defined in the module, but you must include the module in a class to use it on instances. See execution_table step 3 and 4.

How does module_eval add methods dynamically inside a module?

module_eval runs the given code block or string inside the module's context, so methods defined inside become part of the module. This is shown in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3 when calling Greeter.new.hello?

A It successfully calls hello and prints 'Hello!'

B It returns nil because hello is not defined

C It raises an error because Greeter cannot be instantiated

D It calls hello but returns an empty string

💡 Hint

Check execution_table row 3 where Greeter.new raises NoMethodError

At which step does the hello method become usable on an instance?

A Step 3

B Step 4

C Step 2

D Step 1

💡 Hint

See execution_table step 4 where Person includes Greeter

If we remove module_eval and define hello normally inside Greeter, what changes in the execution?

A hello method is not added dynamically

B No change; behavior is the same

C Greeter can be instantiated now

D Person cannot include Greeter anymore

💡 Hint

module_eval allows dynamic code evaluation; normal definition is static (see concept_snapshot)

Concept Snapshot

module_eval runs code inside a module's context.
It can add methods dynamically.
Modules cannot be instantiated directly.
Include modules in classes to use added methods.
module_eval accepts strings or blocks.
Useful for dynamic behavior.

Full Transcript

This example shows how module_eval lets you add methods inside a module dynamically. First, the module Greeter is defined. Then module_eval runs a block that defines method hello inside Greeter. Trying to call Greeter.new.hello fails because modules cannot be instantiated. To use the method, we include Greeter in a class Person. Now Person instances can call hello and get 'Hello!'. This shows module_eval's power to add behavior dynamically inside modules, but you must include modules in classes to use instance methods.

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)