Method_added hook in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of method_added hook example

What is the output of this Ruby code using the method_added hook?

Ruby

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

  def hello
    'Hello'
  end

  def world
    'World'
  end
end

A

Method added: hello
Method added: world

B

Method added: hello
Method added: world
Method added: method_added

C No output

D Method added: hello

💡 Hint

The method_added hook is called each time an instance method is defined in the class.

The method_added hook is triggered after each instance method definition. Here, hello and world are instance methods, so the hook prints their names. The hook itself is a class method, so defining it does not trigger method_added.

🧠 Conceptual

intermediate

Understanding method_added hook behavior

Which statement about the method_added hook in Ruby is TRUE?

A It is called every time a class method is defined.

B It is called every time an instance method is defined.

C It is called only once when the class is created.

D It is called when an instance of the class is created.

💡 Hint

Think about what kind of methods method_added tracks.

The method_added hook is triggered only when an instance method is added to a class, not for class methods or object instantiation.

🔧 Debug

advanced

Why does this method_added hook cause a SystemStackError?

Consider this Ruby code snippet:

class Demo
  def self.method_added(name)
    puts "Added: #{name}"
    def new_method
      'Hi'
    end
  end

  def first
  end
end

What causes the SystemStackError (stack level too deep) when this code runs?

A The <code>new_method</code> is defined inside an instance method, which is invalid.

B The <code>method_added</code> hook is missing a <code>super</code> call.

C The <code>method_added</code> hook defines a new method, which triggers <code>method_added</code> again, causing infinite recursion.

D The <code>first</code> method is empty, causing the error.

💡 Hint

Think about what happens when a method is defined inside method_added.

Defining a method inside method_added triggers method_added again, causing infinite recursion and eventually a stack overflow error.

📝 Syntax

advanced

Identify the syntax error in method_added hook usage

Which option contains a syntax error in defining a method_added hook?

A

def self.method_added(name)
  puts 'Added: ' + name
end

B

def self.method_added(name)
  puts "Added: #{name}"
end

C

dne
"}eman{# :deddA" stup  
)eman(dedda_dohtem.fles fed

D

def method_added(name)
  puts "Added: #{name}"
end

💡 Hint

Remember where method_added must be defined to work as a hook.

The method_added hook must be defined as a class method (using self.method_added). Option D defines it as an instance method, so it won't work as a hook but is syntactically valid. However, the question asks for syntax error, so check string interpolation carefully.

🚀 Application

expert

Using method_added to track method definitions

You want to track all instance methods added to a class and store their names in an array @methods_list. Which code snippet correctly implements this using method_added?

A

class Tracker
  @methods_list = []
  def self.method_added(name)
    @methods_list = [] unless @methods_list
    @methods_list.push(name)
  end
  def self.methods_list
    @methods_list
  end
  def foo; end
  def bar; end
end

puts Tracker.methods_list.inspect

B

class Tracker
  @methods_list = []
  def self.method_added(name)
    @methods_list << name
  end
  def self.methods_list
    @methods_list
  end
  def foo; end
  def bar; end
end

puts Tracker.methods_list.inspect

C

class Tracker
  @methods_list = []
  def method_added(name)
    @methods_list << name
  end
  def self.methods_list
    @methods_list
  end
  def foo; end
  def bar; end
end

puts Tracker.methods_list.inspect

D

class Tracker
  @methods_list = []
  def self.method_added(name)
    @methods_list << name
  end
  def self.methods_list
    @methods_list
  end
  def foo; end
  def bar; end
  def self.method_added(name)
    @methods_list << name
  end
end

puts Tracker.methods_list.inspect

💡 Hint

Remember that @methods_list is a class instance variable and may need initialization inside the hook.

Option A correctly initializes @methods_list if nil inside method_added and appends method names. This avoids errors if the hook runs before @methods_list is set. Other options either define method_added incorrectly or overwrite the array.

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