rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/linkbot.rb

@@ -0,0 +1,75 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: linkbot management for rbot
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+# Copyright:: (C) 2006 Giuseppe Bilotta
+# License:: GPL v2
+#
+# Based on an idea by hagabaka (Yaohan Chen <yaohan.chen@gmail.com>)
+#
+# This plugin is used to grab messages from eggdrops (or other bots) that link
+# channels from different networks. For the time being, a PRIVMSG echoed by an
+# eggdrop is assumed to be in the form:
+#    <eggdrop> (nick@network) text of the message
+# and it's fed back to the message delegators.
+#
+# This plugin also shows how to create 'fake' messages from a plugin, letting
+# the bot parse them.
+#
+# TODO a possible enhancement to the Irc framework could be to create 'fake'
+# servers to make this even easier.
+
+class LinkBot < Plugin
+  Config.register Config::ArrayValue.new('linkbot.nicks',
+    :default => [],
+    :desc => "Nick(s) of the bots that act as channel links across networks")
+
+  Config.register Config::ArrayValue.new('linkbot.message_patterns',
+    :default => ['^<(\S+?)@(\S+?)>\s+(.*)$', '^\((\S+?)@(\S+?)\)\s+(.*)$'],
+    :desc => "List of regexp which match linkbot messages; each regexp needs to have three captures, which in order are the nickname of the original speaker, network, and original message",
+    :on_change => proc {|bot, v| bot.plugins['linkbot'].update_patterns})
+  # TODO use template strings instead of regexp for user friendliness
+  
+  # Initialize the plugin
+  def initialize
+    super
+    update_patterns
+  end
+
+  def update_patterns
+    @message_patterns = @bot.config['linkbot.message_patterns'].map {|p|
+      Regexp.new(p)
+    }
+  end
+
+  # Main method
+  def message(m)
+    linkbots = @bot.config['linkbot.nicks']
+    return if linkbots.empty?
+    return unless linkbots.include?(m.sourcenick)
+    # Now we know that _m_ is a PRIVMSG from a linkbot. Let's split it
+    # in nick, network, message
+    if @message_patterns.any? {|p| m.message =~ p}
+      # if the regexp doesn't contain all parts, the default values get used
+      new_nick = $1 || 'unknown_nick'
+      network = $2 || 'unknown_network'
+      message = $3 || 'unknown_message'
+      # strip any formatting codes in the new_nick. some people configure their linkbots
+      # to embed these codes in nicknames (such as to\B\Bm), to avoid triggering the
+      # person's highlight
+      new_nick.gsub!(/[#{Bold}#{Underline}#{Reverse}#{Italic}#{NormalText}]/, '')
+      debug "#{m.sourcenick} reports that #{new_nick} said #{message.inspect} on #{network}"
+      begin
+        # Pass the new message back to the bot
+        fake_message(message, :from => m, :source => m.server.user(new_nick))
+      rescue RecurseTooDeep => e
+        error e
+      end
+    end
+  end
+end
+
+plugin = LinkBot.new
+

data/data/rbot/plugins/markov.rb

@@ -1,13 +1,65 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Markov plugin
+#
+# Author:: Tom Gilbert <tom@linuxbrit.co.uk>
+# Copyright:: (C) 2005 Tom Gilbert
+#
+# Contribute to chat with random phrases built from word sequences learned
+# by listening to chat
+
 class MarkovPlugin < Plugin
+  Config.register Config::BooleanValue.new('markov.enabled',
+    :default => false,
+    :desc => "Enable and disable the plugin")
+  Config.register Config::IntegerValue.new('markov.probability',
+    :default => 25,
+    :validate => Proc.new { |v| (0..100).include? v },
+    :desc => "Percentage chance of markov plugin chipping in")
+  Config.register Config::ArrayValue.new('markov.ignore',
+    :default => [],
+    :desc => "Hostmasks and channel names markov should NOT learn from (e.g. idiot*!*@*, #privchan).")
+  Config.register Config::IntegerValue.new('markov.max_words',
+    :default => 50,
+    :validate => Proc.new { |v| (0..100).include? v },
+    :desc => "Maximum number of words the bot should put in a sentence")
+
   def initialize
     super
     @registry.set_default([])
-    @registry['enabled'] = false unless @registry.has_key?('enabled')
-    @lastline = false
+    if @registry.has_key?('enabled')
+      @bot.config['markov.enabled'] = @registry['enabled']
+      @registry.delete('enabled')
+    end
+    if @registry.has_key?('probability')
+      @bot.config['markov.probability'] = @registry['probability']
+      @registry.delete('probability')
+    end
+    if @bot.config['markov.ignore_users']
+      debug "moving markov.ignore_users to markov.ignore"
+      @bot.config['markov.ignore'] = @bot.config['markov.ignore_users'].dup
+      @bot.config.delete('markov.ignore_users'.to_sym)
+    end
+    @learning_queue = Queue.new
+    @learning_thread = Thread.new do
+      while s = @learning_queue.pop
+        learn s
+        sleep 0.5
+      end
+    end
+    @learning_thread.priority = -1
+  end
+
+  def cleanup
+    debug 'closing learning thread'
+    @learning_queue.push nil
+    @learning_thread.join
+    debug 'learning thread closed'
   end
 
   def generate_string(word1, word2)
-    # limit to max of 50 words
+    # limit to max of markov.max_words words
     output = word1 + " " + word2
 
     # try to avoid :nonword in the first iteration
@@ -19,7 +71,7 @@ class MarkovPlugin < Plugin
       word1, word2 = word2, word3
     end
 
-    49.times do
+    (@bot.config['markov.max_words'] - 1).times do
       wordlist = @registry["#{word1} #{word2}"]
       break if wordlist.empty?
       word3 = wordlist[rand(wordlist.length)]
@@ -31,7 +83,7 @@ class MarkovPlugin < Plugin
   end
 
   def help(plugin, topic="")
-    "markov plugin: listens to chat to build a markov chain, with which it can (perhaps) attempt to (inanely) contribute to 'discussion'. Sort of.. Will get a *lot* better after listening to a lot of chat. usage: 'markov' to attempt to say something relevant to the last line of chat, if it can.  other options to markov: 'ignore' => ignore a hostmask (accept no input), 'status' => show current status, 'probability' => set the % chance of rbot responding to input, 'chat' => try and say something intelligent, 'chat about <foo> <bar>' => riff on a word pair (if possible)"
+    "markov plugin: listens to chat to build a markov chain, with which it can (perhaps) attempt to (inanely) contribute to 'discussion'. Sort of.. Will get a *lot* better after listening to a lot of chat. usage: 'markov' to attempt to say something relevant to the last line of chat, if it can.  other options to markov: 'ignore' => ignore a hostmask (accept no input), 'status' => show current status, 'probability [<chance>]' => set the % chance of rbot responding to input, or display the current probability, 'chat' => try and say something intelligent, 'chat about <foo> <bar>' => riff on a word pair (if possible)"
   end
 
   def clean_str(s)
@@ -42,80 +94,79 @@ class MarkovPlugin < Plugin
   end
 
   def probability?
-    prob = @registry['probability']
-    prob = 25 if prob.kind_of? Array;
-    prob = 0 if prob < 0
-    prob = 100 if prob > 100
-    return prob
+    return @bot.config['markov.probability']
   end
 
   def status(m,params)
-    enabled = @registry['enabled']
-    if (enabled)
+    if @bot.config['markov.enabled']
       m.reply "markov is currently enabled, #{probability?}% chance of chipping in"
     else
       m.reply "markov is currently disabled"
     end
   end
 
-  def ignore?(user=nil)
-    @registry['ignore_users'].each do |mask|
-      return true if Irc.netmaskmatch mask, user
+  def ignore?(m=nil)
+    return false unless m
+    return true if m.address? or m.private?
+    @bot.config['markov.ignore'].each do |mask|
+      return true if m.channel.downcase == mask.downcase
+      return true if m.source.matches?(mask)
     end
     return false
   end
 
   def ignore(m, params)
-    if @registry['ignore_users'].nil?
-      @registry['ignore_users'] = []
-    end
     action = params[:action]
     user = params[:option]
     case action
     when 'remove':
-      if @registry['ignore_users'].include? user
-        s = @registry['ignore_users']
+      if @bot.config['markov.ignore'].include? user
+        s = @bot.config['markov.ignore']
         s.delete user
-        @registry['ignore_users'] = s
+        @bot.config['ignore'] = s
         m.reply "#{user} removed"
       else
         m.reply "not found in list"
       end
     when 'add':
       if user
-        if @registry['ignore_users'].include?(user)
+        if @bot.config['markov.ignore'].include?(user)
           m.reply "#{user} already in list"
         else
-          @registry['ignore_users'] = @registry['ignore_users'].push user 
+          @bot.config['markov.ignore'] = @bot.config['markov.ignore'].push user
           m.reply "#{user} added to markov ignore list"
         end
       else
-        m.reply "give the name of a person to ignore"
+        m.reply "give the name of a person or channel to ignore"
       end
     when 'list':
-      m.reply "I'm ignoring #{@registry['ignore_users'].join(", ")}"
+      m.reply "I'm ignoring #{@bot.config['markov.ignore'].join(", ")}"
     else
-      m.reply "have markov ignore the input from a hostmask.  usage: markov ignore add <mask>; markov ignore remove <mask>; markov ignore list"
+      m.reply "have markov ignore the input from a hostmask or a channel.  usage: markov ignore add <mask or channel>; markov ignore remove <mask or channel>; markov ignore list"
     end
   end
 
   def enable(m, params)
-    @registry['enabled'] = true
+    @bot.config['markov.enabled'] = true
     m.okay
   end
 
   def probability(m, params)
-    @registry['probability'] = params[:probability].to_i
-    m.okay
+    if params[:probability]
+      @bot.config['markov.probability'] = params[:probability].to_i
+      m.okay
+    else
+      m.reply _("markov has a %{prob}% chance of chipping in") % { :prob => probability? }
+    end
   end
 
   def disable(m, params)
-    @registry['enabled'] = false
+    @bot.config['markov.enabled'] = false
     m.okay
   end
 
   def should_talk
-    return false unless @registry['enabled']
+    return false unless @bot.config['markov.enabled']
     prob = probability?
     return true if prob > rand(100)
     return false
@@ -129,11 +180,14 @@ class MarkovPlugin < Plugin
     return unless should_talk
 
     word1, word2 = message.split(/\s+/)
+    return unless word1 and word2
     line = generate_string(word1, word2)
     return unless line
-    return if line == message
-    @bot.timer.add_once(delay, m) {|m|
-      m.reply line
+    # we do nothing if the line we return is just an initial substring
+    # of the line we received
+    return if message.index(line) == 0
+    @bot.timer.add_once(delay) {
+      m.plainreply line
     }
   end
 
@@ -165,32 +219,35 @@ class MarkovPlugin < Plugin
     end
   end
   
-  def listen(m)
-    return unless m.kind_of?(PrivMessage) && m.public?
-    return if m.address?
-    return if ignore? m.source
+  def message(m)
+    return if ignore? m
 
     # in channel message, the kind we are interested in
-    message = clean_str m.message
+    message = clean_str m.plainmessage
 
     if m.action?
       message = "#{m.sourcenick} #{message}"
     end
     
+    @learning_queue.push message
+    random_markov(m, message) unless m.replied?
+  end
+
+  def learn(message)
+    # debug "learning #{message}"
     wordlist = message.split(/\s+/)
     return unless wordlist.length >= 2
-    @lastline = message
     word1, word2 = :nonword, :nonword
     wordlist.each do |word3|
-      @registry["#{word1} #{word2}"] = @registry["#{word1} #{word2}"].push(word3)
+      k = "#{word1} #{word2}"
+      @registry[k] = @registry[k].push(word3)
       word1, word2 = word2, word3
     end
-    @registry["#{word1} #{word2}"] = @registry["#{word1} #{word2}"].push(:nonword)
-
-    return if m.replied?
-    random_markov(m, message)
+    k = "#{word1} #{word2}"
+    @registry[k] = @registry[k].push(:nonword)
   end
 end
+
 plugin = MarkovPlugin.new
 plugin.map 'markov ignore :action :option', :action => "ignore"
 plugin.map 'markov ignore :action', :action => "ignore"
@@ -200,5 +257,5 @@ plugin.map 'markov disable', :action => "disable"
 plugin.map 'markov status', :action => "status"
 plugin.map 'chat about :seed1 :seed2', :action => "chat"
 plugin.map 'chat', :action => "rand_chat"
-plugin.map 'markov probability :probability', :action => "probability",
+plugin.map 'markov probability [:probability]', :action => "probability",
            :requirements => {:probability => /^\d+%?$/}

data/data/rbot/plugins/math.rb

@@ -80,19 +80,20 @@ class MathPlugin < Plugin
     expr.gsub!(/\bover /, "/ ")
     expr.gsub!(/\bsquared/, "**2 ")
     expr.gsub!(/\bcubed/, "**3 ")
-    expr.gsub!(/\bto\s+(\d+)(r?st|nd|rd|th)?( power)?/, "**\1 ")
+    expr.gsub!(/\bto\s+(\d+)(r?st|nd|rd|th)?( power)?/, '**\1 ')
     expr.gsub!(/\bpercent of/, "*0.01*")
     expr.gsub!(/\bpercent/, "*0.01")
     expr.gsub!(/\% of\b/, "*0.01*")
     expr.gsub!(/\%/, "*0.01")
-    expr.gsub!(/\bsquare root of (\d+)/, "\1 ** 0.5 ")
-    expr.gsub!(/\bcubed? root of (\d+)/, "\1 **(1.0/3.0) ")
+    expr.gsub!(/\bsquare root of (\d+(\.\d+)?)/, '\1 ** 0.5 ')
+    expr.gsub!(/\bcubed? root of (\d+(\.\d+)?)/, '\1 **(1.0/3.0) ')
     expr.gsub!(/ of /, " * ")
     expr.gsub!(/(bit(-| )?)?xor(\'?e?d( with))?/, "^")
     expr.gsub!(/(bit(-| )?)?or(\'?e?d( with))?/, "|")
     expr.gsub!(/bit(-| )?and(\'?e?d( with))?/, "& ")
     expr.gsub!(/(plus|and)/, "+")
 
+    debug expr
     if (expr =~ /^\s*[-\d*+\s()\/^\.\|\&\*\!]+\s*$/ &&
        expr !~ /^\s*\(?\d+\.?\d*\)?\s*$/ &&
        expr !~ /^\s*$/ &&
@@ -109,9 +110,9 @@ class MathPlugin < Plugin
              answer = "a number with >30 digits..."
            end
          end
-         m.reply answer
+         m.reply answer.to_s
        rescue Exception => e
-         error "couldn't evaluate expression \"#{m.params}\": #{e.inspect}"
+         error e
          m.reply "illegal expression \"#{m.params}\""
          return
        end

data/data/rbot/plugins/modes.rb

@@ -0,0 +1,114 @@
+class ModesPlugin < Plugin
+
+  def help(plugin, topic="")
+    return "'op [<user>] [<channel>]' => grant user> (if ommitted yourself) ops in <channel> (or in the current channel if no channel is specified). Use deop instead of op to remove the privilege."
+  end
+
+  def op(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "+o")
+  end
+
+  def opme(m, params)
+    params[:user] = m.sourcenick
+    op(m, params)
+  end
+
+  def deop(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "-o")
+  end
+
+  def deopme(m, params)
+    params[:user] = m.sourcenick
+    deop(m, params)
+  end
+
+  def hop(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "+h")
+  end
+
+  def hopme(m, params)
+    params[:user] = m.sourcenick
+    hop(m, params)
+  end
+
+  def dehop(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "-h")
+  end
+
+  def dehopme(m, params)
+    params[:user] = m.sourcenick
+    dehop(m, params)
+  end
+
+  def voice(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "+v")
+  end
+
+  def voiceme(m, params)
+    params[:user] = m.sourcenick
+    voice(m, params)
+  end
+
+  def devoice(m, params)
+    channel = params[:channel]
+    user = params[:user]
+    do_mode(m, channel, user, "-v")
+  end
+
+  def devoiceme(m, params)
+    params[:user] = m.sourcenick
+    devoice(m, params)
+  end
+
+  def do_mode(m, channel, user, mode)
+    unless channel
+      if m.private?
+        target = user.nil? ? "you" : user 
+        m.reply "You should tell me where you want me to #{mode} #{target}."
+        return
+      else
+        channel = m.channel
+      end
+    else
+      channel = m.server.channel(channel)
+
+      unless channel.has_user?(@bot.nick)
+        m.reply "I am not in that channel"
+	return
+      end
+    end
+
+    unless user
+      user = m.sourcenick
+    end
+
+    m.okay unless channel == m.channel.to_s
+    @bot.mode(channel, mode, user)
+  end
+end
+
+plugin = ModesPlugin.new
+plugin.map("op [:user] [:channel]")
+plugin.map("opme [:channel]") # For backwards compatibility with 0.9.10
+plugin.map("deop [:user] [:channel]")
+plugin.map("deopme [:channel]") # For backwards compatibility with 0.9.10
+plugin.map("hop [:user] [:channel]")
+plugin.map("hopme [:channel]")
+plugin.map("dehop [:user] [:channel]")
+plugin.map("dehopme [:channel]")
+plugin.map("voice [:user] [:channel]")
+plugin.map("voiceme [:channel]")
+plugin.map("devoice [:user] [:channel]")
+plugin.map("devoiceme [:channel]")
+plugin.default_auth("*",false)
+