Respond_to_missing? convention in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the respond_to_missing? method in Ruby?

It tells Ruby whether an object can respond to a method that is not explicitly defined, usually used with method_missing to handle dynamic method calls.

intermediate

How does respond_to_missing? improve Ruby objects?

It makes Ruby objects behave correctly with respond_to?, so tools and code that check if a method exists get accurate answers even for dynamic methods.

beginner

What arguments does respond_to_missing? take?

It takes two arguments: the method name (as a symbol) and a boolean indicating if private methods should be included.

intermediate

Why should you always override respond_to_missing? when using method_missing?

Because respond_to? relies on respond_to_missing? to know if an object can handle a method, so overriding it keeps behavior consistent and avoids surprises.

intermediate

Example: How to implement respond_to_missing? for dynamic methods starting with 'find_'?

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

This means the object claims to respond to any method starting with 'find_'.

What does respond_to_missing? help Ruby objects do?

A Prevent errors from undefined methods

B Automatically define missing methods

C Override all existing methods

D Tell if they can handle methods not explicitly defined

respond_to_missing? tells Ruby if an object can respond to a method that is not explicitly defined, helping respond_to? work correctly.

Which method usually works together with respond_to_missing??

A method_missing

B initialize

C to_s

D clone

method_missing handles calls to undefined methods, and respond_to_missing? tells if those methods are supported.

What should respond_to_missing? return if it does not recognize the method?

A false

B true

C nil

D raise an error

If the method is not recognized, respond_to_missing? should return false or call super to delegate.

What arguments does respond_to_missing? receive?

A no arguments

B method name and include_private flag

C method name and arguments list

D only method name

It receives the method name as a symbol and a boolean flag indicating if private methods should be considered.

Why is overriding respond_to_missing? important when using method_missing?

A To speed up method calls

B To disable private methods

C To keep <code>respond_to?</code> accurate

D To automatically define methods

Overriding respond_to_missing? ensures respond_to? returns true for dynamic methods handled by method_missing.

Explain how respond_to_missing? works together with method_missing in Ruby.

Think about how Ruby checks if an object can respond to a method before calling it.

Describe a simple example of implementing respond_to_missing? for dynamic methods.

Consider dynamic methods starting with a prefix like 'find_'.

Practice

1.

What is the main purpose of respond_to_missing? in Ruby?

easy

A. To tell Ruby if an object can handle a method not explicitly defined

B. To automatically define missing methods

C. To raise errors when a method is missing

D. To list all methods of an object

Solution

1. Step 1: Understand the role of respond_to_missing?

   This method is used to inform Ruby whether an object can respond to a method that is not explicitly defined in the class.

2. Step 2: Differentiate from other options

   It does not define methods automatically, raise errors, or list methods; it only answers if a method can be handled dynamically.

3. Final Answer:

   To tell Ruby if an object can handle a method not explicitly defined -> Option A

4. Quick Check:

   respond_to_missing? = informs about dynamic methods [OK]

Hint: Remember: respond_to_missing? answers if method can be handled [OK]

Common Mistakes:

• Thinking it defines missing methods automatically
• Confusing it with method_missing itself
• Assuming it raises errors for missing methods

2.

Which of the following is the correct way to define respond_to_missing? in a Ruby class?

class MyClass
  def respond_to_missing?(method_name, include_private = false)
    # ???
  end
end

easy

A. return method_name == :find_user

B. return true if method_name.to_s.start_with?("find_")

C. return false

D. return method_missing(method_name)

Solution

1. Step 1: Check the method signature and expected return

   respond_to_missing? should return true or false depending on whether the object can handle the method dynamically.

2. Step 2: Analyze each option

   return true if method_name.to_s.start_with?("find_") returns true if the method name starts with "find_", which is a common pattern for dynamic methods. return method_name == :find_user only returns true for one exact method, which is valid but less flexible. return false always returns false, which defeats the purpose. return method_missing(method_name) incorrectly calls method_missing, which is not correct here.

3. Final Answer:

   return true if method_name.to_s.start_with?("find_") -> Option B

4. Quick Check:

   respond_to_missing? returns true for dynamic method patterns [OK]

