rbot 0.9.14 → 0.9.15

data/lib/rbot/language.rb

@@ -24,6 +24,7 @@ class Bot
       :dutch    => 'nl',
       :japanese => 'ja',
       :russian  => 'ru',
+      :finnish  => 'fi',
       :traditional_chinese => 'zh_TW',
       :simplified_chinese => 'zh_CN'
     }
@@ -57,16 +58,16 @@ class Bot
       return 'english'
     end
 
-    Config.register Config::EnumValue.new('core.language', 
+    Config.register Config::EnumValue.new('core.language',
       :default => Irc::Bot::Language.from_locale, :wizard => true,
       :values => Proc.new{|bot|
             Dir.new(Config::datadir + "/languages").collect {|f|
               f =~ /\.lang$/ ? f.gsub(/\.lang$/, "") : nil
             }.compact
-          },   
+          },
       :on_change => Proc.new {|bot, v| bot.lang.set_language v},
       :desc => "Which language file the bot should use")
-    
+
     def initialize(bot, language)
       @bot = bot
       set_language language

data/lib/rbot/load-gettext.rb

@@ -10,6 +10,11 @@ end
 
 # try to load gettext, or provide fake getttext functions
 begin
+# workaround for gettext not checking empty LANGUAGE
+if ENV["LANGUAGE"] and ENV["LANGUAGE"].empty?
+  ENV.delete "LANGUAGE"
+end
+
   require 'gettext/version'
 
   gettext_version = GetText::VERSION.split('.').map {|n| n.to_i}
@@ -22,25 +27,33 @@ begin
 
   include GetText
 
-  add_default_locale_path(File.join(Irc::Bot::Config.datadir, "../locale/%{locale}/LC_MESSAGES/%{name}.mo"))
+  rbot_locale_path = File.join(Irc::Bot::Config.datadir, "../locale/%{locale}/LC_MESSAGES/%{name}.mo")
+  if gettext_version < [2, 0, 0]
+    add_default_locale_path(rbot_locale_path)
+  else
+    LocalePath.add_default_rule(rbot_locale_path)
+  end
 
   if GetText.respond_to? :cached=
     GetText.cached = false
+  elsif TextDomain.respond_to? :cached=
+    TextDomain.cached = false
   else
     warning 'This version of ruby-gettext does not support non-cached mode; mo files are not reloaded when setting language'
   end
   bindtextdomain 'rbot'
 
   module GetText
-    # patch for ruby-gettext 1.8.0 up to 1.10.0 (and more?) to cope with anonymous
-    # modules used by rbot
-    # FIXME remove the patch when ruby-gettext is fixed, or rbot switches to named modules
-    if !instance_methods.include?('orig_bound_targets')
+    # patch for ruby-gettext 1.x to cope with anonymous modules used by rbot.
+    # bound_targets and related methods are not used nor present in 2.x, and
+    # this patch is not needed
+    if respond_to? :bound_targets, true
       alias :orig_bound_targets :bound_targets
-    end
-    def bound_targets(*a)  # :nodoc:
-      bt = orig_bound_targets(*a) rescue []
-      bt.empty? ? orig_bound_targets(Object) : bt
+
+      def bound_targets(*a)  # :nodoc:
+        bt = orig_bound_targets(*a) rescue []
+        bt.empty? ? orig_bound_targets(Object) : bt
+      end
     end
 
     require 'stringio'

data/lib/rbot/message.rb

@@ -22,6 +22,10 @@ module Irc
         :default => ':', :wizard => true,
         :desc => "when replying with nick put this character after the nick of the user the bot is replying to"
       )
+      Config.register BooleanValue.new('core.private_replies',
+        :default => false,
+        :desc => 'Should the bot reply to private instead of the channel?'
+      )
     end
   end
 
@@ -82,7 +86,7 @@ module Irc
             data
           end
       if ColorCode.key?(f)
-        ColorCode[f] 
+        ColorCode[f]
       else
         0
       end
