Respond_to_missing? convention in Ruby - Mini Project: Build & Apply

Using the respond_to_missing? Convention in Ruby

📖 Scenario: Imagine you are building a simple Ruby class that can answer questions about a person, but only for certain known questions. You want your class to behave nicely when Ruby checks if it can respond to a question (method call) that might not be explicitly defined.

🎯 Goal: You will create a Ruby class that uses the respond_to_missing? method to correctly tell Ruby which methods it can handle dynamically. This helps Ruby and other programmers understand what your object can do.

📋 What You'll Learn

Create a class called Person with a constructor that takes a name string

Define a method_missing method that handles the method greet by returning a greeting string

Define a respond_to_missing? method that returns true for the greet method and false otherwise

Create an instance of Person with the name "Alice"

Check if the instance responds to greet and farewell methods

Call the greet method on the instance and print the result

💡 Why This Matters

🌍 Real World

Using <code>respond_to_missing?</code> helps Ruby objects behave predictably when they handle methods dynamically, such as in libraries that create methods on the fly or proxy objects.

💼 Career

Understanding this convention is important for Ruby developers working with metaprogramming, dynamic APIs, or frameworks like Rails that rely on method_missing patterns.

1

Create the Person class with a name attribute

Create a class called Person with an initialize method that takes a parameter name and stores it in an instance variable @name.

Ruby

class Person
  # Your code here
end

Need a hint?

Use def initialize(name) and set @name = name inside the method.

2

Add method_missing to handle greet

Inside the Person class, define a method_missing method that takes method_name and *args. If method_name is :greet, return a string "Hello, " followed by the @name. Otherwise, call super.

Ruby

class Person
  def initialize(name)
    @name = name
  end

  # Define method_missing to handle :greet
  # Your code here
end

Need a hint?

Check if method_name equals :greet. Return the greeting string or call super.

3

Add respond_to_missing? to declare support for greet

Inside the Person class, define a respond_to_missing? method that takes method_name and include_private. Return true if method_name is :greet, otherwise return super.

Ruby

class Person
  def initialize(name)
    @name = name
  end

  def method_missing(method_name, *args)
    if method_name == :greet
      "Hello, #{@name}"
    else
      super
    end
  end

  # Define respond_to_missing? to return true for :greet
  # Your code here
end

Need a hint?

Return true if method_name is :greet, else call super.

4

Create instance, check methods, and print greeting

Create a variable person as a new Person with the name "Alice". Print the result of person.respond_to?(:greet) and person.respond_to?(:farewell). Then print the result of calling person.greet.

Ruby

class Person
  def initialize(name)
    @name = name
  end

  def method_missing(method_name, *args)
    if method_name == :greet
      "Hello, #{@name}"
    else
      super
    end
  end

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

# Create instance and print outputs
# Your code here

Need a hint?

Create the person object, print respond_to? results for :greet and :farewell, then print person.greet.