Question

Given a module with a singleton method like this:

module Foo
  class << self
    def bar
      puts "method bar from Foo"
    end
  end
end

How can I override Foo.bar using another module?

Answer 1

Extend and alias

My problem was that I forgot to think through the inheritance chain. I was
looking for a way to override the method by modifying the inheritance chain, but
that’s not possible.

The reason is that bar is defined on Foo itself, so it never looks up its inheritance chain for the method. Therefore, to change bar, I have to change it on Foo itself.

While I could just re-open Foo, like this:

module Foo
  def self.bar
    puts "new foo method"
  end
end

… I prefer a way to be able to wrap the original bar method, as though I
were subclassing and could call super. I can achieve that by setting up an
alias for the old method.

module Foo
  class << self
    def bar
      "method bar from Foo"
    end
  end
end

puts Foo.bar # => "method bar from Foo"

module FooEnhancement

  # Add a hook - whenever a class or module calls `extend FooEnhancement`,
  # run this code
  def self.extended(base)

    # In the context of the extending module or class 
    # (in this case, it will be Foo), do the following
    base.class_eval do

      # Define this new method
      def self.new_bar
        "#{old_bar} - now with more fiber!"
      end

      # Set up aliases. 
      # We're already in the context of the class, but there's no
      # `self.alias`, so we need to call `alias` inside this block
      class << self

        # We can call the original `bar` method with `old_bar`
        alias :old_bar :bar

        # If we call `bar`, now we'll get our `new_bar` method
        alias :bar :new_bar
      end
    end

  end

end

# This will fire off the self.extended hook in FooEnhancement
Foo.extend FooEnhancement

# Calls the enhanced version of `bar`
puts Foo.bar # => 'method bar from Foo - now with more fiber!'