From: Joel VanderWerf <vjoel@...>
Date: 2006-02-28T04:04:12+09:00
Subject: Re: Plugin type discovery/registration - How do I discover what classes were loaded when I dynamically require in ruby files from a directory?

Jeff Barczewski wrote:
> In my current project I am in need of a standard plugin mechanism where I
> discover what plugins are available by what exists in a directory. I was
> able to easily simply 'require' these ruby files in. However I want to take
> it a step further and know (discover) what classes were in these files
> including the module name so that I can interrogate them further and
> potentially create them and call an initialize type method which might be
> used to register yourself and or do other startup processing.
> 
> Is there an easy way to know what classes were loaded during the require or
> is there a better way to do this sort of thing? I think the Rails plugin
> mechanism works similarly to what I am looking for in that it loads plugins
> from a directory and invokes an initialize method on each so they can do
> their own registration/configuration work.
> 
> PS. It would also be nice if the plugins can use whatever module space they
> want so there won't be class conflicts, so I would prefer suggestions and
> ideas that might allow this functionality, so not only do I get the class
> name but the actual module::class name so that I could create the proper
> object using this information.
> 
> Thanks for any suggestions or help!

Kernel#module_eval is a good tool for wrapping up plug-ins inside a new
namespace. I wrote the "script" library on raa to simplify doing that.
For example:

$ cat plugins/plug1.rb
class Plug1
end

K = 42

$ cat plugins/plug2.rb
class Plug2
end

K = 43

$ cat plugin.rb
require 'script'

plugins = Dir.glob("plugins/*.rb").map do |file|
  Script.load file
end

p plugins

plugins.each do |plugin|
  puts "plugin #{plugin} defines these constants:"
  plugin.constants.each do |const_name|
    val = plugin.const_get(const_name)
    puts "  %20s = %s" % [const_name, val.inspect]
  end
  puts
end

$ ruby plugin.rb
[#<Script:/path/to/plug1.rb>, #<Script:/path/to/plug2.rb>]
plugin #<Script:/path/to/plug1.rb> defines these constants:
                 Plug1 = #<Script:0xb7d61414>::Plug1
                     K = 42

plugin #<Script:/path/to/plug2.rb> defines these constants:
                 Plug2 = #<Script:0xb7d613c4>::Plug2
                     K = 43


(I substituted /path/to/ for the full path to save space.)

Of course, you can filter out only the classes, and skip other constants.

-- 
      vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407