Method_missing for catch-all in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using method_missing?

Consider this Ruby class that uses method_missing to catch undefined method calls:

class CatchAll
  def method_missing(name, *args)
    "Called #{name} with #{args.join(", ")}"
  end
end

obj = CatchAll.new
puts obj.any_method(1, 2, 3)

What will this print?

Ruby

class CatchAll
  def method_missing(name, *args)
    "Called #{name} with #{args.join(", ")}"
  end
end

obj = CatchAll.new
puts obj.any_method(1, 2, 3)

A Called any_method with 1, 2, 3

B Called any_method with []

C NoMethodError: undefined method `any_method' for #<CatchAll:0x000...>

D ArgumentError: wrong number of arguments (given 3, expected 0)

💡 Hint

Think about what method_missing does when a method is not found.

The method_missing method catches calls to undefined methods. It receives the method name and arguments. Here, it returns a string showing the method name and arguments passed. So calling any_method(1, 2, 3) prints Called any_method with 1, 2, 3.

🧠 Conceptual

intermediate

Which statement about method_missing is true?

Choose the correct statement about Ruby's method_missing method.

A <code>method_missing</code> automatically defines the missing method permanently.

B <code>method_missing</code> is called only when a method is not defined on the object.

C <code>method_missing</code> is called before any method is executed, even if it exists.

D <code>method_missing</code> can only handle methods without arguments.

💡 Hint

Think about when Ruby decides to call method_missing.

method_missing is triggered only when Ruby cannot find a method with the given name on the object. It does not run before existing methods, does not define methods permanently, and can handle any arguments.

🔧 Debug

advanced

Why does this method_missing code cause a SystemStackError?

Look at this Ruby code:

class RecursiveCatch
  def method_missing(name, *args)
    method_missing(name, *args)
  end
end

obj = RecursiveCatch.new
obj.any_method

Why does this cause a SystemStackError?

A Because <code>method_missing</code> is not defined with the correct parameters.

B Because Ruby does not allow <code>method_missing</code> to be called explicitly.

C Because <code>method_missing</code> calls itself recursively without a base case.

D Because <code>any_method</code> is actually defined and causes conflict.

💡 Hint

Think about what happens when method_missing calls itself.

The method_missing method calls itself recursively with the same arguments and no stopping condition. This causes infinite recursion, leading to a SystemStackError (stack overflow).

📝 Syntax

advanced

Which option correctly overrides method_missing to handle undefined methods?

Choose the correct Ruby code snippet that overrides method_missing to print the missing method name and arguments.

A

def method_missing(name, *args)
  puts "Missing: #{name} with #{args.join(', ')}"
end

B

def method_missing(name, args)
  puts "Missing: #{name} with #{args.join(', ')}"
end

C

def method_missing(*name, args)
  puts "Missing: #{name} with #{args.join(', ')}"
end

D

def method_missing(name)
  puts "Missing: #{name} with no args"
end

💡 Hint

Remember the correct parameters for method_missing.

The correct signature is method_missing(name, *args). Option A uses this and joins the arguments properly. Option A misses the splat operator, so args is not an array. Option A has wrong parameter order. Option A ignores arguments.

🚀 Application

expert

What is the output of this Ruby code using method_missing and respond_to_missing??

Examine this Ruby class:

class DynamicResponder
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?("say_") || super
  end

  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("say_")
      "You called #{method_name} with #{args.join(", ")}"
    else
      super
    end
  end
end

obj = DynamicResponder.new
puts obj.say_hello("world")
puts obj.unknown_method

What will be the output?

Ruby

class DynamicResponder
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?("say_") || super
  end

  def method_missing(method_name, *args)
    if method_name.to_s.start_with?("say_")
      "You called #{method_name} with #{args.join(", ")}"
    else
      super
    end
  end
end

obj = DynamicResponder.new
puts obj.say_hello("world")
puts obj.unknown_method

A

You called say_hello with world
nil

B

You called say_hello with world
You called unknown_method with 

C

NoMethodError: undefined method `say_hello' for #<DynamicResponder:0x000...>
NoMethodError: undefined method `unknown_method' for #<DynamicResponder:0x000...>

D

You called say_hello with world
Traceback (most recent call last): ... NoMethodError: undefined method `unknown_method' for #<DynamicResponder:0x000...>

💡 Hint

Think about how respond_to_missing? and method_missing work together.

The method say_hello starts with "say_", so method_missing handles it and returns the string. The unknown_method does not start with "say_", so method_missing calls super, which raises NoMethodError. The respond_to_missing? method helps respond_to? but does not prevent errors.