etc.
privmsg(PrivMessage)::
- called for a PRIVMSG if the first word matches one
+ 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.
+ unreplied(PrivMessage)::
+ Called for a PRIVMSG which has not been replied to.
+
kick(KickMessage)::
Called when a user (or the bot) is kicked from a
channel the bot is in.
connect():: Called when a server is joined successfully, but
before autojoin channels are joined (no params)
+ set_language(String)::
+ Called when the user sets a new language
+ whose name is the given String
+
save:: Called when you are required to save your plugin's
state, if you maintain data between sessions
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(kl)
- @manager = Plugins::pluginmanager
+ def initialize
+ @manager = Plugins::manager
@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(self)
+ if self.respond_to?('set_language')
+ self.set_language(@bot.lang.language)
+ end
+ end
+
+ def botmodule_class
+ :BotModule
end
def flush_registry
@handler.handle(m)
end
+ def call_event(ev, *args)
+ @bot.plugins.delegate('event_' + ev.to_s.gsub(/[^\w\?!]+/, '_'), *args)
+ end
+
def map(*args)
@handler.map(self, *args)
# register this map
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
# 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
# message prefixes
def register(cmd, opts={})
raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
- return if @manager.knows?(cmd, @botmodule_class)
+ 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
# default usage method provided as a utility for simple plugins. The
# MessageMapper uses 'usage' as its default fallback method.
def usage(m, params = {})
- m.reply "incorrect usage, ask for help using '#{@bot.nick}: help #{m.plugin}'"
+ m.reply(_("incorrect usage, ask for help using '%{command}'") % {:command => "#{@bot.nick}: help #{m.plugin}"})
end
end
class CoreBotModule < BotModule
- def initialize
- super(:coremodule)
+ def botmodule_class
+ :CoreBotModule
end
end
class Plugin < BotModule
- def initialize
- super(:plugin)
+ def botmodule_class
+ :Plugin
end
end
attr_reader :botmodules
def initialize
- bot_associate(nil)
+ @botmodules = {
+ :CoreBotModule => [],
+ :Plugin => []
+ }
+
+ @names_hash = Hash.new
+ @commandmappers = Hash.new
@dirs = []
+
+ @failed = Array.new
+ @ignored = Array.new
+
+ bot_associate(nil)
end
# Reset lists of botmodules
def reset_botmodule_lists
- @botmodules = {
- :coremodule => [],
- :plugin => []
- }
-
- @commandmappers = {
- :coremodule => {},
- :plugin => {}
- }
-
+ @botmodules[:CoreBotModule].clear
+ @botmodules[:Plugin].clear
+ @names_hash.clear
+ @commandmappers.clear
+ @failures_shown = false
end
# Associate with bot _bot_
@bot = bot
end
- # 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)
+ # 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.class <= BotModule
- kl = botmodule.botmodule_class
- @commandmappers[kl.to_sym][cmd.to_sym] = {:botmodule => botmodule, :auth => auth_path}
- h = @commandmappers[kl.to_sym][cmd.to_sym]
- # debug "Registered command mapper for #{cmd.to_sym} (#{kl.to_sym}): #{h[:botmodule].name} with command path #{h[:auth]}"
+ 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.class <= BotModule
+ raise TypeError, "Argument #{botmodule.inspect} is not of class BotModule" unless botmodule.kind_of?(BotModule)
kl = botmodule.botmodule_class
- raise "#{kl.to_s} #{botmodule.name} already registered!" if @botmodules[kl.to_sym].include?(botmodule)
- @botmodules[kl.to_sym] << botmodule
+ 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[:coremodule]
+ @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
# plugins
- def plugin_commands
- @commandmappers[:plugin]
- end
-
- # Returns a hash of the registered message prefixes and associated
- # core modules
- def core_commands
- @commandmappers[:coremodule]
+ def commands
+ @commandmappers
end
# Makes a string of error _err_ by adding text _str_
return :loaded
rescue Exception => err
# rescue TimeoutError, StandardError, NameError, LoadError, SyntaxError => err
- warning report_error("#{desc}#{fname} load failed", err)
+ error report_error("#{desc}#{fname} load failed", err)
bt = err.backtrace.select { |line|
line.match(/^(\(eval\)|#{fname}):\d+/)
}
debug "Botmodule loading path: #{@dirs.join(', ')}"
end
+ def clear_botmodule_dirs
+ @dirs.clear
+ debug "Botmodule loading path cleared"
+ end
+
# load plugins from pre-assigned list of directories
def scan
- @failed = Array.new
- @ignored = Array.new
+ @failed.clear
+ @ignored.clear
processed = Hash.new
@bot.config['plugins.blacklist'].each { |p|
# call the cleanup method for each active plugin
def cleanup
- @bot.save_mutex.synchronize do
- delegate 'cleanup'
- end
+ delegate 'cleanup'
reset_botmodule_lists
end
end
def status(short=false)
- list = ""
+ output = []
if self.core_length > 0
- list << "#{self.core_length} core module#{'s' if core_length > 1}"
if short
- list << " loaded"
+ output << n_("%{count} core module loaded", "%{count} core modules loaded",
+ self.core_length) % {:count => self.core_length}
else
- list << ": " + core_modules.collect{ |p| p.name}.sort.join(", ")
+ output << n_("%{count} core module: %{list}",
+ "%{count} core modules: %{list}", self.core_length) %
+ { :count => self.core_length,
+ :list => core_modules.collect{ |p| p.name}.sort.join(", ") }
end
else
- list << "no core botmodules loaded"
+ output << _("no core botmodules loaded")
end
# Active plugins first
if(self.length > 0)
- list << "; #{self.length} plugin#{'s' if length > 1}"
if short
- list << " loaded"
+ output << n_("%{count} plugin loaded", "%{count} plugins loaded",
+ self.length) % {:count => self.length}
else
- list << ": " + plugins.collect{ |p| p.name}.sort.join(", ")
+ output << n_("%{count} plugin: %{list}",
+ "%{count} plugins: %{list}", self.length) %
+ { :count => self.length,
+ :list => plugins.collect{ |p| p.name}.sort.join(", ") }
end
else
- list << "no plugins active"
+ output << "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
+ unless @ignored.empty? or @failures_shown
+ if short
+ output << n_("%{highlight}%{count} plugin ignored%{highlight}",
+ "%{highlight}%{count} plugins ignored%{highlight}",
+ @ignored.length) %
+ { :count => @ignored.length, :highlight => Underline }
+ else
+ output << n_("%{highlight}%{count} plugin ignored%{highlight}: use %{bold}%{command}%{bold} to see why",
+ "%{highlight}%{count} plugins ignored%{highlight}: use %{bold}%{command}%{bold} to see why",
+ @ignored.length) %
+ { :count => @ignored.length, :highlight => Underline,
+ :bold => Bold, :command => "help ignored plugins"}
+ end
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
+ unless @failed.empty? or @failures_shown
+ if short
+ output << n_("%{highlight}%{count} plugin failed to load%{highlight}",
+ "%{highlight}%{count} plugins failed to load%{highlight}",
+ @failed.length) %
+ { :count => @failed.length, :highlight => Reverse }
+ else
+ output << n_("%{highlight}%{count} plugin failed to load%{highlight}: use %{bold}%{command}%{bold} to see why",
+ "%{highlight}%{count} plugins failed to load%{highlight}: use %{bold}%{command}%{bold} to see why",
+ @failed.length) %
+ { :count => @failed.length, :highlight => Reverse,
+ :bold => Bold, :command => "help failed plugins"}
+ end
end
- list
+ output.join '; '
end
# return list of help topics (plugin names)
def helptopics
- return status
+ rv = status
+ @failures_shown = true
+ rv
end
def length
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
+ return _("no plugins failed to load") if @failed.empty?
+ return @failed.collect { |p|
+ _('%{highlight}%{plugin}%{highlight} in %{dir} failed with error %{exception}: %{reason}') % {
+ :highlight => Bold, :plugin => p[:name], :dir => p[:dir],
+ :exception => p[:reason].class, :reason => p[:reason],
+ } + if $1 && !p[:reason].backtrace.empty?
+ _('at %{backtrace}') % {:backtrace => p[:reason].backtrace.join(', ')}
+ else
+ ''
+ end
}.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(", ")
+ return _('no plugins were ignored') if @ignored.empty?
+
+ tmp = Hash.new
+ @ignored.each do |p|
+ reason = p[:loaded] ? _('overruled by previous') : _(p[:reason].to_s)
+ ((tmp[p[:dir]] ||= Hash.new)[reason] ||= Array.new).push(p[:name])
+ end
+
+ return tmp.map do |dir, reasons|
+ # FIXME get rid of these string concatenations to make gettext easier
+ s = reasons.map { |r, list|
+ list.map { |_| _.sub(/\.rb$/, '') }.join(', ') + " (#{r})"
+ }.join('; ')
+ "in #{dir}: #{s}"
+ end.join('; ')
when /^(\S+)\s*(.*)$/
key = $1
params = $2
+
+ # Let's see if we can match a plugin by the given name
(core_modules + plugins).each { |p|
- # debug "checking #{p.name.inspect} against #{key.inspect}"
+ next unless p.name == key
begin
- return p.help(params)
+ 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 if p.name == key
- }
- [core_commands, plugin_commands].each { |pl|
- # debug "looking for #{key.inspect} in #{pl.keys.sort.inspect}"
- if pl.has_key?(key)
- p = pl[key][: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
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
+ end
end
return false
end
# +message+ as a parameter
def delegate(method, *args)
# debug "Delegating #{method.inspect}"
+ ret = Array.new
[core_modules, plugins].each { |pl|
pl.each {|p|
if(p.respond_to? method)
begin
# debug "#{p.botmodule_class} #{p.name} responds"
- p.send method, *args
+ ret.push p.send(method, *args)
rescue Exception => err
- raise if err.class <= SystemExit
+ raise if err.kind_of?(SystemExit)
error report_error("#{p.botmodule_class} #{p.name} #{method}() failed:", err)
- raise if err.class <= BDB::Fatal
+ raise if err.kind_of?(BDB::Fatal)
end
end
}
}
+ return ret
# debug "Finished delegating #{method.inspect}"
end
def privmsg(m)
# debug "Delegating privmsg #{m.message.inspect} from #{m.source} to #{m.replyto} with pluginkey #{m.plugin.inspect}"
return unless m.plugin
- [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][:botmodule]
- a = pl[k][:auth]
- else
- p = nil
- a = nil
- end
- if p
- # 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.class <= SystemExit
- error report_error("#{p.botmodule_class} #{p.name} privmsg() failed:", err)
- raise if err.class <= 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()"
+ 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 #{m.source} isn't allowed to call #{m.plugin.inspect} on #{m.replyto}"
+ # debug "#{p.botmodule_class} #{p.name} is registered, but it doesn't respond to privmsg()"
end
else
- # debug "No #{pl.values.first[:botmodule].botmodule_class} registered #{m.plugin.inspect}" unless pl.empty?
+ # debug "#{p.botmodule_class} #{p.name} is registered, but #{m.source} isn't allowed to call #{m.plugin.inspect} on #{m.replyto}"
end
- # debug "Finished delegating privmsg with key #{m.plugin.inspect}" + ( pl.empty? ? "" : " to #{pl.values.first[:botmodule].botmodule_class}s" )
- }
+ 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
# Returns the only PluginManagerClass instance
- def Plugins.pluginmanager
+ def Plugins.manager
return PluginManagerClass.instance
end
projects / user / henk / code / ruby / rbot.git / blobdiff