Method_missing for catch-all in Ruby - Time & Space Complexity

Time Complexity: Method_missing for catch-all

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run a method_missing catch-all grows as we call different methods.

Specifically, how does the program behave when it handles unknown method calls?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class CatchAll
  def method_missing(name, *args)
    "You called: #{name} with #{args.length} arguments"
  end
end

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

This code catches any unknown method call and returns a message including the method name and argument count.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The method_missing is called once per unknown method call.
• How many times: Once per unknown method call; no loops or recursion inside method_missing.

How Execution Grows With Input

Each unknown method call triggers method_missing once, doing a simple string operation.

Input Size (n)	Approx. Operations
10 unknown calls	10 simple string operations
100 unknown calls	100 simple string operations
1000 unknown calls	1000 simple string operations

Pattern observation: The work grows directly with the number of unknown method calls, each handled quickly.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with the number of unknown method calls made.

Common Mistake

[X] Wrong: "method_missing runs once and handles all unknown calls at once."

[OK] Correct: method_missing runs separately for each unknown call, so time adds up with each call.

Interview Connect

Understanding how method_missing works helps you reason about dynamic method handling and its cost in real programs.

Self-Check

"What if method_missing called another method inside that loops over arguments? How would the time complexity change?"

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