Method lookup chain in Ruby - Step-by-Step Execution

Concept Flow - Method lookup chain

Call method on object

↓

Check object's class for method

↓

Check included modules in order

↓

Method found in module?

↓

Execute method

↓

Done

↓

Done

↓

Check superclass

↓

Repeat check up the chain

Yes↓

Execute method

↓

Done

When you call a method on an object, Ruby looks for it first in the object's class, then in included modules in order, then up the superclass chain until it finds the method or ends.

Execution Sample

Ruby

module M
  def greet; "Hello from M"; end
end

class A
  include M
  def greet; "Hello from A"; end
end

class B < A; end

puts B.new.greet

This code calls greet on an instance of B, which looks up the method through B, A, and module M.

Execution Table

Step	Lookup Location	Method Found?	Action	Output
1	B (class)	No	Check superclass
2	A (superclass of B)	Yes	Use A#greet method	Hello from A
3	End		Method executed, stop lookup	Hello from A

💡 Method found in superclass A, so lookup stops and method is executed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
object	B instance	B instance	B instance	B instance
method_location	unknown	B class (no)	A class (yes)	A class

Key Moments - 2 Insights

Why does Ruby check the superclass A before the included module M in this example?

Because the module M is included in class A, Ruby first checks B, then A, then modules included in A. Since A defines greet, it stops there (see execution_table step 2).

What happens if the method is not found in the class or any included modules?

Ruby continues looking up the superclass chain until it finds the method or reaches BasicObject. If not found, it raises a NoMethodError (not shown in this example).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the method greet found?

A Step 2

B Step 1

C Step 3

D Method not found

💡 Hint

Check the 'Method Found?' column in execution_table rows.

If class A did not define greet, where would Ruby look next?

A In class B again

B In superclass of A

C In modules included in A

D Stop and raise error

💡 Hint

Look at the concept_flow showing included modules are checked after class.

According to variable_tracker, what is the method_location after step 2?

A B class

B A class

C Module M

D Unknown

💡 Hint

See variable_tracker row for method_location after step 2.

Concept Snapshot

Method lookup chain in Ruby:
- Call method on object
- Check object's class
- Check included modules in order
- Check superclass chain
- Execute first found method
- If none found, raise NoMethodError

Full Transcript

When you call a method on an object in Ruby, the language looks for the method in a specific order called the method lookup chain. First, it checks the object's own class. If the method is not there, it looks in any modules included in that class, in the order they were included. If still not found, Ruby checks the superclass of the class, repeating the same process. This continues up the chain until the method is found or Ruby reaches the top class. If the method is found, Ruby executes it and stops looking further. If not found anywhere, Ruby raises an error. In the example, calling greet on an instance of class B causes Ruby to check B, then A, where greet is found and executed.