How can I dynamically add/extend methods from a Class?

Question

I'm using a Ruby Component inside an Audio Application Environment. This Ruby Component is represented by an instance of a RubyEdit class. This provide the interface between my Ruby code and the Environment.

For example if I write self it outputs the instance of the RubyEdit class that represents that component:

the nice things is that I can/must "implement/extend" some methods that RubyEdit will call when it get some events. I can define my custom method event for that instance:

def event
    # my own event code
end

and it will be called when the Environment get some events outside this Ruby Component. Or I can call a class method called redraw, and it will call my custom method draw:

  def draw
     # my own draw code (this will called after invoking redraw from Ruby Component)
  end

I need to understand some hierarchy of this process, so I'm making a simulation of that RubyEdit class in Ruby.

How it will looks? I mean: how can I provide methods that will be defined "later"?

This is how RubyEdit will look I think:

class RubyEdit
  def self.redraw
    # calling this class method should invoke my extended draw method
  end

  def draw
  end

  def event
  end
end

but I don't understand how to place event and draw methods extendible. Interfaces?

Answer 1

module ExtendRubyEdit

   def self.included(base)
     base.extend(ClassMethods)
   end

   def draw
   end

   def event
   end

   module ClassMethods
    def redraw
    end
   end
end

class RubyEdit
  include ExtendRubyEdit
end