Respond_to_missing? convention in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using respond_to_missing?

Consider this Ruby class that uses method_missing and respond_to_missing?. What will be printed when calling obj.greet?

Ruby

class Greeter
  def respond_to_missing?(method_name, include_private = false)
    method_name == :greet || super
  end

  def method_missing(method_name, *args, &block)
    if method_name == :greet
      "Hello!"
    else
      super
    end
  end
end

obj = Greeter.new
puts obj.greet

A Hello!

B NoMethodError

C false

D nil

💡 Hint

Check how respond_to_missing? affects method detection and how method_missing handles calls.

The respond_to_missing? method tells Ruby that the object responds to :greet. When obj.greet is called, method_missing catches it and returns "Hello!".

🧠 Conceptual

intermediate

Why implement respond_to_missing? when using method_missing?

Why is it important to implement respond_to_missing? when you override method_missing in Ruby?

A To automatically define missing methods without writing them manually.

B To speed up method calls by caching missing methods.

C To correctly report which methods the object can respond to, improving compatibility with Ruby's introspection methods.

D To prevent runtime errors when calling any undefined method.

💡 Hint

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

Implementing respond_to_missing? ensures that methods like respond_to? and others that check method availability work correctly with dynamic methods handled by method_missing.

🔧 Debug

advanced

What error does this code raise and why?

Examine this Ruby code snippet. What error will it raise when calling obj.foo and why?

Ruby

class Speaker < BasicObject
  def respond_to_missing?(method_name, include_private = false)
    method_name == :hello
  end

  def method_missing(method_name, *args, &block)
    if method_name == :hello
      "Hi!"
    else
      super
    end
  end
end

obj = Speaker.new
puts obj.foo

A NoMethodError: super called in method_missing without a superclass method

B Hello!

C ArgumentError: wrong number of arguments

D NameError: undefined local variable or method

💡 Hint

Check what happens when super is called inside method_missing without a parent method_missing.

The super call in method_missing tries to call the parent's method_missing, but BasicObject does not define it, causing a NoMethodError.

📝 Syntax

advanced

Which option correctly implements respond_to_missing? for dynamic methods?

Which of the following Ruby code snippets correctly implements respond_to_missing? to handle dynamic methods starting with 'find_'?

A

def respond_to_missing?(method_name, include_private = false)
  method_name.start_with?("find_")
end

B

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

C

def respond_to_missing?(method_name)
  method_name.start_with?("find_") || super
end

D

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

💡 Hint

Remember the method signature and that method_name is a symbol.

Option B correctly converts method_name to string and checks if it starts with 'find_'. It also calls super for other cases. Option B misses the second argument and calls start_with? on a symbol, causing error. Option B misses super call. Option B uses include? instead of start_with?, which is not the requirement.

🚀 Application

expert

How many methods does this object respond to?

Given this Ruby class, how many methods will obj.respond_to? return true for, when checking :foo1, :foo2, :bar, and :baz?

Ruby

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

  def method_missing(method_name, *args, &block)
    if method_name.to_s.start_with?("foo")
      "Handled #{method_name}"
    else
      super
    end
  end
end

obj = DynamicResponder.new
results = {
  foo1: obj.respond_to?(:foo1),
  foo2: obj.respond_to?(:foo2),
  bar: obj.respond_to?(:bar),
  baz: obj.respond_to?(:baz)
}
puts results.select { |_, v| v }.size

A 3

B 4

C 0

D 2

💡 Hint

Check which method names start with 'foo' and how respond_to_missing? works.

The object responds to methods starting with 'foo' only. So :foo1 and :foo2 return true, but :bar and :baz return false. Hence, 2 methods respond true.