Method_missing for catch-all in Ruby - Step-by-Step Execution

Concept Flow - Method_missing for catch-all

Call an undefined method

↓

Ruby looks for method

↓

Method not found?

↓

Call method_missing

↓

Handle call or raise error

↓

Return result

When you call a method that does not exist, Ruby calls method_missing to handle it or raise an error.

Execution Sample

Ruby

class CatchAll
  def method_missing(name, *args)
    "Called #{name} with #{args}"
  end
end
obj = CatchAll.new
puts obj.any_method(1, 2)

This code catches calls to any undefined method and returns a string describing the call.

Execution Table

Step	Action	Method Called	Arguments	Result
1	Create object	N/A	N/A	obj is a CatchAll instance
2	Call undefined method	any_method	[1, 2]	No method found
3	Invoke method_missing	method_missing	any_method, [1, 2]	"Called any_method with [1, 2]"
4	Print result	N/A	N/A	Called any_method with [1, 2]

💡 method_missing handles the undefined method call and returns a string

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
obj	undefined	CatchAll instance	CatchAll instance	CatchAll instance	CatchAll instance
name	undefined	undefined	undefined	:any_method	:any_method
args	undefined	undefined	undefined	[1, 2]	[1, 2]
result	undefined	undefined	undefined	"Called any_method with [1, 2]"	"Called any_method with [1, 2]"

Key Moments - 3 Insights

Why does Ruby call method_missing instead of raising an error?

Because the method called (any_method) does not exist, Ruby automatically calls method_missing to handle it, as shown in step 3 of the execution_table.

What are the arguments passed to method_missing?

The first argument is the method name as a symbol (:any_method), and the second is an array of arguments ([1, 2]), as shown in the 'Arguments' column in step 3.

What happens if method_missing does not handle the call?

If method_missing does not handle the call or raise an error, Ruby will raise a NoMethodError. Here, method_missing returns a string, so no error occurs.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' at step 3?

A CatchAll instance

B "Called any_method with [1, 2]"

C No method found

D undefined

💡 Hint

Check the 'Result' column at step 3 in the execution_table.

At which step does Ruby realize the method is undefined and calls method_missing?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look for the step where 'Invoke method_missing' happens in the execution_table.

If method_missing did not return a string, what would happen?

A Ruby would call method_missing again

B Ruby would print nil

C Ruby would raise NoMethodError

D Ruby would ignore the call

💡 Hint

Recall the key_moments explanation about what happens if method_missing does not handle the call.

Concept Snapshot

method_missing(name, *args) is called when an undefined method is invoked.
It receives the method name and arguments.
You can handle the call or raise an error.
Useful for catch-all or dynamic method handling.
If not handled, Ruby raises NoMethodError.

Full Transcript

When you call a method that does not exist on an object, Ruby tries to find it but fails. Then Ruby calls the method_missing method on that object. This method receives the name of the missing method and any arguments passed. You can write code inside method_missing to handle these calls, like returning a message or performing some action. If method_missing does not handle the call, Ruby raises a NoMethodError. In the example, calling any_method with arguments 1 and 2 triggers method_missing, which returns a string describing the call. This way, method_missing acts as a catch-all for undefined methods.

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