Method_missing for catch-all in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is method_missing in Ruby?

method_missing is a special Ruby method that catches calls to methods that don't exist on an object. It lets you handle or respond to those calls dynamically.

beginner

How do you define method_missing in a Ruby class?

You define method_missing by creating a method named method_missing that takes at least one argument (the method name) and optionally others (arguments and block). Example:
def method_missing(name, *args, &block)

intermediate

Why use method_missing for catch-all methods?

It lets you catch any call to undefined methods and handle them in one place. This is useful for dynamic behavior, like delegating calls or creating flexible APIs.

intermediate

What should you do inside method_missing to avoid breaking Ruby's method lookup?

You should call super if you don't handle the method yourself. This lets Ruby raise the usual NoMethodError if needed.

beginner

How can method_missing improve user experience in a Ruby program?

It can provide helpful error messages or fallback behavior when users call methods that don't exist, making the program more forgiving and flexible.

What does method_missing do in Ruby?

A Prevents method calls

B Defines new methods automatically

C Handles calls to undefined methods

D Deletes methods from a class

method_missing catches calls to methods that don't exist and lets you handle them.

Which argument does method_missing always receive?

A The method's source code

B The method's return value

C The class name

D The method name as a symbol

The first argument to method_missing is the name of the missing method as a symbol.

What should you do inside method_missing if you don't handle a method call?

A Call <code>super</code>

B Return nil

C Raise a custom error

D Ignore the call

Calling super passes the call up so Ruby can raise NoMethodError properly.

Which of these is a common use of method_missing?

A Creating dynamic method handlers

B Improving performance by caching

C Encrypting method names

D Automatically documenting methods

method_missing is often used to create dynamic methods or delegate calls.

What happens if you don't define method_missing and call an undefined method?

A The method is created automatically

B Ruby raises <code>NoMethodError</code>

C The program crashes silently

D The call is ignored

Ruby raises a NoMethodError when a method is missing and method_missing is not defined.

Explain how method_missing works in Ruby and why it is useful.

Think about how Ruby handles unknown method calls.

Describe a simple example where method_missing can be used to create flexible method calls.

Imagine a class that responds to any method starting with 'say_'.

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