What's the preferred way to use helper methods in Ruby?

Disclaimer: Although I'm asking in context of a Rails application, I'm not talking about Rails helpers (i.e. view helpers)

Let's say I have a helper method/function:

def dispatch_job(job = {})
  #Do something
end

Now I want to use this from several different places (mostly controllers, but also a few BackgrounDRb workers)

What's the preferred way to do this?

I can think of two possibilities:

1. Use a class and make the helper a static method:

class MyHelper
  def self.dispatch_job(job = {})
  end
end

class MyWorker
  def run
    MyHelper.dispatch_job(...)
  end
end

2. Use a module and include the method into whatever class I need this functionality

module MyHelper
  def self.dispatch_job(job = {})
  end
end

class MyWorker
  include MyHelper

  def run
    dispatch_job(...)
  end
end

3. Other possibilities I don't know yet

...

The first one is more Java-like, but I'm not sure if the second one is really an appropriate use of Ruby's modules.

The module approach is the direction I would take. I prefer it because of its flexibility and how nicely it allows you to organize your code. I suppose you could argue that they are just another form of mixin. I always think of mixins as direct extensions of a particular class

class Foo
  def hello
    'Hello'
  end
end

class Foo
  def allo
    'Allo?'
  end
end

f = Foo.new
f.hello => 'Hello'
f.allo => 'Allo?'

That always seems very specific, whereas the module approach can extend any class you include it in.

Peer

If you are going to use that in your controllers and some other code, you can create a mixin and add it to your application controller, from which other controllers derive from, that way you can have it in your controllers, then you can add the module to your other outside classes.