Question

I want to put a method in a Ruby module such that it can be called from a class method or an instance method, using simple syntax:

module MyMod
  def fmt *args
    args.map { | a | "You said #{a}" }
  end
end

class MyClass
  include MyMod
  def inst
    puts fmt 1,2,3
  end
  def self.cls
    puts fmt 4,5,6
  end
end

The above doesn’t work because the class method (cls) can’t see the instance method fmt. If I change the definition to self.fmt, then the instance method has to invoke it as MyMod.fmt.

I’d like to be able to just invoke fmt (some stuff) from both types of method. Is there a “ruby-ish” way of doing this? I can define the module as

module MyMod
  def self.fmt *args
    args.map { | a | "You said #{a}" }
  end
  def fmt *args
    MyMod.fmt args
  end
end

but that’s not very DRY, is it? Is there a simpler way?

Answer 1

You can use advantage of Module#included method to do it like that:

module MyMod
  # here base is a class the module is included into
  def self.included(base)
    # extend includes all methods of the module as class methods
    # into the target class
    base.extend self
  end

  def fmt(*args)
    args.map { |a| "You said #{a}" }
  end
end

class MyClass
  # regular include provides us with instance methods
  # and defined above MyMod#included hook - with class methods
  include MyMod

  def inst
    puts fmt(1, 2, 3)
  end

  def self.cls
    puts fmt(4, 5, 6)
  end
end

puts MyClass.cls
puts MyClass.new.inst

And here’s the output:

You said 4
You said 5
You said 6

You said 1
You said 2
You said 3

For more detailed explanation have a look at this article.