From fdc64bd6634ae0aa3b9ecc4973648114f4a83ef5 Mon Sep 17 00:00:00 2001 From: Giuseppe Bilotta Date: Tue, 1 Aug 2006 17:14:01 +0000 Subject: New modular framework is in place. Nothing works until core/auth.rb is done, though --- lib/rbot/botuser.rb | 63 +++++++------ lib/rbot/core/core.rb | 155 ++++++++++++++++++++++++++++++++ lib/rbot/ircbot.rb | 10 +-- lib/rbot/plugins.rb | 244 ++++++++++++++++++++++++++++++++------------------ 4 files changed, 353 insertions(+), 119 deletions(-) create mode 100644 lib/rbot/core/core.rb (limited to 'lib/rbot') 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 Irc::User 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 [] => quit IRC with message " + when "restart" + return "restart => completely stop and restart the bot (including reconnect)" + when "join" + return "join [] => join channel with secret key if specified. #{myself} also responds to invites if you have the required access level" + when "part" + return "part => part 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 => attempt to change nick to " + when "say" + return "say | => say to or in private message to " + when "action" + return "action | => does a /me to or in private message to " + when "quiet" + return "quiet [in here|] => with no arguments, stop speaking in all channels, if \"in here\", stop speaking in this channel, or stop speaking in " + when "talk" + return "talk [in here|] => with no arguments, resume speaking in all channels, if \"in here\", resume speaking in this channel, or resume speaking in " + 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(/^#::/,"").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 -- cgit v1.2.3