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.