Method_added hook in Ruby - Time & Space Complexity

Time Complexity: Method_added hook

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code changes when using the method_added hook in Ruby.

Specifically, we ask: how does adding methods affect the work done by this hook?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

  def foo
    # some code
  end

  def bar
    # some code
  end
end

This code prints a message every time a new method is added to the class.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The method_added hook runs once for each method defined.
• How many times: It runs exactly as many times as methods are added to the class.

How Execution Grows With Input

Each time you add a method, the hook runs once, doing a simple print.

Input Size (n)	Approx. Operations
10	10 print operations
100	100 print operations
1000	1000 print operations

Pattern observation: The work grows directly with the number of methods added.

Final Time Complexity

Time Complexity: O(n)

This means the time grows in a straight line with the number of methods added.

Common Mistake

[X] Wrong: "The method_added hook runs only once no matter how many methods are added."

[OK] Correct: The hook runs every time a new method is defined, so it runs as many times as methods are added.

Interview Connect

Understanding how hooks like method_added work helps you reason about code that reacts to changes, a useful skill in many Ruby projects.

Self-Check

"What if the method_added hook itself defined another method? How would that affect the time complexity?"

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