• Nesnenin singleton metotları
• Nesnenin sınıfı
• Sınıfın `include` ettiği modüller (eklenme sırasının tersiyle, yani en son eklenen modül ilk aranır)
• Sınıfın üst sınıfı
• Üst sınıfın `include` ettiği modüller
• Bu yol `BasicObject`'e kadar devam eder.

module Greeter
  def greet
    "Hello, I am #{name}."
  end
end

class Person
  include Greeter # Greeter modülünü Person sınıfına dahil ediyoruz
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

class Robot
  include Greeter # Greeter modülünü Robot sınıfına da dahil ediyoruz
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

person = Person.new("Alice")
robot = Robot.new("Bumblebee")

puts person.greet  # Çıktı: Hello, I am Alice.
puts robot.greet   # Çıktı: Hello, I am Bumblebee.

# Sınıfların metot arama yollarını inceleyelim
puts "Person.ancestors: #{Person.ancestors.inspect}"
# Çıktı: Person.ancestors: [Person, Greeter, Object, Kernel, BasicObject]
puts "Robot.ancestors: #{Robot.ancestors.inspect}"
# Çıktı: Robot.ancestors: [Robot, Greeter, Object, Kernel, BasicObject]

• Kod Tekrar Kullanımı: Ortak davranışları tek bir modülde toplayarak birden fazla sınıfta kolayca kullanılmasını sağlar. Bu, kodun DRY (Don't Repeat Yourself) prensibine uygun olmasını teşvik eder.
• Çoklu Kalıtımın Olumsuzluklarından Kaçınma: Çoklu kalıtımın potansiyel karmaşıklıkları (örneğin, aynı isimde metotların farklı üst sınıflarda bulunmasından kaynaklanan "elmas problemi") olmadan, sınıflara birden fazla davranış seti eklemeyi mümkün kılar.
• Dinamik Davranış Ekleme: Mevcut sınıflara yeni özellikler ve yetenekler eklemenin esnek bir yoludur. Kütüphaneler ve framework'ler sıklıkla bu yeteneği kullanır.
• Polimorfizm: Farklı sınıflar aynı modülü `include` ettiğinde, aynı arayüze sahip olurlar. Bu, farklı türdeki nesneleri aynı şekilde işleyebilmenizi sağlayarak polimorfizmi destekler.
• Bakım Kolaylığı: Ortak davranışlar merkezi bir modülde tanımlandığı için, bu davranışlarda yapılacak değişiklikler sadece modül üzerinde yapılır ve otomatik olarak tüm ilgili sınıflara yansır.

• `include`: Bir modülün metotlarını sınıfın örnek metotları haline getirir. Yani, sınıfın nesneleri bu metotları çağırabilir.
• `extend`: Bir modülün metotlarını sınıfın kendisinin singleton metotları haline getirir (yani sınıf metotları). Bu metotlar doğrudan sınıfın kendisi üzerinden çağrılabilir, nesneleri üzerinden değil.

module Logger
  def log_message(message)
    puts "[#{Time.now}] #{message}"
  end
end

class Application
  extend Logger # Logger modülünü sınıf metotları olarak ekle
  
  def self.start
    log_message "Application started." # Sınıf üzerinden çağrılır
  end
  
  def run
    Application.log_message "Running instance method." # Hala sınıf üzerinden çağrılmalı
    # log_message "Running instance method." # Bu satır hata verir, çünkü bu bir instance metodu değil.
  end
end

Application.start # Çıktı: [YYYY-MM-DD HH:MM:SS +TZ] Application started.
app = Application.new
app.run # Çıktı: [YYYY-MM-DD HH:MM:SS +TZ] Running instance method.

• Enumerable Modülü: Bu modül, bir sınıf `each` metodunu uyguladığında (ki bu metodun nasıl iterasyon yapacağını bilmesi gerekir), `map`, `select`, `find`, `sort`, `group_by` gibi birçok güçlü koleksiyon işleme metodunu otomatik olarak sağlar. Ruby'deki diziler (`Array`), hash'ler (`Hash`) ve aralıklar (`Range`) gibi sınıfların çoğu Enumerable'ı `include` eder.
  
  
  Kod:

  class MyCollection
    include Enumerable # Bu modülü dahil ediyoruz
  
    def initialize(*elements)
      @elements = elements
    end
  
    def each(&block) # Enumerable modülünün çalışması için bu metodu tanımlamalıyız
      @elements.each(&block)
    end
  end
  
  collection = MyCollection.new(1, 2, 3, 4, 5)
  puts "Tek sayılar: #{collection.select { |e| e.odd? }.inspect}" # Çıktı: Tek sayılar: [1, 3, 5]
  puts "Elemanların iki katı: #{collection.map { |e| e * 2 }.inspect}" # Çıktı: Elemanların iki katı: [2, 4, 6, 8, 10]
  puts "İlk tek sayı: #{collection.find { |e| e.odd? }}" # Çıktı: İlk tek sayı: 1

• Comparable Modülü: Eğer bir sınıfın nesneleri arasında karşılaştırma yapmak istiyorsanız, bu modülü `include` edebilirsiniz. Tek yapmanız gereken, `self` ve başka bir nesneyi karşılaştıran ve -1 (self daha küçük), 0 (eşit) veya 1 (self daha büyük) döndüren `<=>` (spaceshift operatörü) metodunu tanımlamaktır. Comparable, bu metodu kullanarak `<`, `>`, `<=`, `>=`, `==` ve `between?` gibi diğer karşılaştırma metotlarını otomatik olarak sağlar.
  
  
  Kod:

  class Book
    include Comparable # Bu modülü dahil ediyoruz
    attr_reader :title, :pages
  
    def initialize(title, pages)
      @title = title
      @pages = pages
    end
  
    def <=>(other) # Comparable modülünün çalışması için bu metodu tanımlamalıyız
      return nil unless other.is_a?(Book)
      self.pages <=> other.pages # Sayfa sayısına göre karşılaştırıyoruz
    end
  
    def to_s
      "#{@title} (#{@pages} sayfa)"
    end
  end
  
  book1 = Book.new("Dune", 412)
  book2 = Book.new("Foundation", 244)
  book3 = Book.new("Dune", 412)
  
  puts "#{book1} > #{book2}: #{book1 > book2}" # Çıktı: Dune (412 sayfa) > Foundation (244 sayfa): true
  puts "#{book1} < #{book2}: #{book1 < book2}" # Çıktı: Dune (412 sayfa) < Foundation (244 sayfa): false
  puts "#{book1} == #{book3}: #{book1 == book3}" # Çıktı: Dune (412 sayfa) == Dune (412 sayfa): true
  puts "#{book1} between #{book2} and #{book3}: #{book1.between?(book2, book3)}" # Çıktı: Dune (412 sayfa) between Foundation (244 sayfa) and Dune (412 sayfa): true

"Mix-in'ler, sınıflara davranış kazandırmanın esnek bir yoludur, ancak aşırıya kaçmak veya kötü tasarlanmış modüller kullanmak, kodun karmaşıklığını ve anlaşılırlığını artırabilir. Modüllerin tek bir sorumluluğu olmasına dikkat edin."

Genişletmek için tıkla ...

• İsim Çakışmaları: Eğer bir modülde ve onu `include` eden sınıfta aynı isimde metotlar varsa, sınıfın kendi içinde tanımlanan metot modüldekine göre öncelik alır. Bu, beklenmedik davranışlara yol açabilir. Metot arama yolu bu durumu netleştirir.
• Bağımlılıklar: Bazı modüller (Enumerable gibi) belirli metotların sınıfta tanımlanmasını bekler. Bu bağımlılıklar belgelenmeli ve takip edilmelidir.
• Aşırı Kullanım: Çok fazla modülü bir sınıfa dahil etmek, o sınıfın ne yaptığını anlamayı zorlaştırabilir ve "tanımlanmamış" bağımlılıklara yol açabilir. Modülerliği korumak için modülleri mantıksal olarak bölmek önemlidir.