module Irc
BotConfig.register BotConfigArrayValue.new('plugins.blacklist',
- :default => [], :wizard => false, :requires_restart => true,
+ :default => [], :wizard => false, :requires_rescan => true,
:desc => "Plugins that should not be loaded")
module Plugins
require 'rbot/messagemapper'
class BotModule
attr_reader :bot # the associated bot
+
# 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
+ @manager = Plugins::pluginmanager
+ @bot = @manager.bot
+
@botmodule_triggers = Array.new
+
@handler = MessageMapper.new(self)
@registry = BotRegistryAccessor.new(@bot, self.class.to_s.gsub(/^.*::/, ""))
+
+ @manager.add_botmodule(self)
+ end
+
+ def botmodule_class
+ :BotModule
end
def flush_registry
end
def map(*args)
- @handler.map(*args)
+ @handler.map(self, *args)
# register this map
name = @handler.last.items[0]
- self.register name
+ self.register name, :auth => nil
unless self.respond_to?('privmsg')
def self.privmsg(m)
handle(m)
end
def map!(*args)
- @handler.map(*args)
+ @handler.map(self, *args)
# register this map
name = @handler.last.items[0]
- self.register name, {:hidden => true}
+ self.register name, :auth => nil, :hidden => true
unless self.respond_to?('privmsg')
def self.privmsg(m)
handle(m)
end
end
+ # Sets the default auth for command path _cmd_ to _val_ on channel _chan_:
+ # usually _chan_ is either "*" for everywhere, public and private (in which
+ # case it can be omitted) or "?" for private communications
+ #
+ def default_auth(cmd, val, chan="*")
+ case cmd
+ when "*", ""
+ c = nil
+ else
+ c = cmd
+ end
+ Auth::defaultbotuser.set_default_permission(propose_default_path(c), val)
+ end
+
+ # Gets the default command path which would be given to command _cmd_
+ def propose_default_path(cmd)
+ [name, cmd].compact.join("::")
+ end
+
# 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|module)?$/,"")
+ end
+
+ # just calls name
+ def to_s
+ name
+ end
+
+ # intern the name
+ def to_sym
+ self.name.to_sym
end
# return a help string for your module. for complex modules, you may wish
# 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
- @botmodule_triggers << name unless opts.fetch(:hidden, false)
+ def register(cmd, opts={})
+ raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
+ who = @manager.who_handles?(cmd)
+ if who
+ raise "Command #{cmd} is already handled by #{who.botmodule_class} #{who}" if who != self
+ return
+ end
+ if opts.has_key?(:auth)
+ @manager.register(self, cmd, opts[:auth])
+ else
+ @manager.register(self, cmd, propose_default_path(cmd))
+ end
+ @botmodule_triggers << cmd unless opts.fetch(:hidden, false)
end
# default usage method provided as a utility for simple plugins. The
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 botmodule_class
+ :CoreBotModule
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 botmodule_class
+ :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
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
+ :CoreBotModule => [],
+ :Plugin => []
}
+ @names_hash = Hash.new
+ @commandmappers = Hash.new
+ end
- # associated IrcBot class
+ # 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 the botmodule with the given _name_
+ def [](name)
+ @names_hash[name.to_sym]
+ end
+
+ # Returns +true+ if _cmd_ has already been registered as a command
+ def who_handles?(cmd)
+ return nil unless @commandmappers.has_key?(cmd.to_sym)
+ return @commandmappers[cmd.to_sym][:botmodule]
+ end
+
+ # Registers botmodule _botmodule_ with command _cmd_ and command path _auth_path_
+ def register(botmodule, cmd, auth_path)
+ raise TypeError, "First argument #{botmodule.inspect} is not of class BotModule" unless botmodule.kind_of?(BotModule)
+ @commandmappers[cmd.to_sym] = {:botmodule => botmodule, :auth => auth_path}
+ end
+
+ def add_botmodule(botmodule)
+ raise TypeError, "Argument #{botmodule.inspect} is not of class BotModule" unless botmodule.kind_of?(BotModule)
+ kl = botmodule.botmodule_class
+ if @names_hash.has_key?(botmodule.to_sym)
+ case self[botmodule].botmodule_class
+ when kl
+ raise "#{kl} #{botmodule} already registered!"
+ else
+ raise "#{self[botmodule].botmodule_class} #{botmodule} already registered, cannot re-register as #{kl}"
+ end
+ end
+ @botmodules[kl] << botmodule
+ @names_hash[botmodule.to_sym] = botmodule
+ end
+
+ # Returns an array of the loaded plugins
+ def core_modules
+ @botmodules[:CoreBotModule]
+ end
+
+ # Returns an array of the loaded plugins
def plugins
- @botmodules[:plugin]
+ @botmodules[:Plugin]
end
# Returns a hash of the registered message prefixes and associated
- # core modules
- def core_modules
- @botmodules[:core]
+ # plugins
+ def commands
+ @commandmappers
end
# Makes a string of error _err_ by adding text _str_
plugin_module = Module.new
desc = desc.to_s + " " if desc
+
begin
plugin_string = IO.readlines(fname).join("")
debug "loading #{desc}#{fname}"
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
+ # TODO find a way to specify necessary plugins which _must_ be loaded
+ #
+ def add_botmodule_dir(*dirlist)
+ @dirs += dirlist
+ debug "Botmodule loading path: #{@dirs.join(', ')}"
end
# load plugins from pre-assigned list of directories
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|
}
end
}
+ debug "finished loading plugins: #{status(true)}"
end
# call the save method for each active plugin
# call the cleanup method for each active plugin
def cleanup
delegate 'cleanup'
+ reset_botmodule_lists
end
# drop all plugins and rescan plugins on disk
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?
# return list of help topics (plugin names)
def helptopics
- return " [#{status}]"
+ return status
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)
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|
+ 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")
+ }.join("\n")
when /ignored?\s*plugins?/
return "no plugins were ignored" if @ignored.empty?
- return (@ignored.inject(Array.new) { |list, p|
+ return @ignored.inject(Array.new) { |list, p|
case p[:reason]
when :loaded
list << "#{p[:name]} in #{p[:dir]} (overruled by previous)"
list << "#{p[:name]} in #{p[:dir]} (#{p[:reason].to_s})"
end
list
- }).join(", ")
+ }.join(", ")
when /^(\S+)\s*(.*)$/
key = $1
params = $2
- if(@@plugins.has_key?(key))
+
+ # Let's see if we can match a plugin by the given name
+ (core_modules + plugins).each { |p|
+ next unless p.name == key
begin
- return @@plugins[key].help(key, params)
+ return p.help(key, params)
rescue Exception => err
#rescue TimeoutError, StandardError, NameError, SyntaxError => err
- error report_error("plugin #{@@plugins[key].name} help() failed:", err)
+ error report_error("#{p.botmodule_class} #{p.name} help() failed:", err)
+ end
+ }
+
+ # Nope, let's see if it's a command, and ask for help at the corresponding botmodule
+ k = key.to_sym
+ if commands.has_key?(k)
+ p = commands[k][:botmodule]
+ begin
+ return p.help(key, params)
+ rescue Exception => err
+ #rescue TimeoutError, StandardError, NameError, SyntaxError => err
+ error report_error("#{p.botmodule_class} #{p.name} help() failed:", err)
end
- else
- return false
end
end
+ return false
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)
+ raise if err.kind_of?(SystemExit)
+ error report_error("#{p.botmodule_class} #{p.name} #{method}() failed:", err)
+ raise if err.kind_of?(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 #{m.message.inspect} from #{m.source} to #{m.replyto} with pluginkey #{m.plugin.inspect}"
+ return unless m.plugin
+ k = m.plugin.to_sym
+ if commands.has_key?(k)
+ p = commands[k][:botmodule]
+ a = commands[k][:auth]
+ # We check here for things that don't check themselves
+ # (e.g. mapped things)
+ # debug "Checking auth ..."
+ if a.nil? || @bot.auth.allow?(a, 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
+ raise if err.kind_of?(SystemExit)
+ error report_error("#{p.botmodule_class} #{p.name} privmsg() failed:", err)
+ raise if err.kind_of?(BDB::Fatal)
+ end
+ # debug "Successfully delegated #{m.message}"
+ return true
+ else
+ # debug "#{p.botmodule_class} #{p.name} is registered, but it doesn't respond to privmsg()"
end
- return true
+ else
+ # debug "#{p.botmodule_class} #{p.name} is registered, but #{m.source} isn't allowed to call #{m.plugin.inspect} on #{m.replyto}"
end
- return false
- }
+ end
+ # debug "Finished delegating privmsg with key #{m.plugin.inspect}" + ( pl.empty? ? "" : " to #{pl.values.first[:botmodule].botmodule_class}s" )
+ return false
+ # debug "Finished delegating privmsg with key #{m.plugin.inspect}"
end
end