@@ -155,7 +159,11 @@ module Irc
       ret << ' plainmessage=' << plainmessage.inspect
       ret << fields if fields
       ret << ' (identified)' if identified?
-      ret << ' (addressed to me)' if address?
+      if address?
+        ret << ' (addressed to me'
+        ret << ', with prefix' if prefixed?
+        ret << ')'
+      end
       ret << ' (replied)' if replied?
       ret << ' (ignored)' if ignored?
       ret << ' (in thread)' if in_thread?
@@ -175,6 +183,7 @@ module Irc
       @bot = bot
       @source = source
       @address = false
+      @prefixed = false
       @target = target
       @message = message || ""
       @replied = false
@@ -233,6 +242,12 @@ module Irc
       return @address
     end
 
+    # returns true if the messaged was addressed to the bot via the address
+    # prefix. This can be used to tell appart "!do this" from "botname, do this"
+    def prefixed?
+      return @prefixed
+    end
+
     # strip mIRC colour escapes from a string
     def BasicUserMessage.stripcolour(string)
       return "" unless string
@@ -338,6 +353,7 @@ module Irc
       bot.config['core.address_prefix'].each {|mprefix|
         if @message.gsub!(/^#{Regexp.escape(mprefix)}\s*/, "")
           @address = true
+          @prefixed = true
           break
         end
       }
@@ -390,26 +406,56 @@ module Irc
     # 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 plainreply(string, options={})
-      @bot.say @replyto, string, options
-      @replied = true
+      reply string, {:nick => false}.merge(options)
     end
 
     # Same as reply, but when replying in public it adds the nick of the user
     # the bot is replying to
     def nickreply(string, options={})
-      extra = self.public? ? "#{@source}#{@bot.config['core.nick_postfix']} " : ""
-      @bot.say @replyto, extra + string, options
-      @replied = true
+      reply string, {:nick => true}.merge(options)
+    end
+
+    # Same as nickreply, but always prepend the target's nick.
+    def nickreply!(string, options={})
+      reply string, {:nick => true, :forcenick => true}.merge(options)
     end
 
-    # the default reply style is to nickreply unless the reply already contains
-    # the nick or core.reply_with_nick is set to false
+    # The general way to reply to a command. The following options are available:
+    # :nick [false, true, :auto]
+    #   state if the nick of the user calling the command should be prepended
+    #   :auto uses core.reply_with_nick
+    #
+    # :forcenick [false, true]
+    #   if :nick is true, always prepend the target's nick, even if the nick
+    #   already appears in the reply. Defaults to false.
     #
+    # :to [:private, :public, :auto]
+    #   where should the bot reply?
+    #   :private always reply to the nick
+    #   :public reply to the channel (if available)
+    #   :auto uses core.private_replies
     def reply(string, options={})
-      if @bot.config['core.reply_with_nick'] and not string =~ /(?:^|\W)#{Regexp.escape(@source.to_s)}(?:$|\W)/
-        return nickreply(string, options)
+      opts = {:nick => :auto, :forcenick => false, :to => :auto}.merge options
+
+      if opts[:nick] == :auto
+        opts[:nick] = @bot.config['core.reply_with_nick']
+      end
+
+      if !self.public?
+        opts[:to] = :private
+      elsif opts[:to] == :auto
+        opts[:to] = @bot.config['core.private_replies'] ? :private : :public
+      end
+
+      if (opts[:nick] &&
+          opts[:to] != :private &&
+          (string !~ /(?:^|\W)#{Regexp.escape(@source.to_s)}(?:$|\W)/ ||
+            opts[:forcenick]))
+        string = "#{@source}#{@bot.config['core.nick_postfix']} #{string}"
       end
-      plainreply(string, options)
+      to = (opts[:to] == :private) ? source : @channel
+      @bot.say to, string, options
+      @replied = true
     end
 
     # convenience method to reply to a message with an action. It's the
@@ -431,7 +477,7 @@ module Irc
     # convenience method to reply "okay" in the current language to the
     # message
     def plainokay
-      self.plainreply @bot.lang.get("okay")
+      self.reply @bot.lang.get("okay"), :nick => false
     end
 
     # Like the above, but append the username
@@ -442,16 +488,13 @@ module Irc
         str.gsub!(/[!,.]$/,"")
         str += ", #{@source}"
       end
-      self.plainreply str
+      self.reply str, :nick => false
     end
 
     # the default okay style is the same as the default reply style
     #
     def okay
-      if @bot.config['core.reply_with_nick']
-        return nickokay
-      end
-      plainokay
+      @bot.config['core.reply_with_nick'] ? nickokay : plainokay
     end
 
     # send a NOTICE to the message source
@@ -583,6 +626,22 @@ module Irc
     end
   end
 
+  # class to manager Ban list replies
+  class BanlistMessage < BasicUserMessage
+    # the bans
+    attr_accessor :bans
+
+    def initialize(bot, server, source, target, message="")
+      super(bot, server, source, target, message)
+      @bans = []
+    end
+
+    def inspect
+      fields = ' bans=' << bans.inspect
+      super(fields)
+    end
+  end
+
   class QuitMessage < BasicUserMessage
     attr_accessor :was_on
     def initialize(bot, server, source, target, message="")
@@ -639,6 +698,18 @@ module Irc
   class PartMessage < JoinMessage
   end
 
+  # class to handle ERR_NOSUCHNICK and ERR_NOSUCHCHANNEL
+  class NoSuchTargetMessage < BasicUserMessage
+    # the channel or nick that was not found
+    attr_reader :target
+
+    def initialize(bot, server, source, target, message='')
+      super(bot, server, source, target, message)
+
+      @target = target
+    end
+  end
+
   class UnknownMessage < BasicUserMessage
   end
 end

data/lib/rbot/messagemapper.rb

@@ -52,6 +52,57 @@ class Bot
   #   {:option => "bar", :otheroption => "baz"}
   # See the #map method for more details.
   class MessageMapper
+
+    class Failure
+      STRING   = "template %{template} failed to recognize message %{message}"
+      FRIENDLY = "I failed to understand the command"
+      attr_reader :template
+      attr_reader :message
+      def initialize(tmpl, msg)
+        @template = tmpl
+        @message = msg
+      end
+
+      def to_s
+        STRING % {
+          :template => template.template,
+          :regexp => template.regexp,
+          :message => message.message,
+          :action => template.options[:action]
+        }
+      end
+    end
+
+    # failures with a friendly message
+    class FriendlyFailure < Failure
+      def friendly
+        self.class::FRIENDLY rescue FRIENDLY
+      end
+    end
+
+    class NotPrivateFailure < FriendlyFailure
+      STRING   = "template %{template} is not configured for private messages"
+      FRIENDLY = "the command must not be given in private"
+    end
+
+    class NotPublicFailure < FriendlyFailure
+      STRING   = "template %{template} is not configured for public messages"
+      FRIENDLY = "the command must not be given in public"
+    end
+
+    class NoMatchFailure < Failure
+      STRING = "%{message} does not match %{template} (%{regex})"
+    end
+
+    class PartialMatchFailure < Failure
+      STRING = "%{message} only matches %{template} (%{regex}) partially"
+    end
+
+    class NoActionFailure < FriendlyFailure
+      STRING   = "%{template} calls undefined action %{action}"
+      FRIENDLY = "uh-ho, somebody forgot to tell me how to do that ..."
+    end
+
     # used to set the method name used as a fallback for unmatched messages.
     # The default fallback is a method called "usage".
     attr_writer :fallback
@@ -144,7 +195,7 @@ class Bot
     # threaded::
     #   a boolean (defaults to false) that determines whether the action should be
     #   called in a separate thread.
-    #   
+    #
     #
     # Further examples:
     #
@@ -194,13 +245,13 @@ class Bot
       return false if @templates.empty?
       failures = []
       @templates.each do |tmpl|
-        options, failure = tmpl.recognize(m)
-        if options.nil?
-          failures << [tmpl, failure]
+        options = tmpl.recognize(m)
+        if options.kind_of? Failure
+          failures << options
         else
           action = tmpl.options[:action]
           unless @parent.respond_to?(action)
-            failures << [tmpl, "class does not respond to action #{action}"]
+            failures << NoActionFailure.new(tmpl, m)
             next
           end
           auth = tmpl.options[:full_auth_path]
@@ -228,13 +279,13 @@ class Bot
           return false
         end
       end
-      failures.each {|f, r|
-        debug "#{f.inspect} => #{r}"
+      failures.each {|r|
+        debug "#{r.template.inspect} => #{r}"
       }
       debug "no handler found, trying fallback"
       if @fallback && @parent.respond_to?(@fallback)
         if m.bot.auth.allow?(@fallback, m.source, m.replyto)
-          @parent.send(@fallback, m, {})
+          @parent.send(@fallback, m, {:failures => failures})
           return true
         end
       end
@@ -333,7 +384,7 @@ class Bot
       mul = multi? ? " multi" : " single"
       opt = optional? ? " optional" : " needed"
       if @regexp
-        reg = " regexp=%s index=%d" % [@regexp, @index]
+        reg = " regexp=%s index=%s" % [@regexp, @index]
       else
         reg = nil
       end
@@ -514,7 +565,9 @@ class Bot
         s = "#{not_needed ? "(?:" : ""}#{whites}(#{sub})#{ not_needed ? ")?" : ""}"
       }
       # debug "Replaced dyns: #{rx.inspect}"
-      rx.gsub!(/((?:\\ )*)\\\[/, "(?:\\1")
+      rx.gsub!(/((?:\\ )*)((?:\\\[)+)/, '\2\1')
+      # debug "Corrected optionals spacing: #{rx.inspect}"
+      rx.gsub!(/\\\[/, "(?:")
       rx.gsub!(/\\\]/, ")?")
       # debug "Delimited optionals: #{rx.inspect}"
       rx.gsub!(/(?:\\ )+/, "\\s+")
@@ -529,20 +582,19 @@ class Bot
 
       debug "Testing #{m.message.inspect} against #{self.inspect}"
 
-      # Early out
-      return nil, "template #{@template} is not configured for private messages" if @options.has_key?(:private) && !@options[:private] && m.private?
-      return nil, "template #{@template} is not configured for public messages" if @options.has_key?(:public) && !@options[:public] && !m.private?
-
-      options = {}
-
       matching = @regexp.match(m.message)
-      return nil, "#{m.message.inspect} doesn't match #{@template} (#{@regexp})" unless matching
-      return nil, "#{m.message.inspect} only matches #{@template} (#{@regexp}) partially: #{matching[0].inspect}" unless matching[0] == m.message
+      return MessageMapper::NoMatchFailure.new(self, m) unless matching
+      return MessageMapper::PartialMatchFailure.new(self, m) unless matching[0] == m.message
+
+      return MessageMapper::NotPrivateFailure.new(self, m) if @options.has_key?(:private) && !@options[:private] && m.private?
+      return MessageMapper::NotPublicFailure.new(self, m) if @options.has_key?(:public) && !@options[:public] && !m.private?
 
       debug_match = matching[1..-1].collect{ |d| d.inspect}.join(', ')
       debug "#{m.message.inspect} matched #{@regexp} with #{debug_match}"
       debug "Associating #{debug_match} with dyn items #{@dyn_items.join(', ')}"
 
+      options = @defaults.dup
+
       @dyn_items.each_with_index { |it, i|
         next if i == 0
         item = it.name
@@ -587,7 +639,7 @@ class Bot
       }
 
       options.delete_if {|k, v| v.nil?} # Remove nil values.
-      return options, nil
+      return options
     end
 
     def inspect

data/lib/rbot/plugins.rb

@@ -10,6 +10,9 @@ class Bot
     Config.register Config::ArrayValue.new('plugins.blacklist',
       :default => [], :wizard => false, :requires_rescan => true,
       :desc => "Plugins that should not be loaded")
+    Config.register Config::ArrayValue.new('plugins.whitelist',
+      :default => [], :wizard => false, :requires_rescan => true,
+      :desc => "Only whitelisted plugins will be loaded unless the list is empty")
 module Plugins
   require 'rbot/messagemapper'
 
@@ -198,7 +201,7 @@ module Plugins
       @priority ||= 1
     end
 
-    # Returns the symbol :BotModule 
+    # Returns the symbol :BotModule
     def botmodule_class
       :BotModule
     end
@@ -318,7 +321,7 @@ module Plugins
     #
     # This command is now superceded by the #map() command, which should be used
     # instead whenever possible.
-    # 
+    #
     def register(cmd, opts={})
       raise ArgumentError, "Second argument must be a hash!" unless opts.kind_of?(Hash)
       who = @manager.who_handles?(cmd)
@@ -338,10 +341,19 @@ module Plugins
     # MessageMapper uses 'usage' as its default fallback method.
     #
     def usage(m, params = {})
+      if params[:failures].respond_to? :find
+        friendly = params[:failures].find do |f|
+          f.kind_of? MessageMapper::FriendlyFailure
+        end
+        if friendly
+          m.reply friendly.friendly
+          return
+        end
+      end
       m.reply(_("incorrect usage, ask for help using '%{command}'") % {:command => "#{@bot.nick}: help #{m.plugin}"})
     end
 
-    # Define the priority of the module.  During event delegation, lower 
+    # Define the priority of the module.  During event delegation, lower
     # priority modules will be called first.  Default priority is 1
     def priority=(prio)
       if @priority != prio
@@ -349,6 +361,20 @@ module Plugins
         @bot.plugins.mark_priorities_dirty
       end
     end
+
+    # Directory name to be joined to the botclass to access data files. By
+    # default this is the plugin name itself, but may be overridden, for
+    # example by plugins that share their datafiles or for backwards
+    # compatibilty
+    def dirname
+      name
+    end
+
+    # Filename for a datafile built joining the botclass, plugin dirname and
+    # actual file name
+    def datafile(*fname)
+      @bot.path dirname, *fname
+    end
   end
 
   # A CoreBotModule is a BotModule that provides core functionality.
@@ -410,7 +436,8 @@ module Plugins
         h[k] = Array.new
       }
 
-      @dirs = []
+      @core_module_dirs = []
+      @plugin_dirs = []
 
       @failed = Array.new
       @ignored = Array.new
@@ -555,10 +582,27 @@ module Plugins
             "#{fname}#{$1}#{$3}"
           }
         }
