rbot 0.9.9

data/data/rbot/plugins/karma.rb

@@ -0,0 +1,85 @@
+class KarmaPlugin < Plugin
+  def initialize
+    super
+
+    # this plugin only wants to store ints!
+    class << @registry
+      def store(val)
+        val.to_i
+      end
+      def restore(val)
+        val.to_i
+      end
+    end
+    @registry.set_default(0)
+
+    # import if old file format found
+    if(File.exist?("#{@bot.botclass}/karma.rbot"))
+      puts "importing old karma data"
+      IO.foreach("#{@bot.botclass}/karma.rbot") do |line|
+        if(line =~ /^(\S+)<=>([\d-]+)$/)
+          item = $1
+          karma = $2.to_i
+          @registry[item] = karma
+        end
+      end
+      File.delete("#{@bot.botclass}/karma.rbot")
+    end
+
+  end
+
+  def stats(m, params)
+    if (@registry.length)
+      max = @registry.values.max
+      min = @registry.values.min
+      best = @registry.to_hash.index(max)
+      worst = @registry.to_hash.index(min)
+      m.reply "#{@registry.length} items. Best: #{best} (#{max}); Worst: #{worst} (#{min})"
+    end
+  end
+
+  def karma(m, params)
+    thing = params[:key]
+    thing = m.sourcenick unless thing
+    thing = thing.to_s
+    karma = @registry[thing]
+    if(karma != 0)
+      m.reply "karma for #{thing}: #{@registry[thing]}"
+    else
+      m.reply "#{thing} has neutral karma"
+    end
+  end
+  
+  
+  def help(plugin, topic="")
+    "karma module: <thing>++/<thing>-- => increase/decrease karma for <thing>, karma for <thing>? => show karma for <thing>, karmastats => show stats. Karma is a community rating system - only in-channel messages can affect karma and you cannot adjust your own."
+  end
+  def listen(m)
+    return unless m.kind_of?(PrivMessage) && m.public?
+    # in channel message, the kind we are interested in
+    if(m.message =~ /(\+\+|--)/)
+      string = m.message.sub(/\W(--|\+\+)(\(.*?\)|[^(++)(\-\-)\s]+)/, "\2\1")
+      seen = Hash.new
+      while(string.sub!(/(\(.*?\)|[^(++)(\-\-)\s]+)(\+\+|--)/, ""))
+        key = $1
+        change = $2
+        next if seen[key]
+        seen[key] = true
+
+        key.sub!(/^\((.*)\)$/, "\1")
+        key.gsub!(/\s+/, " ")
+        next unless(key.length > 0)
+        next if(key == m.sourcenick)
+        if(change == "++")
+          @registry[key] += 1
+        elsif(change == "--")
+          @registry[key] -= 1
+        end
+      end
+    end
+  end
+end
+plugin = KarmaPlugin.new
+plugin.map 'karmastats', :action => 'stats'
+plugin.map 'karma :key', :defaults => {:key => false}
+plugin.map 'karma for :key'

data/data/rbot/plugins/lart.rb

