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.

basic_include.rb

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).

multiple_includes.rb

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.

ancestors_chain.rb

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.

inheritance_inclusion.rb

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.

extend_vs_include.rb

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.

kernel_inclusion.rb

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.

conditional_include.rb

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.

Ebooks