Ruby Method Lookup Chain Mastery
Master Ruby's method lookup mechanism, eigenclasses, singleton methods, and the ancestors chain. Understand how Ruby finds and executes methods in its sophisticated object model.
How Method Lookup Works
Method Lookup: When you call a method on an object, Ruby searches through a specific chain of classes and modules to find the method definition. Understanding this chain is crucial for debugging and metaprogramming.
The Ancestors Chain
# Every class has an ancestors chain
String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]
Array.ancestors
# => [Array, Enumerable, Object, Kernel, BasicObject]
# Method lookup follows this chain
"hello".upcase
# 1. Look in String class ✓ Found!
"hello".nil?
# 1. Look in String class ✗
# 2. Look in Comparable ✗
# 3. Look in Object ✗
# 4. Look in Kernel ✓ Found!
# Custom class with modules
module
Greetings
def
say_hello
"Hello from module!"
end
end
class
Person
include
Greetings
end
Person.ancestors
# => [Person, Greetings, Object, Kernel, BasicObject]
Method Lookup Order
# Method lookup order demonstration
module
A
def
test
; "From A"
; end
end
module
B
def
test
; "From B"
; end
end
class
TestClass
include
A
include
B
# B is included after A
def
test
"From TestClass"
end
end
TestClass.ancestors
# => [TestClass, B, A, Object, Kernel, BasicObject]
obj = TestClass.new
obj.test
# => "From TestClass" (class method wins)
# Remove class method to see module method
TestClass.remove_method(:test)
obj.test
# => "From B" (B comes before A in ancestors)
Singleton Methods & Eigenclasses
Eigenclasses: Every object has a hidden singleton class (eigenclass) that sits between the object and its class in the method lookup chain. This is where singleton methods are stored.
Singleton Methods
# Adding methods to specific objects
str = "hello"
# Method 1: def object.method_name
def
str.shout self.upcase + "!!!"
end
# Method 2: define_singleton_method
str.define_singleton_method(:whisper) do
self.downcase + "..."
end
# Method 3: class_eval on singleton_class
str.singleton_class.class_eval do
def
reverse_shout
self.reverse.upcase
end
end
# Use the singleton methods
str.shout
# => "HELLO!!!"
str.whisper
# => "hello..."
str.reverse_shout
# => "OLLEH"
# Other strings don't have these methods
other_str = "world"
other_str.respond_to?(:shout)
# => false
Eigenclass Exploration
# Exploring eigenclasses (singleton classes)
obj = "hello"
eigenclass = obj.singleton_class
# Eigenclass is unique to this object
eigenclass.class
# => Class
eigenclass.superclass
# => String (points to object's class)
# Different objects have different eigenclasses
obj1 = "hello"
obj2 = "world"
obj1.singleton_class == obj2.singleton_class
# => false
# Eigenclass in method lookup
def
obj1.special_method "I'm special!"
end
# Method lookup: eigenclass -> String -> Comparable -> Object -> Kernel -> BasicObject
obj1.special_method
# => "I'm special!" (found in eigenclass)