X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=lib%2Frbot%2Fplugins.rb;h=b0626b9687181c8416e5d3e68e19ce0efaa439b4;hb=a4ff366eea4c88083be8a3d30cc6395f17b55fe2;hp=546a9b30882cfc3a8613fc326e3b79945dae8b25;hpb=5cc6ece3d483db28f92f82a78b926ba6ce62769d;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git

diff --git a/lib/rbot/plugins.rb b/lib/rbot/plugins.rb
index 546a9b30..b0626b96 100644
--- a/lib/rbot/plugins.rb
+++ b/lib/rbot/plugins.rb
@@ -2,7 +2,7 @@ require 'singleton'
 
 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'
@@ -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(self)
     end
 
     def flush_registry
@@ -122,10 +130,10 @@ module Plugins
     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)
@@ -134,10 +142,10 @@ module Plugins
     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)
@@ -145,10 +153,34 @@ module Plugins
       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
 
     # return a help string for your module. for complex modules, you may wish
@@ -163,11 +195,15 @@ 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
-      @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)
+      return if @manager.knows?(cmd, @botmodule_class)
+      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
@@ -179,20 +215,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 +235,71 @@ 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 => []
+      }
+
+      @commandmappers = {
+        :coremodule => {},
+        :plugin => {}
       }
 
-      # associated IrcBot class
+    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
+
+    # 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)
+      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]}"
+    end
+
+    def add_botmodule(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
+    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 +322,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 +349,14 @@ 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
+    # 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
@@ -310,11 +370,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 +406,7 @@ module Plugins
           }
         end
       }
+      debug "finished loading plugins: #{status(true)}"
     end
 
     # call the save method for each active plugin
@@ -360,6 +418,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 +426,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?
@@ -398,11 +467,15 @@ module Plugins
 
     # 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)
@@ -411,15 +484,15 @@ module Plugins
       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)"
@@ -427,61 +500,105 @@ module Plugins
             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))
+
+	# We test for the mapped commands first
+        k = key.to_sym
+        [core_commands, plugin_commands].each { |pl|
+          next unless pl.has_key?(k)
+          p = pl[k][:botmodule] 
           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
-        else
-          return false
-        end
+        }
+
+	# If no such commmand was found, we look for a botmodule with that name
+        (core_modules + plugins).each { |p|
+	  next unless p.name == key
+          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
+      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
+      [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.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
+          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 true
+        else
+          # debug "No #{pl.values.first[:botmodule].botmodule_class} registered #{m.plugin.inspect}" unless pl.empty?
         end
-        return false
+        # 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