Module_eval for dynamic behavior in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does module_eval do in Ruby?

module_eval runs a string or block of code inside the context of a module or class, allowing you to add or change methods dynamically.

beginner

How can module_eval be used to add a method to a class?

<p>You pass a string defining the method to <code>module_eval</code>, and it adds that method to the class or module.</p><pre>MyClass.module_eval do
  def greet
    "Hello!"
  end
end</pre>

intermediate

What is a practical use case for module_eval?

It helps when you want to create methods or change behavior based on data or conditions at runtime, like generating methods from a list of names.

intermediate

What is the difference between module_eval and class_eval?

They are very similar; both evaluate code in the context of a module or class. class_eval is just an alias for module_eval when used on classes.

advanced

Can module_eval access instance variables of the module or class?

Yes, inside the block or string passed to module_eval, you can access and modify instance variables of the module or class.

What does module_eval primarily allow you to do?

A Compile Ruby code to machine code

B Create a new module

C Run code inside a module or class context

D Delete methods from a class

module_eval runs code inside the context of a module or class, enabling dynamic behavior.

Which of these is a correct way to add a method using module_eval?

A MyClass.module_eval { def hello; 'Hi'; end }

B MyClass.module_eval(:hello) { 'Hi' }

C MyClass.module_eval('hello')

D MyClass.module_eval(:def hello end)

Passing a block with method definition to module_eval adds the method.

What is a key benefit of using module_eval?

A Dynamic method creation at runtime

B Static code analysis

C Faster execution speed

D Memory optimization

module_eval allows creating or changing methods dynamically while the program runs.

Which is true about class_eval compared to module_eval?

A <code>class_eval</code> is only for classes, <code>module_eval</code> only for modules

B <code>class_eval</code> is an alias of <code>module_eval</code> for classes

C <code>class_eval</code> cannot add methods

D <code>module_eval</code> is deprecated

class_eval is just another name for module_eval when used on classes.

Can module_eval access instance variables of the module or class it is called on?

A Only if passed as arguments

B No, it only accesses class methods

C Only in Ruby versions before 2.0

D Yes, it can access and modify them

Inside module_eval, instance variables of the module or class are accessible.

Explain how module_eval can be used to add methods dynamically to a Ruby class.

Think about passing a block or string with method code.

Describe the difference and similarity between module_eval and class_eval.

Consider their usage on classes and modules.

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)