Method_added hook in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the method_added hook in Ruby?

It is a special method called automatically whenever a new instance method is added to a class or module.

beginner

How do you define a method_added hook in a Ruby class?

Define a class method named <code>self.method_added(method_name)</code> inside the class or module.

beginner

What argument does the method_added hook receive?

It receives the name of the method (as a symbol) that was just added.

intermediate

Can method_added be used to modify methods after they are defined?

Yes, it can be used to wrap or change methods right after they are added, for example to add logging or validation.

advanced

What happens if you define a method inside method_added itself?

It triggers method_added again, which can cause infinite recursion unless carefully handled.

What does the method_added hook detect in Ruby?

A When a new instance method is defined

B When a class is created

C When a variable is assigned

D When a module is included

The method_added hook is called whenever a new instance method is added to a class or module.

How do you prevent infinite recursion inside method_added?

A Rename the method being added

B Avoid defining methods inside <code>method_added</code>

C Call <code>super</code> inside <code>method_added</code>

D Use a guard variable to skip re-entry

Using a guard variable to track if method_added is already running prevents infinite recursion.

What type of argument does method_added receive?

A Method body as a string

B Method name as a symbol

C Class name as a string

D No arguments

method_added receives the name of the method just added as a symbol.

Where should method_added be defined to work properly?

A Inside the class or module as a class method

B Outside any class or module

C Inside an instance method

D Inside a block passed to <code>define_method</code>

method_added must be defined as a class method inside the class or module.

Which of these is a common use of method_added?

A Creating new classes

B Deleting methods from a class

C Automatically wrapping new methods with extra behavior

D Changing variable values

method_added is often used to wrap or modify methods right after they are defined.

Explain how the method_added hook works and give an example of when you might use it.

Think about how Ruby tells you when a new method appears.

Describe a potential problem when defining methods inside method_added and how to avoid it.

What happens if the hook triggers itself repeatedly?

Practice

1. What does the method_added hook do in Ruby?

easy

A. It runs when a class is inherited by another class.

B. It runs automatically whenever a new instance method is defined in a class.

C. It runs when a method is called on an object.

D. It runs when a module is included in a class.

Solution

1. Step 1: Understand the purpose of method_added

   The method_added hook is a special method in Ruby that triggers automatically when a new instance method is defined inside a class.

2. Step 2: Compare with other hooks

   Other hooks like inherited or included run on inheritance or module inclusion, not on method definition.

3. Final Answer:

   It runs automatically whenever a new instance method is defined in a class. -> Option B

4. Quick Check:

   method_added triggers on method definition [OK]

Hint: Remember: method_added triggers on new instance methods [OK]

Common Mistakes:

• Confusing method_added with inherited or included hooks
• Thinking it runs when methods are called
• Assuming it triggers on class creation

2. Which of the following is the correct way to define a method_added hook inside a Ruby class?

easy

A. def self.method_added(method_name); puts "Added: #{method_name}"; end

B. def self.method_added; puts "Added method"; end

C. def method_added(method_name); puts "Added: #{method_name}"; end

D. def method_added; puts "Added method"; end

Solution

1. Step 1: Identify the correct method signature

   The method_added hook is an instance method of the class's singleton class, so it should be defined as an instance method inside the class (not a class method). It receives the method name as a symbol.

2. Step 2: Check the options

   def method_added(method_name); puts "Added: #{method_name}"; end defines def method_added(method_name) which is correct. def self.method_added(method_name); puts "Added: #{method_name}"; end defines it as a class method (self.method_added), which is incorrect. Options B and C miss the required parameter.

3. Final Answer:

   def method_added(method_name); puts "Added: #{method_name}"; end -> Option C

4. Quick Check:

   method_added is an instance method with one parameter [OK]

Hint: Define method_added as instance method with one parameter [OK]

Common Mistakes:

• Defining method_added as a class method
• Omitting the method_name parameter
• Using wrong method signature without parameters

3. What will be the output of the following Ruby code?

class Test
  def method_added(name)
    puts "Method added: #{name}"
  end

  def hello
    puts 'Hello world'
  end
end

Test.new.hello

medium

A. Method added: hello
Hello world

B. Hello world

C. Method added: hello

D. No output

Solution

1. Step 1: Trace the class definition

   During class definition, def method_added is processed first; the hook for defining method_added itself does not print as it is not yet active. Then def hello triggers Test.method_added(:hello), printing "Method added: hello".

2. Step 2: Runtime execution

   Test.new.hello prints "Hello world". Combined output matches Method added: hello Hello world.

3. Final Answer:

   Method added: hello Hello world -> Option A

4. Quick Check:

   Hook triggers for methods defined after method_added [OK]

Hint: method_added hook triggers during class def for subsequent methods [OK]

Common Mistakes:

• Thinking method_added as instance method does not hook
• Forgetting hook triggers at class definition time
• Expecting only "Hello world"

4. Identify the error in this Ruby code using method_added hook:

class Demo
  def method_added(name)
    puts "Added: #{name}"
    def new_method
      puts 'New method called'
    end
  end

  def test
    puts 'Test method'
  end
end

Demo.new.new_method

medium

A. Infinite recursion caused by defining a method inside method_added

B. Syntax error due to missing end keyword

C. No error; code runs and prints 'New method called'

D. new_method is private and cannot be called

Solution

1. Step 1: Analyze method_added behavior

   Inside method_added, a new method new_method is defined. Defining a method triggers method_added again, causing infinite recursion.

2. Step 2: Understand the recursion effect

   This recursion never ends, leading to a SystemStackError (stack overflow) at runtime.

3. Final Answer:

   Infinite recursion caused by defining a method inside method_added -> Option A

4. Quick Check:

   Defining methods inside method_added causes recursion [OK]

Hint: Avoid defining methods inside method_added to prevent recursion [OK]

Common Mistakes:

• Ignoring infinite recursion risk
• Thinking code runs normally
• Confusing syntax error with runtime error

5. How can you safely use method_added to track new methods without causing infinite recursion when defining methods inside the hook?

hard

A. Use alias_method to rename methods inside method_added

B. Define all methods outside the class to avoid triggering method_added

C. Remove method_added after the first method is added

D. Use a guard variable to skip method_added logic when defining methods inside the hook

Solution

1. Step 1: Understand the recursion problem

   Defining methods inside method_added triggers the hook again, causing infinite recursion.

2. Step 2: Use a guard variable

   By setting a flag (e.g., a class variable) before defining methods inside the hook and checking it at the start of method_added, you can skip the hook logic during internal method definitions.

3. Step 3: Implement safe tracking

   This approach allows tracking new methods safely without recursion.

4. Final Answer:

   Use a guard variable to skip method_added logic when defining methods inside the hook -> Option D

5. Quick Check:

   Guard variable prevents recursion in method_added [OK]

Hint: Use a flag to skip method_added during internal method definitions [OK]

Common Mistakes:

• Not using a guard variable and causing recursion
• Trying to remove method_added dynamically
• Misusing alias_method to fix recursion