rbot 0.9.10 → 0.9.12

data/lib/rbot/language.rb

@@ -1,9 +1,64 @@
-module Irc
-module Language
+#-- vim:sw=2:et
+#++
+#
+# :title: Language module for rbot
+#
+# This module takes care of language handling for rbot:
+# setting the core.language value, loading the appropriate
+# .lang file etc.
 
+module Irc
+class Bot
   class Language
-    BotConfig.register BotConfigEnumValue.new('core.language', 
-      :default => "english", :wizard => true,
+
+    # This constant hash holds the mapping
+    # from long language names to the usual POSIX
+    # locale specifications
+    Lang2Locale = {
+      :english  => 'en',
+      :british_english  => 'en_GB',
+      :american_english  => 'en_US',
+      :italian  => 'it',
+      :french   => 'fr',
+      :german   => 'de',
+      :dutch    => 'nl',
+      :japanese => 'ja',
+      :russian  => 'ru',
+      :traditional_chinese => 'zh_TW',
+      :simplified_chinese => 'zh_CN'
+    }
+    # On WIN32 it appears necessary to have ".UTF-8" explicitly for gettext to use UTF-8
+    Lang2Locale.each_value {|v| v.replace(v + '.UTF-8')}
+
+    # Return the shortest language for the current
+    # GetText locale
+    def Language.from_locale
+      return 'english' unless defined?(GetText)
+      lang = locale.language
+      if locale.country
+        str = lang + "_#{locale.country}"
+        if Lang2Locale.value?(str)
+          # Get the shortest key in Lang2Locale which maps to the given lang_country
+          lang_str = Lang2Locale.select { |k, v| v == str }.transpose.first.map { |v| v.to_s }.sort { |a, b| a.length <=> b.length }.first
+          if File.exist?(File.join(Config::datadir, "languages/#{lang_str}.lang"))
+            return lang_str
+          end
+        end
+      end
+      # lang_country didn't work, let's try lan
+      if Lang2Locale.value?(lang)
+        # Get the shortest key in Lang2Locale which maps to the given lang
+        lang_str = Lang2Locale.select { |k, v| v == lang }.transpose.first.map { |v| v.to_s }.sort { |a, b| a.length <=> b.length }.first
+        if File.exist?(File.join(Config::datadir, "/languages/#{lang_str}.lang"))
+          return lang_str
+        end
+      end
+      # all else fail, return 'english'
+      return 'english'
+    end
+
+    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
@@ -12,18 +67,41 @@ module Language
       :on_change => Proc.new {|bot, v| bot.lang.set_language v},
       :desc => "Which language file the bot should use")
     
-    def initialize(language)
+    def initialize(bot, language)
+      @bot = bot
       set_language language
     end
+    attr_reader :language
 
     def set_language(language)
-      file = Config::datadir + "/languages/#{language}.lang"
+      lang_str = language.to_s.downcase.gsub(/\s+/,'_')
+      lang_sym = lang_str.intern
+      if defined?(GetText) and Lang2Locale.key?(lang_sym)
+        setlocale(Lang2Locale[lang_sym])
+        debug "locale set to #{locale}"
+        rbot_gettext_debug
+      else
+        warning "Unable to set locale, unknown language #{language} (#{lang_str})"
+      end
+
+      file = Config::datadir + "/languages/#{lang_str}.lang"
       unless(FileTest.exist?(file))
-        raise "no such language: #{language} (no such file #{file})"
+        raise "no such language: #{lang_str} (no such file #{file})"
       end
-      @language = language
+      @language = lang_str
       @file = file
       scan
+      return if @bot.plugins.nil?
+      @bot.plugins.core_modules.each { |p|
+        if p.respond_to?('set_language')
+          p.set_language(@language)
+        end
+      }
+      @bot.plugins.plugins.each { |p|
+        if p.respond_to?('set_language')
+          p.set_language(@language)
+        end
+      }
     end
 
     def scan

