Method_added hook in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method that prints a message when a new method is added.

Ruby

class MyClass
  def self.method_added([1])
    puts "New method added: #{method_name}"
  end

  def greet
    puts 'Hello!'
  end
end

Drag options to blanks, or click blank then click option'

Aname

Bmethod

Cmethod_name

Dmethod_added

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong parameter name that doesn't represent the method's name.

Forgetting to define the parameter in the method signature.

The method_added hook receives the name of the newly added method as a symbol. Naming the parameter method_name is clear and conventional.

2fill in blank

medium

Complete the code to print the name of each method added to the class.

Ruby

class Tracker
  def self.method_added([1])
    puts "Method added: #{method_name}"
  end

  def example_method
  end
end

Drag options to blanks, or click blank then click option'

Aadded_method

Bmethod

Cname

Dmethod_name

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name that doesn't match the variable used inside the method.

Not defining any parameter, causing an error.

The parameter method_name correctly receives the symbol of the method just added, which is then printed.

3fill in blank

hard

Fix the error in the method_added hook to correctly print the added method's name.

Ruby

class Fixer
  def self.method_added([1])
    puts "Added method: #{method_name}"
  end

  def test
  end
end

Drag options to blanks, or click blank then click option'

Amethod

Bmethod_name

Cname

Dadded

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatch between parameter name and variable used inside the method.

Omitting the parameter entirely.

The parameter method_name matches the variable used inside the method, fixing the error.

4fill in blank

hard

Fill both blanks to create a method_added hook that ignores methods starting with an underscore.

Ruby

class IgnoreUnderscore
  def self.method_added([1])
    return if method_name.to_s.start_with?([2])
    puts "Added: #{method_name}"
  end

  def _hidden
  end

  def visible
  end
end

Drag options to blanks, or click blank then click option'

Amethod_name

B'_'

C'__'

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong parameter name.

Checking for the wrong prefix string.

The parameter method_name receives the method's name. Checking if it starts with '_' allows ignoring such methods.

5fill in blank

hard

Fill all three blanks to create a method_added hook that tracks added methods in a class variable array.

Ruby

class Tracker
  @methods = []

  def self.method_added([1])
    @methods [2] [3]
  end

  def first
  end

  def second
  end
end

Drag options to blanks, or click blank then click option'

Amethod_name

B<<

D+=

Attempts:

3 left

💡 Hint

Common Mistakes

Using += which creates a new array instead of modifying the existing one.

Using wrong parameter names.

The hook receives the method name as method_name. Using << adds it to the @methods 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