When you call a method on an object, Ruby looks for the implementation of that method. It looks in the following places and uses the first implementation it finds:

1. Methods from the object's singleton class (an unnamed class that only exists for that object)
2. Methods from prepended modules Show archive.org snapshot (Ruby 2.0+ feature)
3. Methods from the object's class
4. Methods from included modules
5. Methods from the class hierarchy (superclass and its ancestors)

Example

Do you need DevOps-experts?

Your development team has a full backlog? No time for infrastructure architecture? Our DevOps team is ready to support you!

• We build reliable cloud solutions with Infrastructure as code
• We are experts in security, Linux and databases
• We support your dev team to perform

Read more Show archive.org snapshot

Let's say we have the following class hierarchy:

class Superclass

  def action
    puts "Superclass"
  end 

end


module IncludedModule

  def action
    puts "Included module"
    super
  end
  
end


module PrependedModule

  def action
    puts "Prepended module"
    super
  end
  
end

module SingletonModule

  def action
    puts "Singleton class"
    super
  end

end

class Klass < Superclass
  include IncludedModule
  prepend PrependedModule

  def action
    puts "Klass"
    super
  end
  
end

... and we call a method like this:

instance = Klass.new
instance.extend(SingletonModule)
instance.action

Then we get an output as expected:

Singleton class
Prepended module
Klass
Included module
Superclass

If you are interested in why it works like that, you will find some more background here.