rbot 0.9.9 → 0.9.10

data/lib/rbot/message.rb

@@ -1,28 +1,37 @@
 module Irc
+  BotConfig.register BotConfigArrayValue.new('core.address_prefix',
+    :default => [], :wizard => true,
+    :desc => "what non nick-matching prefixes should the bot respond to as if addressed (e.g !, so that '!foo' is treated like 'rbot: foo')"
+  )
+
+  Color = "\003"
+  Bold = "\002"
+  Underline = "\037"
+  Reverse = "\026"
 
   # base user message class, all user messages derive from this
   # (a user message is defined as having a source hostmask, a target
   # nick/channel and a message part)
   class BasicUserMessage
-    
+
     # associated bot
     attr_reader :bot
-    
+
     # when the message was received
     attr_reader :time
 
     # hostmask of message source
     attr_reader :source
-    
+
     # nick of message source
     attr_reader :sourcenick
-    
+
     # url part of message source
     attr_reader :sourceaddress
-    
+
     # nick/channel message was sent to
     attr_reader :target
-    
+
     # contents of the message
     attr_accessor :message
 
@@ -35,6 +44,8 @@ module Irc
     # target::   nick/channel message is destined for
     # message::  message part
     def initialize(bot, source, target, message)
+      @msg_wants_id = false unless defined? @msg_wants_id
+
       @time = Time.now
       @bot = bot
       @source = source
@@ -43,18 +54,32 @@ module Irc
       @message = BasicUserMessage.stripcolour message
       @replied = false
 
+      @identified = false
+      if @msg_wants_id && @bot.capabilities["identify-msg".to_sym]
+        if @message =~ /([-+])(.*)/
+          @identified = ($1=="+")
+          @message = $2
+        else
+          warning "Message does not have identification"
+        end
+      end
+
       # split source into consituent parts
       if source =~ /^((\S+)!(\S+))$/
         @sourcenick = $2
         @sourceaddress = $3
       end
-      
+
       if target && target.downcase == @bot.nick.downcase
         @address = true
       end
-      
+
+    end
+
+    def identified?
+      return @identified
     end
-    
+
     # returns true if the message was addressed to the bot.
     # This includes any private message to the bot, or any public message
     # which looks like it's addressed to the bot, e.g. "bot: foo", "bot, foo",
@@ -83,10 +108,10 @@ module Irc
   # The +message+ member will have any bot addressing "^bot: " removed
   # (address? will return true in this case)
   class UserMessage < BasicUserMessage
-    
+
     # for plugin messages, the name of the plugin invoked by the message
     attr_reader :plugin
-    
+
     # for plugin messages, the rest of the message, with the plugin name
     # removed
     attr_reader :params
@@ -98,11 +123,11 @@ module Irc
 
     # channel the message was in, nil for privately addressed messages
     attr_reader :channel
-    
+
     # for PRIVMSGs, true if the message was a CTCP ACTION (CTCP stuff
     # will be stripped from the message)
     attr_reader :action
-    
+
     # instantiate a new UserMessage
     # bot::      associated bot class
     # source::   hostmask of the message source
@@ -114,7 +139,7 @@ module Irc
       @private = false
       @plugin = nil
       @action = false
-      
+
       if target.downcase == @bot.nick.downcase
         @private = true
         @address = true
@@ -127,25 +152,25 @@ module Irc
 
       # check for option extra addressing prefixes, e.g "|search foo", or
       # "!version" - first match wins
