First step towards the new modularized core framework

1 files changed, 169 insertions, 95 deletions

diff --git a/lib/rbot/plugins.rb b/lib/rbot/plugins.rb
index 50b5576b..546a9b30 100644
--- a/lib/rbot/plugins.rb
+++ b/lib/rbot/plugins.rb
@@ -1,3 +1,5 @@
+require 'singleton'
+
 module Irc
     BotConfig.register BotConfigArrayValue.new('plugins.blacklist',
       :default => [], :wizard => false, :requires_restart => true,
@@ -94,13 +96,13 @@ module Plugins
                          files/connections or flush caches here
 =end
 
-  class Plugin
+  class BotModule
     attr_reader :bot   # the associated bot
-    # initialise your plugin. Always call super if you override this method,
+    # initialise your bot module. Always call super if you override this method,
     # as important variables are set up for you
     def initialize
-      @bot = Plugins.bot
-      @names = Array.new
+      @bot = Plugins.pluginmanager.bot
+      @botmodule_triggers = Array.new
       @handler = MessageMapper.new(self)
       @registry = BotRegistryAccessor.new(@bot, self.class.to_s.gsub(/^.*::/, ""))
     end
@@ -146,7 +148,7 @@ module Plugins
     # return an identifier for this plugin, defaults to a list of the message
     # prefixes handled (used for error messages etc)
     def name
-      @names.join("|")
+      self.class.downcase.sub(/(plugin)?$/,"")
     end
 
     # return a help string for your module. for complex modules, you may wish
@@ -161,11 +163,11 @@ module Plugins
     # register the plugin as a handler for messages prefixed +name+
     # this can be called multiple times for a plugin to handle multiple
     # message prefixes
-    def register(name,opts={})
-      raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
-      return if Plugins.plugins.has_key?(name)
-      Plugins.plugins[name] = self
-      @names << name unless opts.fetch(:hidden, false)
+    def register(name, kl, opts={})
+      raise ArgumentError, "Third argument must be a hash!" unless opts.kind_of?(Hash)
+      return if Plugins.pluginmanager.botmodules[kl].has_key?(name)
+      Plugins.pluginmanager.botmodules[kl][name] = self
+      @botmodule_triggers << name unless opts.fetch(:hidden, false)
     end
 
     # default usage method provided as a utility for simple plugins. The
@@ -176,46 +178,140 @@ module Plugins
 
   end
 
+  class CoreBotModule < BotModule
+    def register(name, opts={})
+      raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
+      super(name, :core, opts)
+    end
+  end
+
+  class Plugin < BotModule
+    def register(name, opts={})
+      raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
+      super(name, :plugin, opts)
+    end
+  end
+
   # class to manage multiple plugins and delegate messages to them for
   # handling
-  class Plugins
-    # hash of registered message prefixes and associated plugins
-    @@plugins = Hash.new
-    # associated IrcBot class
-    @@bot = nil
+  class PluginManagerClass
+    include Singleton
+    attr_reader :bot
+    attr_reader :botmodules
+
+    def initialize
+      bot_associate(nil)
+    end
+
+    # Associate with bot _bot_
+    def bot_associate(bot)
+      @botmodules = {
+        :core => Hash.new,
+        :plugin => Hash.new
+      }
+
+      # associated IrcBot class
+      @bot = bot
+    end
+
+    # Returns a hash of the registered message prefixes and associated
+    # plugins
+    def plugins
+      @botmodules[:plugin]
+    end
+
+    # Returns a hash of the registered message prefixes and associated
+    # core modules
+    def core_modules
+      @botmodules[:core]
+    end
+
+    # Makes a string of error _err_ by adding text _str_
+    def report_error(str, err)
+      ([str, err.inspect] + err.backtrace).join("\n")
+    end
+
+    # This method is the one that actually loads a module from the
+    # file _fname_
+    #
+    # _desc_ is a simple description of what we are loading (plugin/botmodule/whatever)
+    #
+    # It returns the Symbol :loaded on success, and an Exception
+    # on failure
+    #
+    def load_botmodule_file(fname, desc=nil)
+      # create a new, anonymous module to "house" the plugin
+      # the idea here is to prevent namespace pollution. perhaps there
+      # is another way?
+      plugin_module = Module.new
+
+      desc = desc.to_s + " " if desc
+      begin
+        plugin_string = IO.readlines(fname).join("")
+        debug "loading #{desc}#{fname}"
+        plugin_module.module_eval(plugin_string, fname)
+        return :loaded
+      rescue Exception => err
+        # rescue TimeoutError, StandardError, NameError, LoadError, SyntaxError => err
+        warning report_error("#{desc}#{fname} load failed", err)
+        bt = err.backtrace.select { |line|
+          line.match(/^(\(eval\)|#{fname}):\d+/)
+        }
+        bt.map! { |el|
+          el.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
+            "#{fname}#{$1}#{$3}"
+          }
+        }
+        msg = err.to_str.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
+          "#{fname}#{$1}#{$3}"
+        }
+        newerr = err.class.new(msg)
+        newerr.set_backtrace(bt)
+        return newerr
+      end
+    end
+    private :load_botmodule_file
+
+    # Load core botmodules
+    def load_core(dir)
+      # TODO FIXME should this be hardcoded?
+      if(FileTest.directory?(dir))
+        d = Dir.new(dir)
+        d.sort.each { |file|
+          next unless(file =~ /[^.]\.rb$/)
+
+          did_it = load_botmodule_file("#{dir}/#{file}", "core module")
+          case did_it
+          when Symbol
+            # debug "loaded core botmodule #{dir}/#{file}"
+          when Exception
+            raise "failed to load core botmodule #{dir}/#{file}!"
+          end
+        }
+      end
+    end
 
-    # bot::     associated IrcBot class
     # dirlist:: array of directories to scan (in order) for plugins
     #
     # create a new plugin handler, scanning for plugins in +dirlist+
-    def initialize(bot, dirlist)
-      @@bot = bot
+    def load_plugins(dirlist)
       @dirs = dirlist
       scan
     end
 
-    # access to associated bot
-    def Plugins.bot
-      @@bot
-    end
-
-    # access to list of plugins
-    def Plugins.plugins
-      @@plugins
-    end
-
     # load plugins from pre-assigned list of directories
     def scan
       @failed = Array.new
       @ignored = Array.new
       processed = Hash.new
 
-      @@bot.config['plugins.blacklist'].each { |p|
+      @bot.config['plugins.blacklist'].each { |p|
         pn = p + ".rb"
         processed[pn.intern] = :blacklisted
       }
 
       dirs = Array.new
+      # TODO FIXME should this be hardcoded?
       dirs << Config::datadir + "/plugins"
       dirs += @dirs
       dirs.reverse.each {|dir|
@@ -242,40 +338,14 @@ module Plugins
 
             next unless(file =~ /\.rb$/)
 
-            tmpfilename = "#{dir}/#{file}"
-
-            # create a new, anonymous module to "house" the plugin
-            # the idea here is to prevent namespace pollution. perhaps there
-            # is another way?
-            plugin_module = Module.new
-
-            begin
-              plugin_string = IO.readlines(tmpfilename).join("")
-              debug "loading plugin #{tmpfilename}"
-              plugin_module.module_eval(plugin_string, tmpfilename)
-              processed[file.intern] = :loaded
-            rescue Exception => err
-              # rescue TimeoutError, StandardError, NameError, LoadError, SyntaxError => err
-              warning "plugin #{tmpfilename} load failed\n" + err.inspect
-              debug err.backtrace.join("\n")
-              bt = err.backtrace.select { |line|
-                line.match(/^(\(eval\)|#{tmpfilename}):\d+/)
-              }
-              bt.map! { |el|
-                el.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
-                  "#{tmpfilename}#{$1}#{$3}"
-                }
-              }
-              msg = err.to_str.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
-                "#{tmpfilename}#{$1}#{$3}"
-              }
-              newerr = err.class.new(msg)
-              newerr.set_backtrace(bt)
-              # debug "Simplified error: " << newerr.inspect
-              # debug newerr.backtrace.join("\n")
-              @failed << { :name => file, :dir => dir, :reason => newerr }
-              # debug "Failures: #{@failed.inspect}"
+            did_it = load_botmodule_file("#{dir}/#{file}", "plugin")
+            case did_it
+            when Symbol
+              processed[file.intern] = did_it
+            when Exception
+              @failed <<  { :name => file, :dir => dir, :reason => did_it }
             end
+
           }
         end
       }
@@ -297,15 +367,14 @@ module Plugins
     def rescan
       save
       cleanup
-      @@plugins = Hash.new
+      plugins.clear
       scan
-
     end
 
     def status(short=false)
       # Active plugins first
-      if(@@plugins.length > 0)
-        list = "#{length} plugin#{'s' if length > 1}"
+      if(self.length > 0)
+        list = "#{self.length} plugin#{'s' if length > 1}"
         if short
           list << " loaded"
         else
@@ -333,7 +402,7 @@ module Plugins
     end
 
     def length
-      @@plugins.values.uniq.length
+      plugins.values.uniq.length
     end
 
     # return help for +topic+ (call associated plugin's help method)
@@ -367,8 +436,7 @@ module Plugins
             return @@plugins[key].help(key, params)
           rescue Exception => err
             #rescue TimeoutError, StandardError, NameError, SyntaxError => err
-            error "plugin #{@@plugins[key].name} help() failed: #{err.class}: #{err}"
-            error err.backtrace.join("\n")
+            error report_error("plugin #{@@plugins[key].name} help() failed:", err)
           end
         else
           return false
@@ -379,42 +447,48 @@ module Plugins
     # see if each plugin handles +method+, and if so, call it, passing
     # +message+ as a parameter
     def delegate(method, *args)
-      @@plugins.values.uniq.each {|p|
-        if(p.respond_to? method)
-          begin
-            p.send method, *args
-          rescue Exception => err
-            #rescue TimeoutError, StandardError, NameError, SyntaxError => err
-            error "plugin #{p.name} #{method}() failed: #{err.class}: #{err}"
-            error err.backtrace.join("\n")
+      [core_modules, plugins].each { |pl|
+        pl.values.uniq.each {|p|
+          if(p.respond_to? method)
+            begin
+              p.send method, *args
+            rescue Exception => err
+              #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+              error report_error("plugin #{p.name} #{method}() failed:", err)
+            end
           end
-        end
+        }
       }
     end
 
     # see if we have a plugin that wants to handle this message, if so, pass
     # it to the plugin and return true, otherwise false
     def privmsg(m)
-      return unless(m.plugin)
-      if (@@plugins.has_key?(m.plugin) &&
-          @@plugins[m.plugin].respond_to?("privmsg") &&
-          @@bot.auth.allow?(m.plugin, m.source, m.replyto))
-        begin
-          @@plugins[m.plugin].privmsg(m)
-        rescue BDB::Fatal => err
-          error "plugin #{@@plugins[m.plugin].name} privmsg() failed: #{err.class}: #{err}"
-          error err.backtrace.join("\n")
-          raise
-        rescue Exception => err
-          #rescue TimeoutError, StandardError, NameError, SyntaxError => err
-          error "plugin #{@@plugins[m.plugin].name} privmsg() failed: #{err.class}: #{err}"
-          error err.backtrace.join("\n")
+      [core_modules, plugins].each { |pl|
+        return unless(m.plugin)
+        if (pl.has_key?(m.plugin) &&
+          pl[m.plugin].respond_to?("privmsg") &&
+          @bot.auth.allow?(m.plugin, m.source, m.replyto))
+          begin
+            pl[m.plugin].privmsg(m)
+          rescue BDB::Fatal => err
+            error error_report("plugin #{pl[m.plugin].name} privmsg() failed:", err)
+            raise
+          rescue Exception => err
+            #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+            error "plugin #{pl[m.plugin].name} privmsg() failed: #{err.class}: #{err}\n#{error err.backtrace.join("\n")}"
+          end
+          return true
         end
-        return true
-      end
-      return false
+        return false
+      }
     end
   end
 
+  # Returns the only PluginManagerClass instance
+  def Plugins.pluginmanager
+    return PluginManagerClass.instance
+  end
+
 end
 end