-        msg = err.to_str.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
+        msg = err.to_s.gsub(/^\(eval\)(:\d+)(:in `.*')?(:.*)?/) { |m|
           "#{fname}#{$1}#{$3}"
         }
-        newerr = err.class.new(msg)
+        begin
+          newerr = err.class.new(msg)
+        rescue ArgumentError => err_in_err
+          # Somebody should hang the ActiveSupport developers by their balls
+          # with barbed wire. Their MissingSourceFile extension to LoadError
+          # _expects_ a second argument, breaking the usual Exception interface
+          # (instead, the smart thing to do would have been to make the second
+          # parameter optional and run the code in the from_message method if
+          # it was missing).
+          # Anyway, we try to cope with this in the simplest possible way. On
+          # the upside, this new block can be extended to handle other similar
+          # idiotic approaches
+          if err.class.respond_to? :from_message
+            newerr = err.class.from_message(msg)
+          else
+            raise err_in_err
+          end
+        end
         newerr.set_backtrace(bt)
         return newerr
       end
@@ -566,42 +610,58 @@ module Plugins
     private :load_botmodule_file
 
     # add one or more directories to the list of directories to
-    # load botmodules from
-    #
-    # 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(', ')}"
+    # load core modules from
+    def add_core_module_dir(*dirlist)
+      @core_module_dirs += dirlist
+      debug "Core module loading paths: #{@core_module_dirs.join(', ')}"
     end
 
-    def clear_botmodule_dirs
-      @dirs.clear
-      debug "Botmodule loading path cleared"
+    # add one or more directories to the list of directories to
+    # load plugins from
+    def add_plugin_dir(*dirlist)
+      @plugin_dirs += dirlist
+      debug "Plugin loading paths: #{@plugin_dirs.join(', ')}"
     end
 
-    # load plugins from pre-assigned list of directories
-    def scan
-      @failed.clear
-      @ignored.clear
-      @delegate_list.clear
+    def clear_botmodule_dirs
+      @core_module_dirs.clear
+      @plugin_dirs.clear
+      debug "Core module and plugin loading paths cleared"
+    end
 
+    def scan_botmodules(opts={})
+      type = opts[:type]
       processed = Hash.new
 
-      @bot.config['plugins.blacklist'].each { |p|
-        pn = p + ".rb"
-        processed[pn.intern] = :blacklisted
-      }
+      case type
+      when :core
+        dirs = @core_module_dirs
+      when :plugins
+        dirs = @plugin_dirs
 
-      dirs = @dirs
-      dirs.each {|dir|
-        if(FileTest.directory?(dir))
-          d = Dir.new(dir)
-          d.sort.each {|file|
+        @bot.config['plugins.blacklist'].each { |p|
+          pn = p + ".rb"
+          processed[pn.intern] = :blacklisted
+        }
 
-            next if(file =~ /^\./)
+        whitelist = @bot.config['plugins.whitelist'].map { |p|
+          p + ".rb"
+        }
+      end
 
-            if processed.has_key?(file.intern)
+      dirs.each do |dir|
+        next unless FileTest.directory?(dir)
+        d = Dir.new(dir)
+        d.sort.each do |file|
+          next unless file =~ /\.rb$/
+          next if file =~ /^\./
+
+          case type
+          when :plugins
+            if !whitelist.empty? && !whitelist.include?(file)
+              @ignored << {:name => file, :dir => dir, :reason => :"not whitelisted" }
+              next
+            elsif processed.has_key?(file.intern)
               @ignored << {:name => file, :dir => dir, :reason => processed[file.intern]}
               next
             end
@@ -615,20 +675,28 @@ module Plugins
               @ignored << {:name => $1, :dir => dir, :reason => processed[$1.intern]}
               next
             end
+          end
+
+          did_it = load_botmodule_file("#{dir}/#{file}", "plugin")
+          case did_it
+          when Symbol
+            processed[file.intern] = did_it
+          when Exception
+            @failed << { :name => file, :dir => dir, :reason => did_it }
+          end
+        end
+      end
+    end
 
-            next unless(file =~ /\.rb$/)
+    # load plugins from pre-assigned list of directories
+    def scan
+      @failed.clear
+      @ignored.clear
+      @delegate_list.clear
 
-            did_it = load_botmodule_file("#{dir}/#{file}", "plugin")
-            case did_it
-            when Symbol
-              processed[file.intern] = did_it
-            when Exception
-              @failed <<  { :name => file, :dir => dir, :reason => did_it }
-            end
+      scan_botmodules(:type => :core)
+      scan_botmodules(:type => :plugins)
 
-          }
-        end
-      }
       debug "finished loading plugins: #{status(true)}"
       (core_modules + plugins).each { |p|
        p.methods.grep(DEFAULT_DELEGATE_PATTERNS).each { |m|
@@ -798,7 +866,7 @@ module Plugins
     end
 
     def sort_modules
-      @sorted_modules = (core_modules + plugins).sort do |a, b| 
+      @sorted_modules = (core_modules + plugins).sort do |a, b|
         a.priority <=> b.priority
       end || []