-      bot.addressing_prefixes.each {|mprefix|
+      bot.config['core.address_prefix'].each {|mprefix|
         if @message.gsub!(/^#{Regexp.escape(mprefix)}\s*/, "")
           @address = true
           break
         end
       }
-      
+
       # even if they used above prefixes, we allow for silly people who
-      # combine all possible types, e.g. "|rbot: hello", or 
+      # combine all possible types, e.g. "|rbot: hello", or
       # "/msg rbot rbot: hello", etc
-      if @message.gsub!(/^\s*#{bot.nick}\s*([:;,>]|\s)\s*/, "")
+      if @message.gsub!(/^\s*#{Regexp.escape(bot.nick)}\s*([:;,>]|\s)\s*/i, "")
         @address = true
       end
-      
+
       if(@message =~ /^\001ACTION\s(.+)\001/)
         @message = $1
         @action = true
       end
-      
+
       # free splitting for plugins
       @params = @message.dup
       if @params.gsub!(/^\s*(\S+)[\s$]*/, "")
@@ -178,6 +203,16 @@ module Irc
       @replied = true
     end
 
+    # convenience method to reply to a message with an action. It's the
+    # same as doing:
+    # <tt>@bot.action m.replyto, string</tt>
+    # So if the message is private, it will reply to the user. If it was
+    # in a channel, it will reply in the channel.
+    def act(string)
+      @bot.action @replyto, string
+      @replied = true
+    end
+
     # convenience method to reply "okay" in the current language to the
     # message
     def okay
@@ -188,10 +223,18 @@ module Irc
 
   # class to manage IRC PRIVMSGs
   class PrivMessage < UserMessage
+    def initialize(bot, source, target, message)
+      @msg_wants_id = true
+      super
+    end
   end
-  
+
   # class to manage IRC NOTICEs
   class NoticeMessage < UserMessage
+    def initialize(bot, source, target, message)
+      @msg_wants_id = true
+      super
+    end
   end
 
   # class to manage IRC KICKs
@@ -200,7 +243,7 @@ module Irc
   class KickMessage < BasicUserMessage
     # channel user was kicked from
     attr_reader :channel
-    
+
     def initialize(bot, source, target, channel, message="")
       super(bot, source, target, message)
       @channel = channel
@@ -248,7 +291,7 @@ module Irc
       @address = (sourcenick.downcase == @bot.nick.downcase)
     end
   end
-  
+
   # class to manage channel parts
   # same as a join, but can have a message too
   class PartMessage < JoinMessage

data/lib/rbot/messagemapper.rb

@@ -1,9 +1,9 @@
 module Irc
-  
+
   # +MessageMapper+ is a class designed to reduce the amount of regexps and
   # string parsing plugins and bot modules need to do, in order to process
   # and respond to messages.
-  # 
+  #
   # You add templates to the MessageMapper which are examined by the handle
   # method when handling a message. The templates tell the mapper which
   # method in its parent class (your class) to invoke for that message. The
@@ -13,7 +13,7 @@ module Irc
   # A template such as "foo :option :otheroption" will match the string "foo
   # bar baz" and, by default, result in method +foo+ being called, if
   # present, in the parent class. It will receive two parameters, the
-  # Message (derived from BasicUserMessage) and a Hash containing 
+  # Message (derived from BasicUserMessage) and a Hash containing
   #   {:option => "bar", :otheroption => "baz"}
   # See the #map method for more details.
   class MessageMapper
@@ -30,7 +30,7 @@ module Irc
       @templates = Array.new
       @fallback = 'usage'
     end
-    
+
     # args:: hash format containing arguments for this template
     #
     # map a template string to an action. example:
@@ -38,7 +38,7 @@ module Irc
     # (other examples follow). By default, maps a matched string to an
     # action with the name of the first word in the template. The action is
     # a method which takes a message and a parameter hash for arguments.
-    # 
+    #
     # The :action => 'method_name' option can be used to override this
     # default behaviour. Example:
     #   map 'myplugin :parameter1 :parameter2', :action => 'mymethod'
@@ -50,14 +50,14 @@ module Irc
     # Static parameters (not prefixed with ':' or '*') must match the
     # respective component of the message exactly. Example:
     #   map 'myplugin :foo is :bar'
-    # will only match messages of the form "myplugin something is 
+    # will only match messages of the form "myplugin something is
     # somethingelse"
     #
     # Dynamic parameters can be specified by a colon ':' to match a single
-    # component (whitespace seperated), or a * to such up all following
+    # component (whitespace seperated), or a * to suck up all following
     # parameters into an array. Example:
     #   map 'myplugin :parameter1 *rest'
-    # 
+    #
     # You can provide defaults for dynamic components using the :defaults
     # parameter. If a component has a default, then it is optional. e.g:
     #   map 'myplugin :foo :bar', :defaults => {:bar => 'qux'}
@@ -81,7 +81,7 @@ module Irc
     #   map 'karma :key', :defaults => {:key => false}
     #   # match 'karma for something' and call my karma() method
     #   map 'karma for :key'
-    #   
+    #
     #   # two matches, one for public messages in a channel, one for
     #   # private messages which therefore require a channel argument
     #   map 'urls search :channel :limit :string', :action => 'search',
@@ -91,19 +91,19 @@ module Irc
     #   plugin.map 'urls search :limit :string', :action => 'search',
     #             :defaults => {:limit => 4},
     #             :requirements => {:limit => /^\d+$/},
-    #             :private => false                                     
+    #             :private => false
     #
     def map(*args)
       @templates << Template.new(*args)
     end
-    
+
     def each
       @templates.each {|tmpl| yield tmpl}
     end
     def last
       @templates.last
     end
-    
+
     # m::  derived from BasicUserMessage
     #
     # examine the message +m+, comparing it with each map()'d template to
@@ -121,7 +121,10 @@ module Irc
           failures << [tmpl, failure]
         else
           action = tmpl.options[:action] ? tmpl.options[:action] : tmpl.items[0]
-          next unless @parent.respond_to?(action)
+          unless @parent.respond_to?(action)
+            failures << [tmpl, "class does not respond to action #{action}"]
+            next
+          end
           auth = tmpl.options[:auth] ? tmpl.options[:auth] : tmpl.items[0]
           debug "checking auth for #{auth}"
           if m.bot.auth.allow?(auth, m.source, m.replyto)
@@ -135,7 +138,9 @@ module Irc
           return false
         end
       end
-      debug failures.inspect
+      failures.each {|f, r|
+        debug "#{f.inspect} => #{r}"
+      }
       debug "no handler found, trying fallback"
       if @fallback != nil && @parent.respond_to?(@fallback)
         if m.bot.auth.allow?(@fallback, m.source, m.replyto)
@@ -172,8 +177,11 @@ module Irc
       # Verify uniqueness of each component.
       @items.inject({}) do |seen, item|
         if item.kind_of? Symbol
-          raise ArgumentError, "Illegal template -- duplicate item #{item}\n   #{str.inspect}" if seen.key? item
-          seen[item] = true
+          # We must remove the initial * when present,
+          # because the parameters hash will intern both :item and *item as :item
+          it = item.to_s.sub(/^\*/,"").intern
+          raise ArgumentError, "Illegal template -- duplicate item #{it} in #{str.inspect}" if seen.key? it
+          seen[it] = true
         end
         seen
       end
@@ -219,7 +227,7 @@ module Irc
 
       return nil, "template is not configured for private messages" if @options.has_key?(:private) && !@options[:private] && m.private?
       return nil, "template is not configured for public messages" if @options.has_key?(:public) && !@options[:public] && !m.private?
-      
+
       options.delete_if {|k, v| v.nil?} # Remove nil values.
       return options, nil
     end

data/lib/rbot/plugins.rb

@@ -1,93 +1,99 @@
 module Irc
+    BotConfig.register BotConfigArrayValue.new('plugins.blacklist',
+      :default => [], :wizard => false, :requires_restart => true,
+      :desc => "Plugins that should not be loaded")
 module Plugins
   require 'rbot/messagemapper'
 
-  # base class for all rbot plugins
-  # certain methods will be called if they are provided, if you define one of
-  # the following methods, it will be called as appropriate:
-  #
-  # map(template, options)::
-  #    map is the new, cleaner way to respond to specific message formats
-  #    without littering your plugin code with regexps. examples:
-  #
-  #      plugin.map 'karmastats', :action => 'karma_stats'
-  #
-  #      # while in the plugin...
-  #      def karma_stats(m, params)
-  #        m.reply "..."
-  #      end
-  #      
-  #      # the default action is the first component
-  #      plugin.map 'karma'
-  #
-  #      # attributes can be pulled out of the match string
-  #      plugin.map 'karma for :key'
-  #      plugin.map 'karma :key'
-  #
-  #      # while in the plugin...
-  #      def karma(m, params)
-  #        item = params[:key]
-  #        m.reply 'karma for #{item}'
-  #      end
-  #      
-  #      # you can setup defaults, to make parameters optional
-  #      plugin.map 'karma :key', :defaults => {:key => 'defaultvalue'}
-  #      
-  #      # the default auth check is also against the first component
-  #      # but that can be changed
-  #      plugin.map 'karmastats', :auth => 'karma'
-  #
-  #      # maps can be restricted to public or private message:
-  #      plugin.map 'karmastats', :private false,
-  #      plugin.map 'karmastats', :public false,
-  #    end
-  #
-  #    To activate your maps, you simply register them
-  #    plugin.register_maps
-  #    This also sets the privmsg handler to use the map lookups for
-  #    handling messages. You can still use listen(), kick() etc methods
-  # 
-  # listen(UserMessage)::
-  #                        Called for all messages of any type. To
-  #                        differentiate them, use message.kind_of? It'll be
-  #                        either a PrivMessage, NoticeMessage, KickMessage,
-  #                        QuitMessage, PartMessage, JoinMessage, NickMessage,
-  #                        etc.
-  #                              
-  # privmsg(PrivMessage)::
-  #                        called for a PRIVMSG if the first word matches one
-  #                        the plugin register()d for. Use m.plugin to get
-  #                        that word and m.params for the rest of the message,
-  #                        if applicable.
-  #
-  # kick(KickMessage)::
-  #                        Called when a user (or the bot) is kicked from a
-  #                        channel the bot is in.
-  #
-  # join(JoinMessage)::
-  #                        Called when a user (or the bot) joins a channel
-  #
-  # part(PartMessage)::
-  #                        Called when a user (or the bot) parts a channel
-  #
-  # quit(QuitMessage)::    
-  #                        Called when a user (or the bot) quits IRC
-  #
-  # nick(NickMessage)::
-  #                        Called when a user (or the bot) changes Nick
-  # topic(TopicMessage)::
-  #                        Called when a user (or the bot) changes a channel
-  #                        topic
-  #
-  # connect()::            Called when a server is joined successfully, but
-  #                        before autojoin channels are joined (no params)
-  # 
-  # save::                 Called when you are required to save your plugin's
-  #                        state, if you maintain data between sessions
-  #
-  # cleanup::              called before your plugin is "unloaded", prior to a
-  #                        plugin reload or bot quit - close any open
-  #                        files/connections or flush caches here
+=begin
+  base class for all rbot plugins
+  certain methods will be called if they are provided, if you define one of
+  the following methods, it will be called as appropriate:
+
+  map(template, options)::
+  map!(template, options)::
+     map is the new, cleaner way to respond to specific message formats
+     without littering your plugin code with regexps. The difference
+     between map and map! is that map! will not register the new command
+     as an alternative name for the plugin.
+
+     Examples:
+
+       plugin.map 'karmastats', :action => 'karma_stats'
+
+       # while in the plugin...
+       def karma_stats(m, params)
+         m.reply "..."
+       end
+
+       # the default action is the first component
+       plugin.map 'karma'
+
+       # attributes can be pulled out of the match string
+       plugin.map 'karma for :key'
+       plugin.map 'karma :key'
+
+       # while in the plugin...
+       def karma(m, params)
+         item = params[:key]
+         m.reply 'karma for #{item}'
+       end
+
+       # you can setup defaults, to make parameters optional
+       plugin.map 'karma :key', :defaults => {:key => 'defaultvalue'}
+
+       # the default auth check is also against the first component
+       # but that can be changed
+       plugin.map 'karmastats', :auth => 'karma'
+
+       # maps can be restricted to public or private message:
+       plugin.map 'karmastats', :private false,
+       plugin.map 'karmastats', :public false,
+     end
+
+  listen(UserMessage)::
+                         Called for all messages of any type. To
+                         differentiate them, use message.kind_of? It'll be
+                         either a PrivMessage, NoticeMessage, KickMessage,
+                         QuitMessage, PartMessage, JoinMessage, NickMessage,
+                         etc.
+
+  privmsg(PrivMessage)::
+                         called for a PRIVMSG if the first word matches one
+                         the plugin register()d for. Use m.plugin to get
+                         that word and m.params for the rest of the message,
+                         if applicable.
+
+  kick(KickMessage)::
+                         Called when a user (or the bot) is kicked from a
+                         channel the bot is in.
+
+  join(JoinMessage)::
+                         Called when a user (or the bot) joins a channel
+
+  part(PartMessage)::
+                         Called when a user (or the bot) parts a channel
+
+  quit(QuitMessage)::
+                         Called when a user (or the bot) quits IRC
+
+  nick(NickMessage)::
+                         Called when a user (or the bot) changes Nick
+  topic(TopicMessage)::
+                         Called when a user (or the bot) changes a channel
+                         topic
+
+  connect()::            Called when a server is joined successfully, but
+                         before autojoin channels are joined (no params)
+
+  save::                 Called when you are required to save your plugin's
+                         state, if you maintain data between sessions
+
+  cleanup::              called before your plugin is "unloaded", prior to a
+                         plugin reload or bot quit - close any open
+                         files/connections or flush caches here
+=end
+
   class Plugin
     attr_reader :bot   # the associated bot
     # initialise your plugin. Always call super if you override this method,
@@ -99,6 +105,20 @@ module Plugins
       @registry = BotRegistryAccessor.new(@bot, self.class.to_s.gsub(/^.*::/, ""))
     end
 
+    def flush_registry
+      # debug "Flushing #{@registry}"
+      @registry.flush
+    end
+
+    def cleanup
+      # debug "Closing #{@registry}"
+      @registry.close
+    end
+
+    def handle(m)
+      @handler.handle(m)
+    end
+
     def map(*args)
       @handler.map(*args)
       # register this map
@@ -106,7 +126,19 @@ module Plugins
       self.register name
       unless self.respond_to?('privmsg')
         def self.privmsg(m)
-          @handler.handle(m)
+          handle(m)
+        end
+      end
+    end
+
+    def map!(*args)
+      @handler.map(*args)
+      # register this map
+      name = @handler.last.items[0]
+      self.register name, {:hidden => true}
+      unless self.respond_to?('privmsg')
+        def self.privmsg(m)
+          handle(m)
         end
       end
     end
@@ -116,23 +148,24 @@ module Plugins
     def name
       @names.join("|")
     end
-    
+
     # return a help string for your module. for complex modules, you may wish
     # to break your help into topics, and return a list of available topics if
     # +topic+ is nil. +plugin+ is passed containing the matching prefix for
-    # this message - if your plugin handles multiple prefixes, make sure your
+    # this message - if your plugin handles multiple prefixes, make sure you
     # return the correct help for the prefix requested
     def help(plugin, topic)
       "no help"
     end
-    
+
     # 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)
+    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
+      @names << name unless opts.fetch(:hidden, false)
     end
 
     # default usage method provided as a utility for simple plugins. The
@@ -160,7 +193,7 @@ module Plugins
       @dirs = dirlist
       scan
     end
-    
+
     # access to associated bot
     def Plugins.bot
       @@bot
@@ -173,29 +206,75 @@ module Plugins
 
     # 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|
+        pn = p + ".rb"
+        processed[pn.intern] = :blacklisted
+      }
+
       dirs = Array.new
       dirs << Config::datadir + "/plugins"
       dirs += @dirs
-      dirs.each {|dir|
+      dirs.reverse.each {|dir|
         if(FileTest.directory?(dir))
           d = Dir.new(dir)
           d.sort.each {|file|
+
             next if(file =~ /^\./)
+
+            if processed.has_key?(file.intern)
+              @ignored << {:name => file, :dir => dir, :reason => processed[file.intern]}
+              next
+            end
+
+            if(file =~ /^(.+\.rb)\.disabled$/)
+              # GB: Do we want to do this? This means that a disabled plugin in a directory
+              #     will disable in all subsequent directories. This was probably meant
+              #     to be used before plugins.blacklist was implemented, so I think
+              #     we don't need this anymore
+              processed[$1.intern] = :disabled
+              @ignored << {:name => $1, :dir => dir, :reason => processed[$1.intern]}
+              next
+            end
+
             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)
-            rescue TimeoutError, StandardError, NameError, LoadError, SyntaxError => err
-              puts "warning: plugin #{tmpfilename} load failed: " + err
-              puts err.backtrace.join("\n")
+              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}"
             end
           }
         end
@@ -204,6 +283,7 @@ module Plugins
 
     # call the save method for each active plugin
     def save
+      delegate 'flush_registry'
       delegate 'save'
     end
 
@@ -219,16 +299,37 @@ module Plugins
       cleanup
       @@plugins = Hash.new
       scan
+
     end
 
-    # return list of help topics (plugin names)
-    def helptopics
+    def status(short=false)
+      # Active plugins first
       if(@@plugins.length > 0)
-        # return " [plugins: " + @@plugins.keys.sort.join(", ") + "]"
-        return " [#{length} plugins: " + @@plugins.values.uniq.collect{|p| p.name}.sort.join(", ") + "]"
+        list = "#{length} plugin#{'s' if length > 1}"
+        if short
+          list << " loaded"
+        else
+          list << ": " + @@plugins.values.uniq.collect{|p| p.name}.sort.join(", ")
+        end
       else
-        return " [no plugins active]" 
+        list = "no plugins active"
       end
+      # Ignored plugins next
+      unless @ignored.empty?
+        list << "; #{Underline}#{@ignored.length} plugin#{'s' if @ignored.length > 1} ignored#{Underline}"
+        list << ": use #{Bold}help ignored plugins#{Bold} to see why" unless short
+      end
+      # Failed plugins next
+      unless @failed.empty?
+        list << "; #{Reverse}#{@failed.length} plugin#{'s' if @failed.length > 1} failed to load#{Reverse}"
+        list << ": use #{Bold}help failed plugins#{Bold} to see why" unless short
+      end
+      list
+    end
+
+    # return list of help topics (plugin names)
+    def helptopics
+      return " [#{status}]"
     end
 
     def length
@@ -237,22 +338,44 @@ module Plugins
 
     # return help for +topic+ (call associated plugin's help method)
     def help(topic="")
-      if(topic =~ /^(\S+)\s*(.*)$/)
+      case topic
+      when /fail(?:ed)?\s*plugins?.*(trace(?:back)?s?)?/
+        # debug "Failures: #{@failed.inspect}"
+        return "no plugins failed to load" if @failed.empty?
+        return (@failed.inject(Array.new) { |list, p|
+          list << "#{Bold}#{p[:name]}#{Bold} in #{p[:dir]} failed"
+          list << "with error #{p[:reason].class}: #{p[:reason]}"
+          list << "at #{p[:reason].backtrace.join(', ')}" if $1 and not p[:reason].backtrace.empty?
+          list
+        }).join("\n")
+      when /ignored?\s*plugins?/
+        return "no plugins were ignored" if @ignored.empty?
+        return (@ignored.inject(Array.new) { |list, p|
+          case p[:reason]
+          when :loaded
+            list << "#{p[:name]} in #{p[:dir]} (overruled by previous)"
+          else
+            list << "#{p[:name]} in #{p[:dir]} (#{p[:reason].to_s})"
+          end
+          list
+        }).join(", ")
+      when /^(\S+)\s*(.*)$/
         key = $1
         params = $2
         if(@@plugins.has_key?(key))
           begin
             return @@plugins[key].help(key, params)
-          rescue TimeoutError, StandardError, NameError, SyntaxError => err
-            puts "plugin #{@@plugins[key].name} help() failed: " + err
-            puts err.backtrace.join("\n")
+          rescue Exception => err
+            #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+            error "plugin #{@@plugins[key].name} help() failed: #{err.class}: #{err}"
+            error err.backtrace.join("\n")
           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)
@@ -260,9 +383,10 @@ module Plugins
         if(p.respond_to? method)
           begin
             p.send method, *args
-          rescue TimeoutError, StandardError, NameError, SyntaxError => err
-            puts "plugin #{p.name} #{method}() failed: " + err
-            puts err.backtrace.join("\n")
+          rescue Exception => err
+            #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+            error "plugin #{p.name} #{method}() failed: #{err.class}: #{err}"
+            error err.backtrace.join("\n")
           end
         end
       }
@@ -277,9 +401,14 @@ module Plugins
           @@bot.auth.allow?(m.plugin, m.source, m.replyto))
         begin
           @@plugins[m.plugin].privmsg(m)
-        rescue TimeoutError, StandardError, NameError, SyntaxError => err
-          puts "plugin #{@@plugins[m.plugin].name} privmsg() failed: " + err
-          puts err.backtrace.join("\n")
+        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")
         end
         return true
       end