New modular framework is in place. Nothing works until core/auth.rb is done, though

4 files changed, 353 insertions, 119 deletions

diff --git a/lib/rbot/botuser.rb b/lib/rbot/botuser.rb
index 28a54108..67d7d842 100644
--- a/lib/rbot/botuser.rb
+++ b/lib/rbot/botuser.rb
@@ -171,13 +171,13 @@ module Irc
 

   # This method raises a TypeError if _user_ is not of class User

   #

-  def error_if_not_user(user)

+  def Irc.error_if_not_user(user)

     raise TypeError, "#{user.inspect} must be of type Irc::User and not #{user.class}" unless user.class <= User

   end

 

   # This method raises a TypeError if _chan_ is not of class Chan

   #

-  def error_if_not_channel(chan)

+  def Irc.error_if_not_channel(chan)

     raise TypeError, "#{chan.inspect} must be of type Irc::User and not #{chan.class}" unless chan.class <= Channel

   end

 

@@ -219,25 +219,26 @@ module Irc
       # the command as a symbol with the :command method and the whole

       # path as :path

       #

-      #   Command.new("core::auth::save").path => [:"", :core, :"core::auth", :"core::auth::save"]

+      #   Command.new("core::auth::save").path => [:"*", :"core", :"core::auth", :"core::auth::save"]

       #

       #   Command.new("core::auth::save").command => :"core::auth::save"

       #

       def initialize(cmd)

         cmdpath = sanitize_command_path(cmd).split('::')

