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.

Practice

1.

What is the main purpose of the method_missing method in Ruby?

easy

A. To catch calls to methods that do not exist and handle them dynamically.

B. To define a method that always returns nil.

C. To automatically create getter and setter methods.

D. To override existing methods with new behavior.

Solution

1. Step 1: Understand what method_missing does

   method_missing is called when an object receives a method call it does not have defined.

2. Step 2: Identify its purpose

   It allows handling these unknown method calls dynamically, enabling flexible behavior.

3. Final Answer:

   To catch calls to methods that do not exist and handle them dynamically. -> Option A

4. Quick Check:

   method_missing catches unknown methods [OK]

Hint: Remember: method_missing handles calls to undefined methods [OK]

Common Mistakes:

• Thinking method_missing defines new methods automatically
• Confusing method_missing with attr_accessor
• Assuming method_missing overrides existing methods

2.

Which of the following is the correct syntax to define method_missing in a Ruby class?

class Example
  # Your code here
end

easy

A. def method_missing(method_name)
puts "Unknown method: #{method_name}"
end

B. def method_missing(method_name, args)
puts "Unknown method: #{method_name} with args: #{args}"
end

C. def method_missing(method_name, *args)
puts "Unknown method: #{method_name} with args: #{args}"
end

D. def method_missing(*args)
puts "Unknown method called"
end

Solution

1. Step 1: Recall method_missing signature

   The method receives the missing method's name as a symbol and any arguments as a splat array.

2. Step 2: Check each option's parameters

   def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end correctly uses method_name, *args to capture method name and all arguments.

3. Final Answer:

   def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end -> Option C

4. Quick Check:

   Correct parameters = def method_missing(method_name, *args) puts "Unknown method: #{method_name} with args: #{args}" end [OK]

Hint: method_missing needs method name and splat args [OK]

Common Mistakes:

• Forgetting the splat (*) before args
• Using only one parameter for method_missing
• Passing args without splat causing errors

3.

What will be the output of this Ruby code?

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

obj = CatchAll.new
puts obj.hello('world')

medium

A. hello

B. Called hello with world

C. NoMethodError

D. Called method_missing with hello

Solution

1. Step 1: Understand method_missing behavior

   The method_missing catches the call to hello which is undefined and returns a string with method name and arguments.

2. Step 2: Evaluate the output

   Calling obj.hello('world') triggers method_missing with name :hello and args ['world'], so output is "Called hello with world".

3. Final Answer:

   Called hello with world -> Option B

4. Quick Check:

   method_missing output = Called hello with world [OK]

Hint: method_missing returns string with method name and args [OK]

Common Mistakes:

• Expecting NoMethodError instead of method_missing output
• Confusing method name symbol with string
• Ignoring args passed to method_missing

4.

Identify the error in this Ruby class using method_missing:

class Test
  def method_missing(name)
    puts "Missing: #{name}"
  end
end

Test.new.unknown_method(1, 2)

medium

A. method_missing should accept a splat argument for extra parameters.

B. method_missing must return a value, not puts.

C. method_missing cannot be defined in a class.

D. No error; code runs fine.

Solution

1. Step 1: Check method_missing parameters

   The call unknown_method(1, 2) passes two arguments, but method_missing only accepts one parameter name.

2. Step 2: Identify the fix

   To handle any number of arguments, method_missing must accept *args as a splat parameter.

3. Final Answer:

   method_missing should accept a splat argument for extra parameters. -> Option A

4. Quick Check:

   Missing splat args causes error [OK]

Hint: Add *args to method_missing to catch all parameters [OK]

Common Mistakes:

• Ignoring extra arguments passed to missing method
• Assuming puts return is enough
• Thinking method_missing can't be defined in classes

5.

Given this class, what will obj.foo.bar(1) output?

class CatchAll
  def method_missing(name, *args)
    if name == :bar
      "Handled bar with #{args[0]}"
    else
      self
    end
  end
end

obj = CatchAll.new
puts obj.foo.bar(1)

hard

A. NoMethodError for foo

B. Handled bar with nil

C. self

D. Handled bar with 1

Solution

1. Step 1: Trace obj.foo call

   Calling obj.foo triggers method_missing with name=:foo, which returns self (the object itself).

2. Step 2: Trace .bar(1) call on returned self

   Calling .bar(1) triggers method_missing with name=:bar and args [1], which returns "Handled bar with 1".

3. Final Answer:

   Handled bar with 1 -> Option D

4. Quick Check:

   Chained method_missing returns handled string [OK]

Hint: method_missing can return self to chain calls [OK]

Common Mistakes:

• Expecting NoMethodError on first call
• Not realizing method_missing returns self for chaining
• Assuming args are missing for bar method