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.

Practice

1.

What does the included hook do in a Ruby module?

easy

A. It runs only when the module is extended, not included.

B. It runs code automatically when the module is included in a class.

C. It prevents the module from being included in any class.

D. It defines a method that must be called manually.

Solution

1. Step 1: Understand the purpose of the included hook

   The included hook is a special method in Ruby modules that runs automatically when the module is included in a class.

2. Step 2: Compare options with the definition

   Only It runs code automatically when the module is included in a class. correctly describes this automatic behavior. Other options describe manual calls, prevention, or extension, which are incorrect.

3. Final Answer:

   It runs code automatically when the module is included in a class. -> Option B

4. Quick Check:

   Included hook = automatic run on include [OK]

Hint: Remember: included runs automatically on module inclusion [OK]

Common Mistakes:

• Thinking included runs on extend instead of include
• Believing included requires manual method calls
• Confusing included with preventing inclusion

2.

Which of the following is the correct syntax to define an included hook inside a Ruby module?

module Example
  # What goes here?
end

easy

A. def self.included(base)
puts "Included in #{base}"
end

B. def included(base)
puts "Included in #{base}"
end

C. def included
puts "Included"
end

D. def self.include(base)
puts "Included in #{base}"
end

Solution

1. Step 1: Recall how to define class methods in modules

   The included hook must be a module method, so it needs to be defined with self.included.

2. Step 2: Check the method signature

   The method receives the including class as a parameter, so it must accept one argument (base).

3. Final Answer:

   def self.included(base) puts "Included in #{base}" end -> Option A

4. Quick Check:

   included hook = def self.included(base) [OK]

Hint: Use def self.included(base) for included hook syntax [OK]

Common Mistakes:

• Defining included without self (instance method instead of module method)
• Missing the base parameter
• Using def self.include instead of included

3.

What will be the output of this Ruby code?

module Greetings
  def self.included(base)
    puts "Greetings included in #{base}"
  end
end

class Person
  include Greetings
end

medium

A. SyntaxError

B. No output

C. Greetings included in Person

D. Greetings included in Greetings

Solution

1. Step 1: Identify when included hook runs

   The included hook runs automatically when the module is included in a class.

2. Step 2: Check the output inside the included method

   The method prints "Greetings included in #{base}", where base is the class Person.

3. Final Answer:

   Greetings included in Person -> Option C

4. Quick Check:

   included hook prints class name on include [OK]

Hint: included hook prints message with class name on include [OK]

Common Mistakes:

• Expecting no output because included is a hook
• Confusing base with module name
• Thinking included runs on class definition, not include

4.

Find the error in this Ruby code using the included hook:

module Logger
  def included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def log(msg)
      puts "Log: #{msg}"
    end
  end
end

class App
  include Logger
end

App.log("Start")

medium

A. The include statement should be extend.

B. The ClassMethods module should be included, not extended.

C. The log method should be an instance method, not class method.

D. The included method should be defined as self.included, not instance method.

Solution

1. Step 1: Check how included hook is defined

   The included hook must be a module method, defined as self.included, not an instance method.

2. Step 2: Understand the effect of incorrect definition

   Defining included without self means it won't run automatically on include, so base.extend won't happen.

3. Final Answer:

   The included method should be defined as self.included, not instance method. -> Option D

4. Quick Check:

   included hook must be self.included [OK]

Hint: Define included as self.included to run on module include [OK]

Common Mistakes:

• Defining included without self
• Confusing extend and include in hook
• Trying to call class method on instance

5.

You want to add a class method greet to any class that includes your module Friendly. Which is the best way to do this using the included hook?

module Friendly
  # Fill in the included hook
end

class Dog
  include Friendly
end

puts Dog.greet

hard

A. Define self.included(base) and inside it call base.extend with a module containing greet.

B. Define an instance method greet inside Friendly module.

C. Define a class method greet directly inside Friendly module without included hook.

D. Call include Friendly inside Dog.greet method.

Solution

1. Step 1: Understand how to add class methods via included hook

   To add class methods, define self.included(base) and call base.extend with a module containing those methods.

2. Step 2: Why other options fail

   Instance methods won't be class methods; defining class methods directly in module won't add them to including class; calling include inside method is incorrect.

3. Final Answer:

   Define self.included(base) and inside it call base.extend with a module containing greet. -> Option A

4. Quick Check:

   Use included hook + base.extend for class methods [OK]

Hint: Use included hook with base.extend to add class methods [OK]

Common Mistakes:

• Defining greet as instance method instead of class method
• Not using included hook to extend class
• Trying to call include inside a method