Ruby include Method

last modified April 27, 2025

This tutorial explains Ruby's include method for module inclusion. The include method mixes module functionality into classes.

The include method adds a module's methods as instance methods to a class. This is Ruby's primary mixin mechanism for sharing behavior.

Included modules become part of the class's ancestor chain. Their methods are available to all instances. Multiple includes are processed in order.

Basic Module Inclusion

This simple example shows how to include a module in a class. The module's methods become available to class instances.

module Greeter
 def greet
 "Hello from module!"
 end
end
class MyClass
 include Greeter
end
obj = MyClass.new
puts obj.greet

The Greeter module's greet method becomes available to MyClass instances. The include statement makes this happen.

Multiple Module Inclusion

A class can include multiple modules. Methods are searched in reverse inclusion order (last included, first checked).

module ModuleA
 def identify
 "From ModuleA"
 end
end
module ModuleB
 def identify
 "From ModuleB"
 end
end
class MyClass
 include ModuleA
 include ModuleB
end
obj = MyClass.new
puts obj.identify

ModuleB's method takes precedence because it was included last. Ruby searches modules in reverse inclusion order when resolving methods.

Included Modules in Ancestors

Included modules appear in a class's ancestor chain. This example demonstrates how to inspect the inheritance hierarchy.

module MyModule
 def module_method
 "Module method called"
 end
end
class MyClass
 include MyModule
end
puts MyClass.ancestors.inspect
obj = MyClass.new
puts obj.module_method

The ancestors method shows MyModule in the inheritance chain. This explains how instance methods become available.

Module Inclusion in Inheritance

When a class inherits from another, it also inherits all included modules. This example shows module inheritance.

module SharedBehavior
 def shared_method
 "Available to all subclasses"
 end
end
class Parent
 include SharedBehavior
end
class Child < Parent
end
obj = Child.new
puts obj.shared_method

The Child class inherits SharedBehavior from its parent. Modules become part of the inheritance hierarchy.

Extend vs Include

While include adds instance methods, extend adds class methods. This example contrasts both approaches.

module MyMethods
 def say_hello
 "Hello!"
 end
end
class WithInclude
 include MyMethods
end
class WithExtend
 extend MyMethods
end
puts WithInclude.new.say_hello
puts WithExtend.say_hello

include makes methods available to instances, while extend makes them available to the class itself. Both serve different purposes.

Including Kernel Module

Ruby's Kernel module is automatically included in Object. This example shows how to access kernel methods.

class MyClass
 # Kernel methods like 'puts' are already available
 def use_kernel_method
 puts "This is a Kernel method"
 end
end
obj = MyClass.new
obj.use_kernel_method

Common methods like puts come from the Kernel module. They're available everywhere because Object includes Kernel.

Conditional Module Inclusion

Modules can be included conditionally based on runtime factors. This allows flexible behavior composition.

module AdminFeatures
 def admin_action
 "Performing admin action"
 end
end
class User
 def initialize(is_admin)
 @is_admin = is_admin
 end
 def check_admin
 extend AdminFeatures if @is_admin
 end
end
admin = User.new(true)
admin.check_admin
puts admin.admin_action if admin.respond_to?(:admin_action)

Here we use extend conditionally to add admin features. The respond_to? check ensures safe method calling.

Source

Ruby Module#include Documentation

This tutorial covered Ruby's include method with practical examples showing module mixing, inheritance, and method lookup behavior.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.