Included hook in Ruby - Step-by-Step Execution

Concept Flow - Included hook

Define Module with included method

↓

Include Module in Class

↓

Ruby calls included hook

↓

Execute included method code

↓

Modify Class (e.g., add methods)

↓

Class ready with module features

When a module is included in a class, Ruby automatically calls the module's included method, allowing the module to modify the class.

Execution Sample

Ruby

module M
  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def greet
      "Hello from class"
    end
  end
end

class C
  include M
end

puts C.greet

This code shows a module with an included hook that adds class methods to the including class.

Execution Table

Step	Action	Evaluation	Result
1	Define module M with included method	Module M created with included hook	Module M ready
2	Define ClassMethods module inside M	ClassMethods module created	ClassMethods ready
3	Define class C	Class C created	Class C ready
4	Include module M in class C	Ruby calls M.included(C)	C extended with ClassMethods
5	Call C.greet	C.greet method found in ClassMethods	"Hello from class" printed
6	Program ends	No more code	Execution stops

💡 Program ends after printing the greeting from C.greet

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
M	Module defined	Included hook ready	No change	No change
C	Class defined	Extended with ClassMethods	Method greet available	No change

Key Moments - 2 Insights

Why does the included method get called automatically?

Because Ruby calls the included method on the module whenever it is included in a class, as shown in step 4 of the execution_table.

How does the class get new methods from the module?

The included method extends the class with ClassMethods module, adding methods like greet, as seen in step 4 and 5.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 4?

A The module M is defined

B The included hook is called and class C is extended

C The greet method is called

D The program ends

💡 Hint

Check the Action and Result columns at step 4 in the execution_table

According to variable_tracker, what changes happen to class C after step 4?

A C is extended with ClassMethods module

B C is deleted

C C loses all methods

D No change to C

💡 Hint

Look at the 'After Step 4' column for variable C in variable_tracker

If the included method was removed from module M, what would happen when including M in C?

A C would still get greet method

B Program would crash

C C would not get greet method

D included method would be called anyway

💡 Hint

Refer to how included hook adds ClassMethods in execution_table step 4

Concept Snapshot

module M
  def self.included(base)
    base.extend(ClassMethods) # runs when included
  end

  module ClassMethods
    def greet
      "Hello from class"
    end
  end
end

class C
  include M # triggers included hook
end

C.greet # => "Hello from class"

Full Transcript

This example shows how Ruby calls the included method automatically when a module is included in a class. The included method receives the class as an argument and can modify it, for example by extending it with additional methods. Here, module M defines an included method that extends the including class with ClassMethods, adding a greet method. When class C includes M, Ruby calls M.included(C), which adds greet to C. Calling C.greet then prints the greeting. This hook is useful to add class methods or perform setup when a module is included.