Hint: Use method_name.to_s and return true for matching patterns [OK]

Common Mistakes:

• Calling method_missing inside respond_to_missing?
• Always returning false
• Checking method_name without converting to string

3.

What will be the output of the following Ruby code?

class Dynamic
  def respond_to_missing?(method_name, _)
    method_name.to_s.start_with?("say_")
  end

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

d = Dynamic.new
puts d.say_hello("world")
puts d.unknown_method

medium

A. You called say_hello with world
NoMethodError

B. NoMethodError
NoMethodError

C. You called say_hello with world
You called unknown_method with

D. No output

Solution

1. Step 1: Analyze respond_to_missing? behavior

   It returns true only for methods starting with "say_".

2. Step 2: Trace method calls

   d.say_hello("world") triggers method_missing, which checks respond_to_missing? and returns true, so it returns the string. d.unknown_method triggers method_missing, respond_to_missing? returns false, so super is called, raising NoMethodError.

3. Final Answer:

   You called say_hello with world NoMethodError -> Option A

4. Quick Check:

   respond_to_missing? controls method_missing handling [OK]

Hint: respond_to_missing? true means method_missing handles it [OK]

Common Mistakes:

• Assuming all missing methods are handled
• Ignoring super call in method_missing
• Not matching method_name pattern correctly

4.

Identify the error in this Ruby class using respond_to_missing? and method_missing:

class Broken
  def respond_to_missing?(method_name, include_private = false)
    method_name.to_s.start_with?("do_")
  end

  def method_missing(method_name, *args)
    "Doing #{method_name}"
  end
end

b = Broken.new
puts b.do_something
puts b.unknown

medium

A. respond_to_missing? must not have default parameters

B. respond_to_missing? should always return true

C. method_missing should call super for unknown methods

D. method_missing must not accept *args

Solution

1. Step 1: Understand method_missing behavior

   method_missing should handle only methods that respond_to_missing? returns true for; otherwise, it should call super to raise NoMethodError.

2. Step 2: Identify the problem in the code

   Here, method_missing always returns a string, even for unknown methods, so it hides errors and breaks expected behavior.

3. Final Answer:

   method_missing should call super for unknown methods -> Option C

4. Quick Check:

   method_missing must call super if method not handled [OK]

Hint: Always call super in method_missing for unhandled methods [OK]

Common Mistakes:

• Not calling super in method_missing
• Returning wrong types from method_missing
• Misusing respond_to_missing? signature

5.

You want to create a Ruby class that dynamically handles methods starting with calc_ by returning the method name reversed. Which respond_to_missing? and method_missing implementation correctly follows the convention?

hard

A. def respond_to_missing?(method_name, _)
method_name.to_s.start_with?("calc_")
end

def method_missing(method_name, *args)
method_name.reverse
end

B. def respond_to_missing?(method_name, _)
true
end

def method_missing(method_name, *args)
method_name.to_s.reverse
end

C. def respond_to_missing?(method_name, _)
method_name.to_s.include?("calc_")
end

def method_missing(method_name, *args)
method_name.reverse
end

D. def respond_to_missing?(method_name, _)
method_name.to_s.start_with?("calc_")
end

def method_missing(method_name, *args)
if respond_to_missing?(method_name, false)
method_name.to_s.reverse
else
super
end
end

Solution

1. Step 1: Verify respond_to_missing? logic

   The correct version returns true only if the method_name.to_s starts with "calc_" and ignores the include_private parameter using _.

2. Step 2: Verify method_missing logic

   The correct version checks respond_to_missing?(method_name, false) before returning method_name.to_s.reverse, and calls super otherwise.

3. Final Answer:

   def respond_to_missing?(method_name, _) method_name.to_s.start_with?("calc_") end def method_missing(method_name, *args) if respond_to_missing?(method_name, false) method_name.to_s.reverse else super end end -> Option D

4. Quick Check:

   Use respond_to_missing? check and call super in method_missing [OK]

Hint: Call super in method_missing unless respond_to_missing? true [OK]

Common Mistakes:

• Not calling super in method_missing
• Using include? instead of start_with?
• Always returning true in respond_to_missing?