-        seq = cmdpath.inject([""]) { |list, cmd|

-          list << (list.last ? list.last + "::" : "") + cmd

+        seq = cmdpath.inject(["*"]) { |list, cmd|

+          list << (list.length > 1 ? list.last + "::" : "") + cmd

         }

         @path = seq.map { |k|

           k.to_sym

         }

         @command = path.last

+        debug "Created command #{@command.inspect} with path #{@path.join(', ')}"

       end

     end

 

     # This method raises a TypeError if _user_ is not of class User

     #

-    def error_if_not_command(cmd)

+    def Irc.error_if_not_command(cmd)

       raise TypeError, "#{cmd.inspect} must be of type Irc::Auth::Command and not #{cmd.class}" unless cmd.class <= Command

     end

 

@@ -256,7 +257,7 @@ module Irc
       #

       def set_permission(cmd, val)

         raise TypeError, "#{val.inspect} must be true or false" unless [true,false].include?(val)

-        error_if_not_command(cmd)

+        Irc::error_if_not_command(cmd)

         cmd.path.each { |k|

           set_permission(k.to_s, true) unless @perm.has_key?(k)

         }

@@ -266,8 +267,8 @@ module Irc
       # Tells if command _cmd_ is permitted. We do this by returning

       # the value of the deepest Command#path that matches.

       #

-      def allow?(cmd)

-        error_if_not_command(cmd)

+      def permit?(cmd)

+        Irc::error_if_not_command(cmd)

         allow = nil

         cmd.path.reverse.each { |k|

           if @perm.has_key?(k)

@@ -313,7 +314,7 @@ module Irc
       # Checks if BotUser is allowed to do something on channel _chan_,

       # or on all channels if _chan_ is nil

       #

-      def allow?(cmd, chan=nil)

+      def permit?(cmd, chan=nil)

         if chan

           k = chan.to_s.to_sym

         else

@@ -321,7 +322,7 @@ module Irc
         end

         allow = nil

         if @perm.has_key?(k)

-          allow = @perm[k].allow?(cmd)

+          allow = @perm[k].permit?(cmd)

         end

         return allow

       end

@@ -356,7 +357,7 @@ module Irc
 

       # This method checks if BotUser has a Netmask that matches _user_

       def knows?(user)

-        error_if_not_user(user)

+        Irc::error_if_not_user(user)

         known = false

         @netmasks.each { |n|

           if user.matches?(n)

@@ -424,7 +425,7 @@ module Irc
 

       # Anon knows everybody

       def knows?(user)

-        error_if_not_user(user)

+        Irc::error_if_not_user(user)

         return true

       end

 

@@ -437,7 +438,7 @@ module Irc
 

     # Returns the only instance of AnonBotUserClass

     #

-    def Auth::anonbotuser

+    def Auth.anonbotuser

       return AnonBotUserClass.instance

     end

 

@@ -449,14 +450,14 @@ module Irc
         super("owner")

       end

 

-      def allow?(cmd, chan=nil)

+      def permit?(cmd, chan=nil)

         return true

       end

     end

 

     # Returns the only instance of BotOwnerClass

     #

-    def Auth::botowner

+    def Auth.botowner

       return BotOwnerClass.instance

     end

 

@@ -520,8 +521,8 @@ module Irc
 

       # Maps <code>Irc::User</code> to BotUser

       def irc_to_botuser(ircuser)

-        error_if_not_user(ircuser)

-        return @botusers[ircuser] || anonbotuser

+        Irc::error_if_not_user(ircuser)

+        return @botusers[ircuser] || Auth::anonbotuser

       end

 

       # creates a new BotUser

@@ -541,7 +542,7 @@ module Irc
       # It is possible to autologin by Netmask, on request

       #

       def login(ircuser, botusername, pwd, bymask = false)

-        error_if_not_user(ircuser)

+        Irc::error_if_not_user(ircuser)

         n = BotUser.sanitize_username(name)

         k = n.to_sym

         raise "No such BotUser #{n}" unless include?(k)

@@ -569,11 +570,10 @@ module Irc
       # * anonbotuser on _chan_

       # * anonbotuser on all channels

       #

-      def allow?(user, cmdtxt, chan=nil)

-        error_if_not_user(user)

+      def permit?(user, cmdtxt, chan=nil)

+        botuser = irc_to_botuser(user)

         cmd = Command.new(cmdtxt)

-        allow = nil

-        botuser = @botusers[user]

+

         case chan

         when User

           chan = "?"

@@ -581,20 +581,27 @@ module Irc
           chan = chan.name

         end

 

-        allow = botuser.allow?(cmd, chan) if chan

+        allow = nil

+

+        allow = botuser.permit?(cmd, chan) if chan

         return allow unless allow.nil?

-        allow = botuser.allow?(cmd)

+        allow = botuser.permit?(cmd)

         return allow unless allow.nil?

 

-        unless botuser == anonbotuser

-          allow = anonbotuser.allow?(cmd, chan) if chan

+        unless botuser == Auth::anonbotuser

+          allow = Auth::anonbotuser.permit?(cmd, chan) if chan

           return allow unless allow.nil?

-          allow = anonbotuser.allow?(cmd)

+          allow = Auth::anonbotuser.permit?(cmd)

           return allow unless allow.nil?

         end

 

         raise "Could not check permission for user #{user.inspect} to run #{cmdtxt.inspect} on #{chan.inspect}"

       end

+

+      # Checks if command _cmd_ is allowed to User _user_ on _chan_

+      def allow?(cmdtxt, user, chan=nil)

+        permit?(user, cmdtxt, chan)

+      end

     end

 

     # Returns the only instance of AuthManagerClass

diff --git a/lib/rbot/core/core.rb b/lib/rbot/core/core.rb
new file mode 100644
index 00000000..c9210d59
--- /dev/null
+++ b/lib/rbot/core/core.rb
@@ -0,0 +1,155 @@
+#-- vim:sw=2:et

+#++

+

+

+class Core < CoreBotModule

+

+  # TODO cleanup

+  # handle incoming IRC PRIVMSG +m+

+  def listen(m)

+    return unless m.class <= PrivMessage

+    if(m.private? && m.message =~ /^\001PING\s+(.+)\001/)

+      @bot.notice m.sourcenick, "\001PING #$1\001"

+      @bot.irclog "@ #{m.sourcenick} pinged me"

+      return

+    end

+

+    if(m.address?)

+      case m.message

+      when (/^join\s+(\S+)\s+(\S+)$/i)

+        @bot.join $1, $2 if(@bot.auth.allow?("join", m.source, m.replyto))

+      when (/^join\s+(\S+)$/i)

+        @bot.join $1 if(@bot.auth.allow?("join", m.source, m.replyto))

+      when (/^part$/i)

+        @bot.part m.target if(m.public? && @bot.auth.allow?("join", m.source, m.replyto))

+      when (/^part\s+(\S+)$/i)

+        @bot.part $1 if(@bot.auth.allow?("join", m.source, m.replyto))

+      when (/^quit(?:\s+(.*))?$/i)

+        @bot.quit $1 if(@bot.auth.allow?("quit", m.source, m.replyto))

+      when (/^restart(?:\s+(.*))?$/i)

+        @bot.restart $1 if(@bot.auth.allow?("quit", m.source, m.replyto))

+      when (/^hide$/i)

+        @bot.join 0 if(@bot.auth.allow?("join", m.source, m.replyto))

+      when (/^save$/i)

+        if(@bot.auth.allow?("config", m.source, m.replyto))

+          @bot.save

+          m.okay

+        end

+      when (/^nick\s+(\S+)$/i)

+        @bot.nickchg($1) if(@bot.auth.allow?("nick", m.source, m.replyto))

+      when (/^say\s+(\S+)\s+(.*)$/i)

+        @bot.say $1, $2 if(@bot.auth.allow?("say", m.source, m.replyto))

+      when (/^action\s+(\S+)\s+(.*)$/i)

+        @bot.action $1, $2 if(@bot.auth.allow?("say", m.source, m.replyto))

+        # when (/^topic\s+(\S+)\s+(.*)$/i)

+        #   topic $1, $2 if(@bot.auth.allow?("topic", m.source, m.replyto))

+      when (/^mode\s+(\S+)\s+(\S+)\s+(.*)$/i)

+        @bot.mode $1, $2, $3 if(@bot.auth.allow?("mode", m.source, m.replyto))

+      when (/^ping$/i)

+        @bot.say m.replyto, "pong"

+      when (/^rescan$/i)

+        if(@bot.auth.allow?("config", m.source, m.replyto))

+          m.reply "saving ..."

+          @bot.save

+          m.reply "rescanning ..."

+          @bot.rescan

+          m.reply "done. #{@plugins.status(true)}"

+        end

+      when (/^quiet$/i)

+        if(@bot.auth.allow?("talk", m.source, m.replyto))

+          m.okay

+          @bot.set_quiet

+        end

+      when (/^quiet in (\S+)$/i)

+        where = $1

+        if(@bot.auth.allow?("talk", m.source, m.replyto))

+          m.okay

+          where.gsub!(/^here$/, m.target) if m.public?

+          @bot.set_quiet(where)

+        end

+      when (/^talk$/i)

+        if(@bot.auth.allow?("talk", m.source, m.replyto))

+          @bot.reset_quiet

+          m.okay

+        end

+      when (/^talk in (\S+)$/i)

+        where = $1

+        if(@bot.auth.allow?("talk", m.source, m.replyto))

+          where.gsub!(/^here$/, m.target) if m.public?

+          @bot.reset_quiet(where)

+          m.okay

+        end

+      when (/^status\??$/i)

+        m.reply status if @bot.auth.allow?("status", m.source, m.replyto)

+      when (/^registry stats$/i)

+        if @bot.auth.allow?("config", m.source, m.replyto)

+          m.reply @registry.stat.inspect

+        end

+      when (/^(help\s+)?config(\s+|$)/)

+        @config.privmsg(m)

+      when (/^(version)|(introduce yourself)$/i)

+        @bot.say m.replyto, "I'm a v. #{$version} rubybot, (c) Tom Gilbert - http://linuxbrit.co.uk/rbot/"

+      when (/^help(?:\s+(.*))?$/i)

+        @bot.say m.replyto, help($1)

+        #TODO move these to a "chatback" plugin

+      when (/^(botsnack|ciggie)$/i)

+        @bot.say m.replyto, @lang.get("thanks_X") % m.sourcenick if(m.public?)

+        @bot.say m.replyto, @lang.get("thanks") if(m.private?)

+      when (/^(hello|howdy|hola|salut|bonjour|sup|niihau|hey|hi(\W|$)|yo(\W|$)).*/i)

+        @bot.say m.replyto, @lang.get("hello_X") % m.sourcenick if(m.public?)

+        @bot.say m.replyto, @lang.get("hello") if(m.private?)

+      end

+    else

+      # stuff to handle when not addressed

+      case m.message

+      when (/^\s*(hello|howdy|hola|salut|bonjour|sup|niihau|hey|hi|yo(\W|$))[\s,-.]+#{Regexp.escape(@bot.nick)}$/i)

+        @bot.say m.replyto, @lang.get("hello_X") % m.sourcenick

+      when (/^#{Regexp.escape(@bot.nick)}!*$/)

+        @bot.say m.replyto, @lang.get("hello_X") % m.sourcenick

+      else

+        # @keywords.privmsg(m)

+      end

+    end

+  end

+

+  # handle help requests for "core" topics

+  def help(topic="")

+    case topic

+    when "quit"

+      return "quit [<message>] => quit IRC with message <message>"

+    when "restart"

+      return "restart => completely stop and restart the bot (including reconnect)"

+    when "join"

+      return "join <channel> [<key>] => join channel <channel> with secret key <key> if specified. #{myself} also responds to invites if you have the required access level"

+    when "part"

+      return "part <channel> => part channel <channel>"

+    when "hide"

+      return "hide => part all channels"

+    when "save"

+      return "save => save current dynamic data and configuration"

+    when "rescan"

+      return "rescan => reload modules and static facts"

+    when "nick"

+      return "nick <nick> => attempt to change nick to <nick>"

+    when "say"

+      return "say <channel>|<nick> <message> => say <message> to <channel> or in private message to <nick>"

+    when "action"

+      return "action <channel>|<nick> <message> => does a /me <message> to <channel> or in private message to <nick>"

+    when "quiet"

+      return "quiet [in here|<channel>] => with no arguments, stop speaking in all channels, if \"in here\", stop speaking in this channel, or stop speaking in <channel>"

+    when "talk"

+      return "talk [in here|<channel>] => with no arguments, resume speaking in all channels, if \"in here\", resume speaking in this channel, or resume speaking in <channel>"

+    when "version"

+      return "version => describes software version"

+    when "botsnack"

+      return "botsnack => reward #{myself} for being good"

+    when "hello"

+      return "hello|hi|hey|yo [#{myself}] => greet the bot"

+    else

+      return "Core help topics: quit, restart, config, join, part, hide, save, rescan, nick, say, action, topic, quiet, talk, version, botsnack, hello"

+    end

+  end

+end

+

+core = Core.new

+

diff --git a/lib/rbot/ircbot.rb b/lib/rbot/ircbot.rb
index 42f39b16..d567189b 100644
--- a/lib/rbot/ircbot.rb
+++ b/lib/rbot/ircbot.rb
@@ -350,8 +350,10 @@ class IrcBot
     Dir.mkdir("#{botclass}/plugins") unless File.exist?("#{botclass}/plugins")
     @plugins = Plugins::pluginmanager
     @plugins.bot_associate(self)
-    @plugins.load_core(Config::coredir)
-    @plugins.load_plugins(["#{botclass}/plugins"])
+    @plugins.add_botmodule_dir(Config::coredir)
+    @plugins.add_botmodule_dir("#{botclass}/plugins")
+    @plugins.add_botmodule_dir(Config::datadir + "/plugins")
+    @plugins.scan
 
     @socket = IrcSocket.new(@config['server.name'], @config['server.port'], @config['server.bindhost'], @config['server.sendq_delay'], @config['server.sendq_burst'])
     @client = IrcClient.new
@@ -364,7 +366,6 @@ class IrcBot
     # in all channels, a list of channels otherwise
     @quiet = nil
 
-
     @client[:welcome] = proc {|data|
       irclog "joined server #{@client.server} as #{myself}", "server"
 
@@ -735,8 +736,6 @@ class IrcBot
     case where
     when Channel
       irclog "* #{myself} #{message}", where
-    when User
-      irclog "* #{myself}[#{where}] #{message}", $1
     else
       irclog "* #{myself}[#{where}] #{message}", where
     end
@@ -1003,7 +1002,6 @@ class IrcBot
     end
   end
 
-  # respond to being kicked from a channel
   def irclogkick(m)
     if(m.address?)
       debug "kicked from channel #{m.channel}"
diff --git a/lib/rbot/plugins.rb b/lib/rbot/plugins.rb
index 546a9b30..bb4c744a 100644
--- a/lib/rbot/plugins.rb
+++ b/lib/rbot/plugins.rb
@@ -98,13 +98,21 @@ module Plugins
 
   class BotModule
     attr_reader :bot   # the associated bot
+    attr_reader :botmodule_class # the botmodule class (:coremodule or :plugin)
+
     # initialise your bot module. Always call super if you override this method,
     # as important variables are set up for you
-    def initialize
-      @bot = Plugins.pluginmanager.bot
+    def initialize(kl)
+      @manager = Plugins::pluginmanager
+      @bot = @manager.bot
+
+      @botmodule_class = kl.to_sym
       @botmodule_triggers = Array.new
+
       @handler = MessageMapper.new(self)
       @registry = BotRegistryAccessor.new(@bot, self.class.to_s.gsub(/^.*::/, ""))
+
+      @manager.add_botmodule(kl, self)
     end
 
     def flush_registry
@@ -148,7 +156,12 @@ module Plugins
     # return an identifier for this plugin, defaults to a list of the message
     # prefixes handled (used for error messages etc)
     def name
-      self.class.downcase.sub(/(plugin)?$/,"")
+      self.class.to_s.downcase.sub(/^#<module:.*?>::/,"").sub(/(plugin)?$/,"")
+    end
+
+    # just calls name
+    def to_s
+      name
     end
 
     # return a help string for your module. for complex modules, you may wish
@@ -163,10 +176,10 @@ 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, 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
+    def register(name, opts={})
+      raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
+      return if @manager.knows?(name, @botmodule_class)
+      @manager.register(name, @botmodule_class, self)
       @botmodule_triggers << name unless opts.fetch(:hidden, false)
     end
 
@@ -179,20 +192,18 @@ 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)
+    def initialize
+      super(:coremodule)
     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)
+    def initialize
+      super(:plugin)
     end
   end
 
-  # class to manage multiple plugins and delegate messages to them for
+  # Singleton to manage multiple plugins and delegate messages to them for
   # handling
   class PluginManagerClass
     include Singleton
@@ -201,29 +212,67 @@ module Plugins
 
     def initialize
       bot_associate(nil)
+
+      @dirs = []
     end
 
-    # Associate with bot _bot_
-    def bot_associate(bot)
+    # Reset lists of botmodules
+    def reset_botmodule_lists
       @botmodules = {
-        :core => Hash.new,
-        :plugin => Hash.new
+        :coremodule => [],
+        :plugin => []
       }
 
-      # associated IrcBot class
+      @commandmappers = {
+        :coremodule => {},
+        :plugin => {}
+      }
+
+    end
+
+    # Associate with bot _bot_
+    def bot_associate(bot)
+      reset_botmodule_lists
       @bot = bot
     end
 
-    # Returns a hash of the registered message prefixes and associated
-    # plugins
+    # Returns +true+ if _name_ is a known botmodule of class kl
+    def knows?(name, kl)
+      return @commandmappers[kl.to_sym].has_key?(name.to_sym)
+    end
+
+    # Returns +true+ if _name_ is a known botmodule of class kl
+    def register(name, kl, botmodule)
+      raise TypeError, "Third argument #{botmodule.inspect} is not of class BotModule" unless botmodule.class <= BotModule
+      @commandmappers[kl.to_sym][name.to_sym] = botmodule
+    end
+
+    def add_botmodule(kl, botmodule)
+      raise TypeError, "Second argument #{botmodule.inspect} is not of class BotModule" unless botmodule.class <= BotModule
+      raise "#{kl.to_s} #{botmodule.name} already registered!" if @botmodules[kl.to_sym].include?(botmodule)
+      @botmodules[kl.to_sym] << botmodule
+    end
+
+    # Returns an array of the loaded plugins
+    def core_modules
+      @botmodules[:coremodule]
+    end
+
+    # Returns an array of the loaded plugins
     def plugins
       @botmodules[:plugin]
     end
 
     # Returns a hash of the registered message prefixes and associated
+    # plugins
+    def plugin_commands
+      @commandmappers[:plugin]
+    end
+
+    # Returns a hash of the registered message prefixes and associated
     # core modules
-    def core_modules
-      @botmodules[:core]
+    def core_commands
+      @commandmappers[:coremodule]
     end
 
     # Makes a string of error _err_ by adding text _str_
@@ -246,6 +295,7 @@ module Plugins
       plugin_module = Module.new
 
       desc = desc.to_s + " " if desc
+
       begin
         plugin_string = IO.readlines(fname).join("")
         debug "loading #{desc}#{fname}"
@@ -272,31 +322,12 @@ module Plugins
     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
-
-    # dirlist:: array of directories to scan (in order) for plugins
+    # add one or more directories to the list of directories to
+    # load botmodules from
     #
-    # create a new plugin handler, scanning for plugins in +dirlist+
-    def load_plugins(dirlist)
-      @dirs = dirlist
-      scan
+    def add_botmodule_dir(*dirlist)
+      @dirs += dirlist
+      debug "Botmodule loading path: #{@dirs.join(', ')}"
     end
 
     # load plugins from pre-assigned list of directories
@@ -310,11 +341,8 @@ module Plugins
         processed[pn.intern] = :blacklisted
       }
 
-      dirs = Array.new
-      # TODO FIXME should this be hardcoded?
-      dirs << Config::datadir + "/plugins"
-      dirs += @dirs
-      dirs.reverse.each {|dir|
+      dirs = @dirs
+      dirs.each {|dir|
         if(FileTest.directory?(dir))
           d = Dir.new(dir)
           d.sort.each {|file|
@@ -349,6 +377,7 @@ module Plugins
           }
         end
       }
+      debug "finished loading plugins: #{status(true)}"
     end
 
     # call the save method for each active plugin
@@ -360,6 +389,7 @@ module Plugins
     # call the cleanup method for each active plugin
     def cleanup
       delegate 'cleanup'
+      reset_botmodule_lists
     end
 
     # drop all plugins and rescan plugins on disk
@@ -367,21 +397,31 @@ module Plugins
     def rescan
       save
       cleanup
-      plugins.clear
       scan
     end
 
     def status(short=false)
+      list = ""
+      if self.core_length > 0
+        list << "#{self.core_length} core module#{'s' if core_length > 1}"
+        if short
+          list << " loaded"
+        else
+          list << ": " + core_modules.collect{ |p| p.name}.sort.join(", ")
+        end
+      else
+        list << "no core botmodules loaded"
+      end
       # Active plugins first
       if(self.length > 0)
-        list = "#{self.length} plugin#{'s' if length > 1}"
+        list << "; #{self.length} plugin#{'s' if length > 1}"
         if short
           list << " loaded"
         else
-          list << ": " + @@plugins.values.uniq.collect{|p| p.name}.sort.join(", ")
+          list << ": " + plugins.collect{ |p| p.name}.sort.join(", ")
         end
       else
-        list = "no plugins active"
+        list << "no plugins active"
       end
       # Ignored plugins next
       unless @ignored.empty?
@@ -402,7 +442,11 @@ module Plugins
     end
 
     def length
-      plugins.values.uniq.length
+      plugins.length
+    end
+
+    def core_length
+      core_modules.length
     end
 
     # return help for +topic+ (call associated plugin's help method)
@@ -431,57 +475,87 @@ module Plugins
       when /^(\S+)\s*(.*)$/
         key = $1
         params = $2
-        if(@@plugins.has_key?(key))
-          begin
-            return @@plugins[key].help(key, params)
-          rescue Exception => err
-            #rescue TimeoutError, StandardError, NameError, SyntaxError => err
-            error report_error("plugin #{@@plugins[key].name} help() failed:", err)
+        [core_commands, plugin_commands].each { |pl|
+          if(pl.has_key?(key))
+            begin
+              return pl[key].help(key, params)
+            rescue Exception => err
+              #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+              error report_error("#{p.botmodule_class} #{plugins[key].name} help() failed:", err)
+            end
+          else
+            return false
           end
-        else
-          return false
-        end
+        }
       end
     end
 
     # see if each plugin handles +method+, and if so, call it, passing
     # +message+ as a parameter
     def delegate(method, *args)
+      debug "Delegating #{method.inspect}"
       [core_modules, plugins].each { |pl|
-        pl.values.uniq.each {|p|
+        pl.each {|p|
           if(p.respond_to? method)
             begin
+              debug "#{p.botmodule_class} #{p.name} responds"
               p.send method, *args
             rescue Exception => err
-              #rescue TimeoutError, StandardError, NameError, SyntaxError => err
-              error report_error("plugin #{p.name} #{method}() failed:", err)
+              error report_error("#{p.botmodule_class} #{p.name} #{method}() failed:", err)
+              raise if err.class <= BDB::Fatal
             end
           end
         }
       }
+      debug "Finished delegating #{method.inspect}"
     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)
-      [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")}"
+      debug "Delegating privmsg with key #{m.plugin}"
+      return unless m.plugin
+      begin
+        [core_commands, plugin_commands].each { |pl|
+          # We do it this way to skip creating spurious keys
+          # FIXME use fetch?
+          k = m.plugin.to_sym
+          if pl.has_key?(k)
+            p = pl[k]
+          else
+            p = nil
           end
-          return true
-        end
+          if p
+            # TODO This should probably be checked elsewhere
+            debug "Checking auth ..."
+            if @bot.auth.allow?(m.plugin, m.source, m.replyto)
+              debug "Checking response ..."
+              if p.respond_to?("privmsg")
+                begin
+                  debug "#{p.botmodule_class} #{p.name} responds"
+                  p.privmsg(m)
+                rescue Exception => err
+                  error report_error("#{p.botmodule_class} #{p.name} privmsg() failed:", err)
+                  raise if err.class <= BDB::Fatal
+                end
+                debug "Successfully delegated privmsg with key #{m.plugin}"
+                return true
+              else
+                debug "#{p.botmodule_class} #{p.name} is registered, but it doesn't respond to privmsgs"
+              end
+            else
+              debug "#{p.botmodule_class} #{p.name} is registered, but #{m.source} isn't allowed to use #{m.plugin} on #{m.replyto}"
+            end
+          else
+            debug "No #{pl.values.first.botmodule_class} registered #{m.plugin}" unless pl.empty?
+          end
+          debug "Finished delegating privmsg with key #{m.plugin}" + ( pl.empty? ? "" : " to #{pl.values.first.botmodule_class}s" )
+        }
         return false
-      }
+      rescue Exception => e
+        error report_error("couldn't delegate #{m}", e)
+      end
+      debug "Finished delegating privmsg with key #{m.plugin}"
     end
   end