@@ -0,0 +1,181 @@
+#  Author:     Michael Brailsford  <brailsmt@yahoo.com>
+#              aka brailsmt
+#  Purpose:	   Provide for humorous larts and praises
+#  Copyright:  2002 Michael Brailsford.  All rights reserved.
+#  License:    This plugin is licensed under the BSD license.  The terms of
+#              which follow.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+
+class LartPlugin < Plugin
+
+	# Keep a 1:1 relation between commands and handlers
+	@@handlers = {
+		"lart" => "handle_lart",
+		"praise" => "handle_praise",
+		"addlart" => "handle_addlart",
+		"rmlart" => "handle_rmlart",
+		"addpraise" => "handle_addpraise",
+		"rmpraise" => "handle_rmpraise"
+	}
+
+  def name
+    "lart"
+  end
+
+	#{{{
+	def initialize
+		super
+		@larts = Array.new
+		@praises = Array.new
+		#read in the lart and praise files
+		if File.exists? "#{@bot.botclass}/lart/larts"
+			IO.foreach("#{@bot.botclass}/lart/larts") { |line|
+				@larts << line.chomp
+			}
+		end
+		if File.exists? "#{@bot.botclass}/lart/praises"
+			IO.foreach("#{@bot.botclass}/lart/praises") { |line|
+				@praises << line.chomp
+			}
+		end
+	end
+	#}}}
+	#{{{
+	def cleanup
+	end
+	#}}}
+	#{{{
+	def save
+		Dir.mkdir("#{@bot.botclass}/lart") if not FileTest.directory? "#{@bot.botclass}/lart"
+		File.open("#{@bot.botclass}/lart/larts", "w") { |file|
+			file.puts @larts
+		}
+		File.open("#{@bot.botclass}/lart/praises", "w") { |file|
+			file.puts @praises
+		}
+	end
+	#}}}
+	#{{{
+	def privmsg(m)
+		if not m.params
+			m.reply "What a crazy fool!  Did you mean |help stats?"
+			return
+		end
+
+		meth = self.method(@@handlers[m.plugin])
+		meth.call(m) if(@bot.auth.allow?(m.plugin, m.source, m.replyto))
+	end
+	#}}}
+	#{{{
+	def help(plugin, topic="")
+		"Lart:  The lart plugin allows you to punish/praise someone in the channel.  You can also add new punishments and new praises as well as delete them.  For the curious, LART is an acronym for Luser Attitude Readjustment Tool.\nUsage:  punish/lart <nick> <reason>  --  punishes <nick> for <reason>.  The reason is optional.\n        praise <nick> <reason>  --  praises <nick> for <reason>.  The reason is optional.\n        mod[lart|punish|praise] [add|remove]  --  Add or remove a lart or praise."
+	end
+	#}}}
+	# The following are command handlers	{{{
+	#{{{
+	def handle_lart(m)
+		for_idx = m.params =~ /\s+\bfor\b/
+		if for_idx
+			nick = m.params[0, for_idx]
+		else
+			nick = m.params
+		end
+		lart = @larts[get_msg_idx(@larts.length)]
+		if lart == nil
+			m.reply "I dunno any larts"
+			return
+		end
+		if nick == @bot.nick
+			lart = replace_who lart, m.sourcenick
+			lart << " for trying to make me lart myself"
+		else
+			lart = replace_who lart, nick
+			lart << m.params[for_idx, m.params.length] if for_idx
+		end
+
+		@bot.action m.replyto, lart
+	end
+	#}}}
+	#{{{
+	def handle_praise(m)
+		for_idx = m.params =~ /\s+\bfor\b/
+		if for_idx
+			nick = m.params[0, for_idx]
+		else
+			nick = m.params
+		end
+		praise = @praises[get_msg_idx(@praises.length)]
+		if not praise
+			m.reply "I dunno any praises"
+			return
+		end
+
+		if nick == m.sourcenick
+			praise = @larts[get_msg_idx(@larts.length)]
+			praise = replace_who praise, nick
+		else
+			praise = replace_who praise, nick
+			praise << m.params.gsub(/#{nick}/, "")
+		end
+
+		@bot.action m.replyto, praise
+	end
+	#}}}
+	#{{{
+	def handle_addlart(m)
+		@larts << m.params
+		m.okay
+	end
+	#}}}
+	#{{{
+	def handle_rmlart(m)
+		@larts.delete m.params
+		m.okay
+	end
+	#}}}
+	#{{{
+	def handle_addpraise(m)
+		@praises << m.params
+		m.okay
+	end
+	#}}}
+	#{{{
+	def handle_rmpraise(m)
+		@praises.delete m.params
+		m.okay
+	end
+	#}}}
+	#}}}
+
+	#  The following are utils for larts/praises	{{{
+	#{{{
+	def replace_who(msg, nick)
+		msg.gsub(/<who>/i, "#{nick}")
+	end
+	#}}}
+	#{{{
+	def get_msg_idx(max)
+		idx = rand(max)
+	end
+	#}}}
+	#}}}
+end
+plugin = LartPlugin.new
+plugin.register("lart")
+plugin.register("praise")
+
+plugin.register("addlart")
+plugin.register("addpraise")
+
+plugin.register("rmlart")
+plugin.register("rmpraise")

data/data/rbot/plugins/math.rb

@@ -0,0 +1,122 @@
+class MathPlugin < Plugin
+  @@digits = {
+     "first" => "1",
+     "second" => "2",
+     "third" => "3",
+     "fourth" => "4",
+     "fifth" => "5",
+     "sixth" => "6",
+     "seventh" => "7",
+     "eighth" => "8",
+     "ninth" => "9",
+     "tenth" => "10",
+     "one" => "1",
+     "two" => "2",
+     "three" => "3",
+     "four" => "4",
+     "five" => "5",
+     "six" => "6",
+     "seven" => "7",
+     "eight" => "8",
+     "nine" => "9",
+     "ten" => "10"
+  };
+
+  def help(plugin, topic="")
+    "math <expression>, evaluate mathematical expression"
+  end
+  def privmsg(m)
+    unless(m.params)
+      m.reply "incorrect usage: " + help(m.plugin)
+      return
+    end
+
+    expr = m.params.dup
+    @@digits.each {|k,v|
+      expr.gsub!(/\b#{k}\b/, v)
+    }
+
+    while expr =~ /(exp ([\w\d]+))/
+      exp = $1
+      val = Math.exp($2).to_s
+      expr.gsub!(/#{Regexp.escape exp}/, "+#{val}")
+    end
+    
+    while expr =~ /^\s*(dec2hex\s*(\d+))\s*\?*/
+      exp = $1
+      val = sprintf("%x", $2)
+      expr.gsub!(/#{Regexp.escape exp}/, "+#{val}")
+    end
+
+    expr.gsub(/\be\b/, Math.exp(1).to_s)
+
+    while expr =~ /(log\s*((\d+\.?\d*)|\d*\.?\d+))\s*/
+      exp = $1
+      res = $2
+      
+      if res == 0
+        val = "Infinity"
+      else
+        val = Math.log(res).to_s
+      end
+      
+      expr.gsub!(/#{Regexp.escape exp}/, "+#{val}")
+    end
+
+    while expr =~ /(bin2dec ([01]+))/
+      exp = $1
+      val = join('', unpack('B*', pack('N', $2)))
+      val.gsub!(/^0+/, "")
+      expr.gsub!(/#{Regexp.escape exp}/, "+#{val}")
+    end
+
+    expr.gsub!(/ to the power of /, " ** ")
+    expr.gsub!(/ to the /, " ** ")
+    expr.gsub!(/\btimes\b/, "*")
+    expr.gsub!(/\bdiv(ided by)? /, "/ ")
+    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!(/\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!(/ 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)/, "+")
+
+    if (expr =~ /^\s*[-\d*+\s()\/^\.\|\&\*\!]+\s*$/ &&
+       expr !~ /^\s*\(?\d+\.?\d*\)?\s*$/ &&
+       expr !~ /^\s*$/ &&
+       expr !~ /^\s*[( )]+\s*$/)
+
+       begin
+         debug "evaluating expression \"#{expr}\""
+         answer = eval(expr)
+         if answer =~ /^[-+\de\.]+$/
+           answer = sprintf("%1.12f", answer)
+           answer.gsub!(/\.?0+$/, "")
+           answer.gsub!(/(\.\d+)000\d+/, '\1')
+           if (answer.length > 30)
+             answer = "a number with >30 digits..."
+           end
+         end
+         m.reply answer
+       rescue Exception => e
+         puts "couldn't evaluate expression \"#{m.params}\": #{e}"
+         m.reply "illegal expression \"#{m.params}\""
+         return
+       end
+    else
+      m.reply "illegal expression \"#{m.params}\""
+      return
+    end
+  end
+end
+plugin = MathPlugin.new
+plugin.register("math")

data/data/rbot/plugins/nickserv.rb

@@ -0,0 +1,89 @@
+# automatically lookup nicks in @registry and identify when asked
+
+class NickServPlugin < Plugin
+  
+  def help(plugin, topic="")
+    case topic
+    when ""
+      return "nickserv plugin: handles nickserv protected IRC nicks. topics password, register, identify, listnicks"
+    when "password"
+      return "nickserv password <nick> <passwd>: remember the password for nick <nick> and use it to identify in future"
+    when "register"
+      return "nickserv register [<password> [<email>]]: register the current nick, choosing a random password unless <password> is supplied - current nick must not already be registered for this to work. Also specify email if required by your services"
+    when "identify"
+      return "nickserv identify: identify with nickserv - shouldn't be needed - bot should identify with nickserv immediately on request - however this could be useful after splits or service disruptions, or when you just set the password for the current nick"
+    when "listnicks"
+      return "nickserv listnicks: lists nicknames and associated password the bot knows about - you will need config level auth access to do this one and it will reply by privmsg only"
+    end
+  end
+  
+  def genpasswd
+    # generate a random password
+    passwd = ""
+    8.times do
+      passwd += (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
+    end
+    return passwd
+  end
+
+  def initialize
+    super
+    # this plugin only wants to store strings!
+    class << @registry
+      def store(val)
+        val
+      end
+      def restore(val)
+        val
+      end
+    end
+  end
+
+  def password(m, params)
+    @registry[params[:nick]] = params[:passwd]
+    m.okay
+  end
+  def nick_register(m, params)
+    passwd = params[:passwd] ? params[:passwd] : genpasswd
+    message = "REGISTER #{passwd}"
+    message += " #{params[:email]}" if params[:email]
+    @bot.sendmsg "PRIVMSG", "NickServ", message
+    @registry[@bot.nick] = passwd
+    m.okay
+  end
+  def listnicks(m, params)
+    if @registry.length > 0
+      @registry.each {|k,v|
+        @bot.say m.sourcenick, "#{k} => #{v}"
+      }
+    else
+      m.reply "none known"
+    end
+  end
+  def identify(m, params)
+    if @registry.has_key?(@bot.nick)
+      @bot.sendmsg "PRIVMSG", "NickServ", "IDENTIFY #{@registry[@bot.nick]}"
+      m.okay
+    else
+      m.reply "I dunno the nickserv password for the nickname #{@bot.nick} :("
+    end
+  end
+  
+  def listen(m)
+    return unless(m.kind_of? NoticeMessage)
+
+    if (m.sourcenick == "NickServ" && m.message =~ /This nickname is owned by someone else/)
+      debug "nickserv asked us to identify for nick #{@bot.nick}"
+      if @registry.has_key?(@bot.nick)
+        @bot.sendmsg "PRIVMSG", "NickServ", "IDENTIFY " + @registry[@bot.nick]
+      end
+    end
+  end
+
+end
+plugin = NickServPlugin.new
+plugin.map 'nickserv password :nick :passwd'
+plugin.map 'nickserv register :passwd :email', :action => 'nick_register',
+           :defaults => {:passwd => false, :email => false}
+plugin.map 'nickserv listnicks'
+plugin.map 'nickserv identify'