data/lib/rbot/load-gettext.rb

@@ -0,0 +1,154 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: GetText interface for rbot
+#
+# Load gettext module and provide fallback in case of failure
+
+class GetTextVersionError < Exception
+end
+
+# try to load gettext, or provide fake getttext functions
+begin
+  require 'gettext/version'
+
+  gettext_version = GetText::VERSION.split('.').map {|n| n.to_i}
+  include Comparable # for Array#>=
+  unless gettext_version >= [1, 8, 0]
+    raise GetTextVersionError, "Unsupported ruby-gettext version installed: #{gettext_version.join '.'}; supported versions are 1.8.0 and above"
+  end
+
+  require 'gettext'
+
+  include GetText
+
+  add_default_locale_path(File.join(Irc::Bot::Config.datadir, "../locale/%{locale}/LC_MESSAGES/%{name}.mo"))
+
+  if GetText.respond_to? :cached=
+    GetText.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')
+      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
+    end
+
+    require 'stringio'
+
+    # This method is used to output debug information on the GetText
+    # textdomain, and it's called by the language setting routines
+    # in rbot
+    def rbot_gettext_debug
+      begin
+        gettext_info = StringIO.new
+        current_textdomain_info(:out => gettext_info) # fails sometimes
+      rescue Exception
+        warning "gettext failed to set call textdomain info. maybe an mo file doesn't exist for your locale."
+      ensure
+        gettext_info.string.each_line { |l| debug l}
+      end
+    end
+  end
+
+  log "gettext loaded"
+
+rescue LoadError, GetTextVersionError
+  warning "failed to load ruby-gettext package: #{$!}; translations are disabled"
+
+  # undefine GetText, in case it got defined because the error was caused by a
+  # wrong version
+  if defined?(GetText)
+    Object.module_eval { remove_const("GetText") }
+  end
+
+  # dummy functions that return msg_id without translation
+  def _(s)
+    s
+  end
+
+  def N_(s)
+    s
+  end
+
+  def n_(s_single, s_plural, n)
+    n > 1 ? s_plural : s_single
+  end
+
+  def Nn_(s_single, s_plural)
+    n_(s_single, s_plural)
+  end
+
+  def s_(*args)
+    args[0]
+  end
+
+  def bindtextdomain_to(*args)
+  end
+
+  # the following extension to String#% is from ruby-gettext's string.rb file.
+  # it needs to be included in the fallback since the source already use this form
+
+=begin
+  string.rb - Extension for String.
+
+  Copyright (C) 2005,2006 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+  # Extension for String class.
+  #
+  # String#% method which accept "named argument". The translator can know
+  # the meaning of the msgids using "named argument" instead of %s/%d style.
+  class String
+    alias :_old_format_m :% # :nodoc:
+
+    # call-seq:
+    #  %(arg)
+    #  %(hash)
+    #
+    # Format - Uses str as a format specification, and returns the result of applying it to arg.
+    # If the format specification contains more than one substitution, then arg must be
+    # an Array containing the values to be substituted. See Kernel::sprintf for details of the
+    # format string. This is the default behavior of the String class.
+    # * arg: an Array or other class except Hash.
+    # * Returns: formatted String
+    #
+    #  (e.g.) "%s, %s" % ["Masao", "Mutoh"]
+    #
+    # Also you can use a Hash as the "named argument". This is recommanded way for Ruby-GetText
+    # because the translators can understand the meanings of the msgids easily.
+    # * hash: {:key1 => value1, :key2 => value2, ... }
+    # * Returns: formatted String
+    #
+    #  (e.g.) "%{firstname}, %{familyname}" % {:firstname => "Masao", :familyname => "Mutoh"}
+    def %(args)
+      if args.kind_of?(Hash)
+        ret = dup
+        args.each {|key, value|
+          ret.gsub!(/\%\{#{key}\}/, value.to_s)
+        }
+        ret
+      else
+        ret = gsub(/%\{/, '%%{')
+        begin
+    ret._old_format_m(args)
+        rescue ArgumentError
+    $stderr.puts "  The string:#{ret}"
+    $stderr.puts "  args:#{args.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/rbot/maskdb.rb

@@ -0,0 +1,162 @@
+module Irc
+  class NetmaskDb
+    # helper backend class: generic nested radix tree
+    class Tree
+      attr_reader :pre, :chi
+
+      def initialize(pre = '', chi = Hash.new)
+        @pre = pre
+        @chi = chi
+      end
+
+      def add(val, *prefs)
+        str = prefs.shift or raise 'empty prefs'
+        @pre = str.dup if @chi.empty?
+
+        n = 0
+        @pre.size.times do
+          break if @pre[n] != str[n]
+          n += 1
+        end
+
+        rest = str.slice(n .. -1)
+
+        if n != @pre.size
+          prest = @pre.slice!(n .. -1)
+          pc = prest.slice! 0
+          @chi = {pc => Tree.new(prest, @chi)}
+        end
+
+        c = rest.slice!(0)
+
+        if c
+          (@chi[c] ||= Tree.new).add(val, rest, *prefs)
+        else
+          if prefs.empty?
+            (@chi[''] ||= Array.new).push val
+          else
+            (@chi[''] ||= Tree.new).add(val, *prefs)
+          end
+        end
+      end
+
+      def empty?
+        @chi.empty?
+      end
+
+      def remove(*prefs, &block)
+        str = prefs.shift or raise 'empty prefs?'
+        return nil unless @pre.empty? or str.index(@pre) == 0
+        c = str.slice(@pre.size) || ''
+        return nil unless @chi.include? c
+        if c == ''
+          if prefs.empty?
+            @chi[c].reject!(&block)
+          else
+            @chi[c].remove(*prefs, &block)
+          end
+        else
+          @chi[c].remove(str.slice((@pre.size + 1) .. -1), *prefs, &block)
+        end
+        @chi.delete(c) if @chi[c].empty?
+
+        if @chi.size == 1
+          k = @chi.keys.shift
+          return nil if k == ''
+          @pre << k << @chi[k].pre
+          @chi = @chi[k].chi
+        end
+      end
+
+      def find(*prefs)
+        str = prefs.shift or raise 'empty prefs?'
+        self.find_helper(str, *prefs) + self.find_helper(str.reverse, *prefs)
+      end
+
+      protected
+      def find_helper(*prefs)
+        str = prefs.shift or raise 'empty prefs?'
+        return [] unless @pre.empty? or str.index(@pre) == 0
+        # puts "#{self.inspect}: #{str} == #{@pre} pfx matched"
+        if !@chi.include? ''
+          matches = []
+        elsif Array === @chi['']
+          matches = @chi['']
+        else
+          matches = @chi[''].find(*prefs)
+        end
+
+        c = str.slice(@pre.size)
+
+        more = []
+        if c and @chi.include?(c)
+          more = @chi[c].find_helper(str.slice((@pre.size + 1) .. -1), *prefs)
+        end
+        return more + matches
+      end
+    end
+
+    # api wrapper for netmasks
+
+    def initialize
+      @tree = Tree.new
+    end
+
+    def cook_component(str)
+      s = (str && !str.empty?) ? str : '*'
+      l = s.index(/[\?\*]/)
+      if l
+        l2 = s.size - s.rindex(/[\?\*]/) - 1
+        if l2 > l
+          s = s.reverse
+          l = l2
+        end
+
+        return (l > 0) ? s.slice(0 .. (l - 1)) : ''
+      else
+        return s
+      end
+    end
+
+    def mask2keys(m)
+      md = m.downcased
+      [md.host, md.user, md.nick].map { |c| cook_component(c) }
+    end
+
+    def add(user, *masks)
+      masks.each do |m|
+        debug "adding user #{user} with mask #{m.fullform}"
+        @tree.add([user, m], *mask2keys(m))
+      end
+    end
+
+    def remove(user, mask)
+      debug "trying to remove user #{user} with mask #{mask}"
+      @tree.remove(*mask2keys(mask)) do |val|
+        val[0] == user and val[1].fullform == mask.fullform
+      end
+    end
+
+    def metric(iu, bu, mask)
+      ret = nil
+      if iu.matches? mask
+        ret = iu.fullform.length - mask.fullform.length
+        ret += 10 if bu.transient?
+      end
+      return ret
+    end
+
+    def find(iu)
+      debug "find(#{iu.fullform})"
+      iud = iu.downcased
+      matches = @tree.find(iud.host, iud.user, iud.nick).uniq.map do |val|
+        m = metric(iu, *val)
+        m ? [val[0], m] : nil
+      end.compact.sort { |a, b| a[1] <=> a[1] }
+      debug "matches: " + (matches.map do |m|
+        "#{m[0].username}: [#{m[1]}]"
+      end.join(', '))
+      return matches.empty? ? nil : matches[0][0]
+    end
+  end
+end

data/lib/rbot/message.rb

@@ -1,13 +1,106 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: IRC message datastructures
+
 module Irc
-  BotConfig.register BotConfigArrayValue.new('core.address_prefix',
-    :default => [], :wizard => true,
-    :desc => "what non nick-matching prefixes should the bot respond to as if addressed (e.g !, so that '!foo' is treated like 'rbot: foo')"
-  )
 
-  Color = "\003"
+
+  class Bot
+    module Config
+      Config.register ArrayValue.new('core.address_prefix',
+        :default => [], :wizard => true,
+        :desc => "what non nick-matching prefixes should the bot respond to as if addressed (e.g !, so that '!foo' is treated like 'rbot: foo')"
+      )
+
+      Config.register BooleanValue.new('core.reply_with_nick',
+        :default => false, :wizard => true,
+        :desc => "if true, the bot will prepend the nick to what he has to say when replying (e.g. 'markey: you can't do that!')"
+      )
+
+      Config.register StringValue.new('core.nick_postfix',
+        :default => ':', :wizard => true,
+        :desc => "when replying with nick put this character after the nick of the user the bot is replying to"
+      )
+    end
+  end
+
+
+  # Define standard IRC attriubtes (not so standard actually,
+  # but the closest thing we have ...)
   Bold = "\002"
   Underline = "\037"
   Reverse = "\026"
+  Italic = "\011"
+  NormalText = "\017"
+  AttributeRx = /#{Bold}|#{Underline}|#{Reverse}|#{Italic}|#{NormalText}/
+
+  # Color is prefixed by \003 and followed by optional
+  # foreground and background specifications, two-digits-max
+  # numbers separated by a comma. One of the two parts
+  # must be present.
+  Color = "\003"
+  ColorRx = /#{Color}\d?\d?(?:,\d\d?)?/
+
+  FormattingRx = /#{AttributeRx}|#{ColorRx}/
+
+  # Standard color codes
+  ColorCode = {
+    :black      => 1,
+    :blue       => 2,
+    :navyblue   => 2,
+    :navy_blue  => 2,
+    :green      => 3,
+    :red        => 4,
+    :brown      => 5,
+    :purple     => 6,
+    :olive      => 7,
+    :yellow     => 8,
+    :limegreen  => 9,
+    :lime_green => 9,
+    :teal       => 10,
+    :aqualight  => 11,
+    :aqua_light => 11,
+    :royal_blue => 12,
+    :hotpink    => 13,
+    :hot_pink   => 13,
+    :darkgray   => 14,
+    :dark_gray  => 14,
+    :lightgray  => 15,
+    :light_gray => 15,
+    :white      => 16
+  }
+
+  # Convert a String or Symbol into a color number
+  def Irc.find_color(data)
+    "%02d" % if Integer === data
+      data
+    else
+      f = if String === data
+            data.intern
+          else
+            data
+          end
+      if ColorCode.key?(f)
+        ColorCode[f] 
+      else
+        0
+      end
+    end
+  end
+
+  # Insert the full color code for a given
+  # foreground/background combination.
+  def Irc.color(fg=nil,bg=nil)
+    str = Color.dup
+    if fg
+     str << Irc.find_color(fg)
+    end
+    if bg
+      str << "," << Irc.find_color(bg)
+    end
+    return str
+  end
 
   # base user message class, all user messages derive from this
   # (a user message is defined as having a source hostmask, a target
@@ -17,33 +110,65 @@ module Irc
     # associated bot
     attr_reader :bot
 
+    # associated server
+    attr_reader :server
+
     # when the message was received
     attr_reader :time
 
-    # hostmask of message source
+    # User that originated the message
     attr_reader :source
 
-    # nick of message source
-    attr_reader :sourcenick
-
-    # url part of message source
-    attr_reader :sourceaddress
-
-    # nick/channel message was sent to
+    # User/Channel message was sent to
     attr_reader :target
 
-    # contents of the message
+    # contents of the message (stripped of initial/final format codes)
     attr_accessor :message
 
+    # contents of the message (for logging purposes)
+    attr_accessor :logmessage
+
+    # contents of the message (stripped of all formatting)
+    attr_accessor :plainmessage
+
     # has the message been replied to/handled by a plugin?
     attr_accessor :replied
+    alias :replied? :replied
+
+    # should the message be ignored?
+    attr_accessor :ignored
+    alias :ignored? :ignored
+
+    # set this to true if the method that delegates the message is run in a thread
+    attr_accessor :in_thread
+    alias :in_thread? :in_thread
+
+    def inspect(fields=nil)
+      ret = self.__to_s__[0..-2]
+      ret << ' bot=' << @bot.__to_s__
+      ret << ' server=' << server.to_s
+      ret << ' time=' << time.to_s
+      ret << ' source=' << source.to_s
+      ret << ' target=' << target.to_s
+      ret << ' message=' << message.inspect
+      ret << ' logmessage=' << logmessage.inspect
+      ret << ' plainmessage=' << plainmessage.inspect
+      ret << fields if fields
+      ret << ' (identified)' if identified?
+      ret << ' (addressed to me)' if address?
+      ret << ' (replied)' if replied?
+      ret << ' (ignored)' if ignored?
+      ret << ' (in thread)' if in_thread?
+      ret << '>'
+    end
 
     # instantiate a new Message
     # bot::      associated bot class
-    # source::   hostmask of the message source
-    # target::   nick/channel message is destined for
-    # message::  message part
-    def initialize(bot, source, target, message)
+    # server::   Server where the message took place
+    # source::   User that sent the message
+    # target::   User/Channel is destined for
+    # message::  actual message
+    def initialize(bot, server, source, target, message)
       @msg_wants_id = false unless defined? @msg_wants_id
 
       @time = Time.now
@@ -51,31 +176,51 @@ module Irc
       @source = source
       @address = false
       @target = target
-      @message = BasicUserMessage.stripcolour message
+      @message = message || ""
       @replied = false
+      @server = server
+      @ignored = false
+      @in_thread = false
 
       @identified = false
-      if @msg_wants_id && @bot.capabilities["identify-msg".to_sym]
-        if @message =~ /([-+])(.*)/
+      if @msg_wants_id && @server.capabilities[:"identify-msg"]
+        if @message =~ /^([-+])(.*)/
           @identified = ($1=="+")
           @message = $2
         else
           warning "Message does not have identification"
         end
       end
+      @logmessage = @message.dup
+      @plainmessage = BasicUserMessage.strip_formatting(@message)
+      @message = BasicUserMessage.strip_initial_formatting(@message)
 
-      # split source into consituent parts
-      if source =~ /^((\S+)!(\S+))$/
-        @sourcenick = $2
-        @sourceaddress = $3
-      end
-
-      if target && target.downcase == @bot.nick.downcase
+      if target && target == @bot.myself
         @address = true
       end
 
     end
 
+    # Access the nick of the source
+    #
+    def sourcenick
+      @source.nick rescue @source.to_s
+    end
+
+    # Access the user@host of the source
+    #
+    def sourceaddress
+      "#{@source.user}@#{@source.host}" rescue @source.to_s
+    end
+
+    # Access the botuser corresponding to the source, if any
+    #
+    def botuser
+      source.botuser rescue @bot.auth.everyone
+    end
+
+
+    # Was the message from an identified user?
     def identified?
       return @identified
     end
@@ -88,19 +233,32 @@ module Irc
       return @address
     end
 
-    # has this message been replied to by a plugin?
-    def replied?
-      return @replied
-    end
-
     # strip mIRC colour escapes from a string
     def BasicUserMessage.stripcolour(string)
       return "" unless string
-      ret = string.gsub(/\cC\d\d?(?:,\d\d?)?/, "")
+      ret = string.gsub(ColorRx, "")
       #ret.tr!("\x00-\x1f", "")
       ret
     end
 
+    def BasicUserMessage.strip_initial_formatting(string)
+      return "" unless string
+      ret = string.gsub(/^#{FormattingRx}|#{FormattingRx}$/,"")
+    end
+
+    def BasicUserMessage.strip_formatting(string)
+      string.gsub(FormattingRx,"")
+    end
+
+  end
+
+  # class for handling welcome messages from the server
+  class WelcomeMessage < BasicUserMessage
+  end
+
+  # class for handling MOTD from the server. Yes, MotdMessage
+  # is somewhat redundant, but it fits with the naming scheme
+  class MotdMessage < BasicUserMessage
   end
 
   # class for handling IRC user messages. Includes some utilities for handling
@@ -109,6 +267,24 @@ module Irc
   # (address? will return true in this case)
   class UserMessage < BasicUserMessage
 
+    def inspect
+      fields = ' plugin=' << plugin.inspect
+      fields << ' params=' << params.inspect
+      fields << ' channel=' << channel.to_s if channel
+      fields << ' (reply to ' << replyto.to_s << ')'
+      if self.private?
+        fields << ' (private)'
+      else
+        fields << ' (public)'
+      end
+      if self.action?
+        fields << ' (action)'
+      elsif ctcp
+        fields << ' (CTCP ' << ctcp << ')'
+      end
+      super(fields)
+    end
+
     # for plugin messages, the name of the plugin invoked by the message
     attr_reader :plugin
 
@@ -124,6 +300,12 @@ module Irc
     # channel the message was in, nil for privately addressed messages
     attr_reader :channel
 
+    # for PRIVMSGs, false unless the message was a CTCP command,
+    # in which case it evaluates to the CTCP command itself
+    # (TIME, PING, VERSION, etc). The CTCP command parameters
+    # are then stored in the message.
+    attr_reader :ctcp
+
     # for PRIVMSGs, true if the message was a CTCP ACTION (CTCP stuff
     # will be stripped from the message)
     attr_reader :action
@@ -133,18 +315,19 @@ module Irc
     # source::   hostmask of the message source
     # target::   nick/channel message is destined for
     # message::  message part
-    def initialize(bot, source, target, message)
-      super(bot, source, target, message)
+    def initialize(bot, server, source, target, message)
+      super(bot, server, source, target, message)
       @target = target
       @private = false
       @plugin = nil
+      @ctcp = false
       @action = false
 
-      if target.downcase == @bot.nick.downcase
+      if target == @bot.myself
         @private = true
         @address = true
         @channel = nil
-        @replyto = @sourcenick
+        @replyto = source
       else
         @replyto = @target
         @channel = @target
@@ -166,14 +349,20 @@ module Irc
         @address = true
       end
 
-      if(@message =~ /^\001ACTION\s(.+)\001/)
-        @message = $1
-        @action = true
+      if(@message =~ /^\001(\S+)(\s(.+))?\001/)
+        @ctcp = $1
+	# FIXME need to support quoting of NULL and CR/LF, see
+	# http://www.irchelp.org/irchelp/rfc/ctcpspec.html
+        @message = $3 || String.new
+        @action = @ctcp == 'ACTION'
+        debug "Received CTCP command #{@ctcp} with options #{@message} (action? #{@action})"
+        @logmessage = @message.dup
       end
 
       # free splitting for plugins
       @params = @message.dup
-      if @params.gsub!(/^\s*(\S+)[\s$]*/, "")
+      # Created messges (such as by fake_message) can contain multiple lines
+      if @params.gsub!(/\A\s*(\S+)[\s$]*/m, "")
         @plugin = $1.downcase
         @params = nil unless @params.length > 0
       end
@@ -198,42 +387,92 @@ module Irc
     # <tt>@bot.say m.replyto, string</tt>
     # 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 reply(string)
-      @bot.say @replyto, string
+    def plainreply(string, options={})
+      @bot.say @replyto, string, options
       @replied = true
     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
+    end
+
+    # the default reply style is to nickreply unless the reply already contains
+    # the nick or core.reply_with_nick is set to false
+    #
+    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)
+      end
+      plainreply(string, options)
+    end
+
     # convenience method to reply to a message with an action. It's the
     # same as doing:
     # <tt>@bot.action m.replyto, string</tt>
     # 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 act(string)
-      @bot.action @replyto, string
+    def act(string, options={})
+      @bot.action @replyto, string, options
       @replied = true
     end
 
+    # send a CTCP response, i.e. a private NOTICE to the sender
+    # with the same CTCP command and the reply as a parameter
+    def ctcp_reply(string, options={})
+      @bot.ctcp_notice @source, @ctcp, string, options
+    end
+
     # convenience method to reply "okay" in the current language to the
     # message
+    def plainokay
+      self.plainreply @bot.lang.get("okay")
+    end
+
+    # Like the above, but append the username
+    def nickokay
+      str = @bot.lang.get("okay").dup
+      if self.public?
+        # remove final punctuation
+        str.gsub!(/[!,.]$/,"")
+        str += ", #{@source}"
+      end
+      self.plainreply str
+    end
+
+    # the default okay style is the same as the default reply style
+    #
     def okay
-      @bot.say @replyto, @bot.lang.get("okay")
+      if @bot.config['core.reply_with_nick']
+        return nickokay
+      end
+      plainokay
+    end
+
+    # send a NOTICE to the message source
+    #
+    def notify(msg,opts={})
+      @bot.notice(sourcenick, msg, opts)
     end
 
   end
 
   # class to manage IRC PRIVMSGs
   class PrivMessage < UserMessage
-    def initialize(bot, source, target, message)
-      @msg_wants_id = true
-      super
+    def initialize(bot, server, source, target, message, opts={})
+      @msg_wants_id = opts[:handle_id]
+      super(bot, server, source, target, message)
     end
   end
 
   # class to manage IRC NOTICEs
   class NoticeMessage < UserMessage
-    def initialize(bot, source, target, message)
-      @msg_wants_id = true
-      super
+    def initialize(bot, server, source, target, message, opts={})
+      @msg_wants_id = opts[:handle_id]
+      super(bot, server, source, target, message)
     end
   end
 
@@ -244,8 +483,31 @@ module Irc
     # channel user was kicked from
     attr_reader :channel
 
-    def initialize(bot, source, target, channel, message="")
-      super(bot, source, target, message)
+    def inspect
+      fields = ' channel=' << channel.to_s
+      super(fields)
+    end
+
+    def initialize(bot, server, source, target, channel, message="")
+      super(bot, server, source, target, message)
+      @channel = channel
+    end
+  end
+
+  # class to manage IRC INVITEs
+  # +address?+ can be used as a shortcut to see if the bot was invited,
+  # which should be true except for server bugs
+  class InviteMessage < BasicUserMessage
+    # channel user was invited to
+    attr_reader :channel
+
+    def inspect
+      fields = ' channel=' << channel.to_s
+      super(fields)
+    end
+
+    def initialize(bot, server, source, target, channel, message="")
+      super(bot, server, source, target, message)
       @channel = channel
     end
   end
@@ -253,14 +515,61 @@ module Irc
   # class to pass IRC Nick changes in. @message contains the old nickame,
   # @sourcenick contains the new one.
   class NickMessage < BasicUserMessage
-    def initialize(bot, source, oldnick, newnick)
-      super(bot, source, oldnick, newnick)
+    attr_accessor :is_on
+    def initialize(bot, server, source, oldnick, newnick)
+      super(bot, server, source, oldnick, newnick)
+      @is_on = []
+    end
+
+    def oldnick
+      return @target
+    end
+
+    def newnick
+      return @message
+    end
+
+    def inspect
+      fields = ' old=' << oldnick
+      fields << ' new=' << newnick
+      super(fields)
+    end
+  end
+
+  # class to manage mode changes
+  class ModeChangeMessage < BasicUserMessage
+    attr_accessor :modes
+    def initialize(bot, server, source, target, message="")
+      super(bot, server, source, target, message)
+      @address = (source == @bot.myself)
+      @modes = []
+    end
+
+    def inspect
+      fields = ' modes=' << modes.inspect
+      super(fields)
+    end
+  end
+
+  # class to manage NAME replies
+  class NamesMessage < BasicUserMessage
+    attr_accessor :users
+    def initialize(bot, server, source, target, message="")
+      super(bot, server, source, target, message)
+      @users = []
+    end
+
+    def inspect
+      fields = ' users=' << users.inspect
+      super(fields)
     end
   end
 
   class QuitMessage < BasicUserMessage
-    def initialize(bot, source, target, message="")
-      super(bot, source, target, message)
+    attr_accessor :was_on
+    def initialize(bot, server, source, target, message="")
+      super(bot, server, source, target, message)
+      @was_on = []
     end
   end
 
@@ -272,11 +581,20 @@ module Irc
     # topic set on channel
     attr_reader :channel
 
-    def initialize(bot, source, channel, timestamp, topic="")
-      super(bot, source, channel, topic)
+    # :info if topic info, :set if topic set
+    attr_accessor :info_or_set
+    def initialize(bot, server, source, channel, topic=ChannelTopic.new)
+      super(bot, server, source, channel, topic.text)
       @topic = topic
-      @timestamp = timestamp
+      @timestamp = topic.set_on
       @channel = channel
+      @info_or_set = nil
+    end
+
+    def inspect
+      fields = ' topic=' << topic
+      fields << ' (set on ' << timestamp << ')'
+      super(fields)
     end
   end
 
@@ -284,11 +602,17 @@ module Irc
   class JoinMessage < BasicUserMessage
     # channel joined
     attr_reader :channel
-    def initialize(bot, source, channel, message="")
-      super(bot, source, channel, message)
+
+    def inspect
+      fields = ' channel=' << channel.to_s
+      super(fields)
+    end
+
+    def initialize(bot, server, source, channel, message="")
+      super(bot, server, source, channel, message)
       @channel = channel
       # in this case sourcenick is the nick that could be the bot
-      @address = (sourcenick.downcase == @bot.nick.downcase)
+      @address = (source == @bot.myself)
     end
   end
 
@@ -296,4 +620,7 @@ module Irc
   # same as a join, but can have a message too
   class PartMessage < JoinMessage
   end
+
+  class UnknownMessage < BasicUserMessage
+  end
 end