Question

Let say we have classes A,B,C.

A
 def self.inherited(sub)
   # meta programming goes here
   # take class that has just inherited class A
   # and for foo classes inject prepare_foo() as 
   # first line of method then run rest of the code
 end

 def prepare_foo
   # => prepare_foo() needed here
   # some code
 end

end

B < A
  def foo
    # some code
  end
end

C < A
  def foo
    # => prepare_foo() needed here
    # some code
  end
end

As you can see I am trying to inject foo_prepare() call to each one of foo() methods.

How can that be done?

Also I have been thinking about overriding send class in class A that way I would run foo_prepare and than just let send (super) to do rest of the method.

What do you guys think, what is the best way to approach this problem?

Answer 1

Here’s a solution for you. Although it’s based on module inclusion and not inheriting from a class, I hope you will still find it useful.

module Parent
  def self.included(child)
    child.class_eval do
      def prepare_for_work
        puts "preparing to do some work"
      end
  
      # back up method's name
      alias_method :old_work, :work
  
      # replace the old method with a new version, which has 'prepare' injected
      def work
        prepare_for_work
        old_work
      end
    end
  end
end

class FirstChild
  def work
    puts "doing some work"
  end

  include Parent # include in the end of class, so that work method is already defined.
end

fc = FirstChild.new
fc.work
# >> preparing to do some work
# >> doing some work