root/lang/ruby/citrus/trunk/lib/citrus/plugins.rb @ 6844

#!/usr/bin/env ruby

require "pathname"

module Citrus
        class Plugins
                class PluginsError < StandardError; end
                class UnknownPlugin < PluginsError; end

                def initialize(path)
                        @path      = Pathname.new(path)
                        @instances = {}
                        update
                end

                def plugin_names
                        @plugins.keys
                end

                def loaded_plugin_names
                        @instances.keys
                end

                def loaded_plugins
                        @instances
                end

                def [](key)
                        @instances[key]
                end

                def each(&block)
                        @instances.each(&block)
                end

                def load(class_name, *args)
                        raise UnknownPlugin, "UnknownPlugin: #{class_name}" unless @plugins.key?(class_name)

                        info = @plugins[class_name]
                        @instances[class_name] = info[:class].new(*args)
                        @instances[class_name].on_load if @instances[class_name].respond_to? :on_load

                        @instances[class_name]
                end

                def unload(class_name)
                        raise UnknownPlugin, "UnknownPlugin: #{class_name}" unless @plugins.key?(class_name)
                        @instances[class_name].on_unload if @instances[class_name].respond_to? :on_unload

                        @instances.delete class_name
                end

                def reload(class_name, *args)
                        if class_name == :all
                                ret = {}
                                plugins = search(@path)
                                plugins.each do |k, v|
                                        if @instances.key?(k)
                                                # Re-instanciate
                                                if @plugins[k][:time] < v[:time]
                                                        @plugins[k] = v
                                                        self.unload(k)
                                                        ret[k] = self.load(k, *args)
                                                end
                                end
                                end
                                ret
                        else
                                plugins = search(@path)
                                raise UnknownPlugin, "UnknownPlugin: #{class_name}" unless plugins.key?(class_name)
                                file = plugins[class_name][:file]
                                @plugins.update load_file(file)
                                self.unload(class_name)
                                self.load(class_name, *args)
                        end
                end

                def update
                        @plugins   = search(@path)
                end

                protected
                def search(path)
                        class_table = {}

                        Pathname.glob("#{path}/*.rb") do |f|
                                class_table.update(load_file(f))
                        end

                        class_table
                end

                def load_file(f)
                        ret = {}
                        m = Module.new
                        m.module_eval(f.read)
                        m.constants.each do |name|
                                const = m.const_get(name)
                                if const.is_a? Class
                                        ret[name] = {
                                                :class => const,
                                                :file  => f,
                                                :time  => f.mtime,
                                        }
                                end
                        end
                        ret
                end
        end
end