Not sure if it's any help, but here's something I've been using in my 
code which is sort of the reverse of Observable.

This is actually just a snippet of the whole thing without comments or 
some fancy features I added.  I may put it up as a gem if there's interest.

module HandlesEvents
   attr_reader :handlers

   def on_event(*triggers, &handler)
     @handlers ||= Hash.new
     triggers.each { |trigger| @handlers[trigger] = handler }
   end

   def handles?(trigger)
     @handlers ||= Hash.new
     return true unless @handlers[trigger].nil?
     false
   end

   def handle(trigger)
     @handlers ||= Hash.new
     @handlers[trigger].call(trigger) unless @handlers[trigger].nil?
   end
end

-Payton

Damphyr wrote:
> OK, bare with me, this is brainstorming of a sorts:
> I want to have some kind of event notification from my classes.
> Typically what I would do would be to pass a logger object and let the
> class log by itself, but I'm not really satisfied with this solution in
> most cases.
> 
> What I would prefer was define a callback method and give this to the
> object. Then I could do whatever I want with it and not only use logs.
> Mostly I want to have progress reports.
> 
> something like
> 
> class A
>   def set_callback notify
>     @notify=notify
>   end
>   def something
>     puts "something"
>     send(@notify) if @notify
>   end
> end
> 
> def coocoo
>     puts "hey"
> end
> a=A.new
> a.something
> a.set_callback(:coocoo)
> a.something
> 
> Now this does exactly what I want and can be wrapped up in a module to
> be included for general use.
> Question: Is there a "better" solution? What are my alternatives?
> Cheers,
> V.-
> 
>