rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/salut.rb

@@ -0,0 +1,226 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Salutations plugin for rbot
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+# Copyright:: (C) 2006-2007 Giuseppe Bilotta
+# License:: GPL v2
+#
+# Salutations plugin: respond to salutations
+#
+# TODO:: allow online editing of salutations
+#
+# TODO:: *REMEMBER* to set @changed to true after edit or changes won't be saved
+
+class SalutPlugin < Plugin
+  Config.register Config::BooleanValue.new('salut.all_languages',
+    :default => true, 
+    :desc => "Check for a salutation in all languages and not just in the one defined by core.language",
+    :on_change => Proc.new {|bot, v| bot.plugins['salut'].reload}
+  )
+  Config.register Config::BooleanValue.new('salut.address_only',
+    :default => true, 
+    :desc => "When set to true, the bot will only reply to salutations directed at him",
+    :on_change => Proc.new {|bot, v| bot.plugins['salut'].reload}
+  )
+
+
+  def initialize
+    @salutations = Hash.new
+    @match = Hash.new
+    @match_langs = Array.new
+    @main_lang_str = nil
+    @main_lang = nil
+    @all_langs = true
+    @changed = false
+    super
+    reload
+  end
+
+  def set_language(what)
+    reload
+  end
+
+  def create_match
+    @match.clear
+    ar_dest = Array.new
+    ar_in = Array.new
+    ar_out = Array.new
+    ar_both = Array.new
+    @salutations.each { |lang, hash|
+      ar_dest.clear
+      ar_in.clear
+      ar_out.clear
+      ar_both.clear
+      hash.each { |situation, array|
+        case situation.to_s
+        when /^generic-dest$/
+          ar_dest += array
+        when /in$/
+          ar_in += array
+        when /out$/
+          ar_out += array
+        else
+          ar_both += array
+        end
+      }
+      @match[lang] = Hash.new
+      @match[lang][:in] = Regexp.new("\\b(?:" + ar_in.uniq.map { |txt|
+        Regexp.escape(txt)
+      }.join('|') + ")\\b", Regexp::IGNORECASE) unless ar_in.empty?
+      @match[lang][:out] = Regexp.new("\\b(?:" + ar_out.uniq.map { |txt|
+        Regexp.escape(txt)
+      }.join('|') + ")\\b", Regexp::IGNORECASE) unless ar_out.empty?
+      @match[lang][:both] = Regexp.new("\\b(?:" + ar_both.uniq.map { |txt|
+        Regexp.escape(txt)
+      }.join('|') + ")\\b", Regexp::IGNORECASE) unless ar_both.empty?
+      @match[lang][:dest] = Regexp.new("\\b(?:" + ar_dest.uniq.map { |txt|
+        Regexp.escape(txt)
+      }.join('|') + ")\\b", Regexp::IGNORECASE) unless ar_dest.empty?
+    }
+    @punct = /\s*[.,:!;?]?\s*/ # Punctuation
+
+    # Languages to match for, in order
+    @match_langs.clear
+    @match_langs << @main_lang if @match.key?(@main_lang)
+    @match_langs << :english if @match.key?(:english)
+    @match.each_key { |key|
+      @match_langs << key
+    }
+    @match_langs.uniq!
+  end
+
+  def unreplied(m)
+    return if @match.empty?
+    return unless m.kind_of?(PrivMessage)
+    return if m.address? and m.plugin == 'config'
+    to_me = m.address? || m.message =~ /#{Regexp.escape(@bot.nick)}/i
+    if @bot.config['salut.address_only']
+      return unless to_me
+    end
+    salut = nil
+    @match_langs.each { |lang|
+      [:both, :in, :out].each { |k|
+        next unless @match[lang][k]
+        if m.message =~ @match[lang][k]
+          salut = [@match[lang][k], lang, k]
+          break
+        end
+      }
+      break if salut
+    }
+    return unless salut
+    # If the bot wasn't addressed, we continue only if the match was exact
+    # (apart from space and punctuation) or if @match[:dest] matches too
+    return unless to_me or m.message =~ /^#{@punct}#{salut.first}#{@punct}$/ or m.message =~ @match[salut[1]][:dest] 
+    h = Time.new.hour
+    case h
+    when 4...12
+      salut_reply(m, salut, :morning)
+    when 12...18
+      salut_reply(m, salut, :afternoon)
+    else
+      salut_reply(m, salut, :evening)
+    end
+  end
+
+  def salut_reply(m, salut, time)
+    lang = salut[1]
+    k = salut[2]
+    debug "Replying to #{salut.first} (#{lang} #{k}) in the #{time}"
+    # salut_ar = @salutations[@main_lang].update @salutations[:english].update @salutations[lang]
+    salut_ar = @salutations[lang]
+    case k
+    when :both
+      sfx = ""
+    else
+      sfx = "-#{k}"
+    end
+    debug "Building array ..."
+    rep_ar = Array.new
+    rep_ar += salut_ar.fetch("#{time}#{sfx}".to_sym, [])
+    rep_ar += salut_ar.fetch("#{time}".to_sym, []) unless sfx.empty?
+    rep_ar += salut_ar.fetch("generic#{sfx}".to_sym, [])
+    rep_ar += salut_ar.fetch("generic".to_sym, []) unless sfx.empty?
+    debug "Choosing reply in #{rep_ar.inspect} ..."
+    if rep_ar.empty?
+      if m.public? # and (m.address? or m =~ /#{Regexp.escape(@bot.nick)}/)
+        choice = @bot.lang.get("hello_X") % m.sourcenick
+      else
+        choice = @bot.lang.get("hello") % m.sourcenick
+      end
+    else
+      choice = rep_ar.pick_one
+      if m.public? and (m.address? or m.message =~ /#{Regexp.escape(@bot.nick)}/)
+        choice += "#{[',',''].pick_one} #{m.sourcenick}"
+        choice += [" :)", " :D", "!", "", "", ""].pick_one
+      end
+    end
+    debug "Replying #{choice}"
+    m.plainreply choice
+  end
+
+  def reload
+    save
+    @main_lang_str = @bot.config['core.language']
+    @main_lang = @main_lang_str.to_sym
+    @all_langs = @bot.config['salut.all_languages']
+    if @all_langs
+      # Get all available languages
+      langs = Dir.new("#{@bot.botclass}/salut").collect {|f|
+        f =~ /salut-([^.]+)/ ? $1 : nil
+      }.compact
+      langs.each { |lang|
+        @salutations[lang.to_sym] = load_lang(lang)
+      }
+    else
+      @salutations.clear
+      @salutations[@main_lang] = load_lang(@main_lang_str)
+    end
+    create_match
+    @changed = false
+  end
+
+  def load_lang(lang)
+    dir = "#{@bot.botclass}/salut"
+    if not File.exist?(dir)
+      Dir.mkdir(dir)
+    end
+    file = "#{@bot.botclass}/salut/salut-#{lang}"
+    if File.exist?(file)
+      begin
+        salutations = Hash.new
+        content = YAML::load_file(file)
+        content.each { |key, val|
+          salutations[key.to_sym] = val
+        }
+        return salutations
+      rescue
+        error "failed to read salutations in #{lang}: #{$!}"
+      end
+    end
+    return nil
+  end
+
+  def save
+    return if @salutations.empty?
+    return unless @changed
+    @salutations.each { |lang, val|
+      l = lang.to_s
+      save_lang(lang, val)
+    }
+    @changed = false
+  end
+
+  def save_lang(lang, val)
+    fn = "#{@bot.botclass}/salut/salut-#{lang}"
+    Utils.safe_save(fn) { |file|
+      file.puts val.to_yaml
+    }
+  end
+
+end
+
+plugin = SalutPlugin.new
+

data/data/rbot/plugins/script.rb

@@ -0,0 +1,184 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Script plugin for rbot
+#
+# Author:: Mark Kretschmann <markey@web.de>
+# Copyright:: (C) 2006 Mark Kretschmann
+# License:: GPL v2
+#
+# Create mini plugins on IRC.
+#
+# Scripts are little Ruby programs that run in the context of the script
+# plugin. You can create them directly in an IRC channel, and invoke them just
+# like normal rbot plugins. 
+
+define_structure :Command, :code, :nick, :created, :channel
+
+class ScriptPlugin < Plugin
+
+  def initialize
+    super
+    if @registry.has_key?(:commands)
+      @commands = @registry[:commands]
+      raise unless @commands
+    else
+      @commands = Hash.new
+    end
+  end
+
+
+  def save
+    @registry[:commands] = @commands
+  end
+
+
+  def help( plugin, topic="" )
+    if topic == "add"
+      "Scripts are little Ruby programs that run in the context of the script plugin. You can access @bot (class Irc::Bot), m (class Irc::PrivMessage), user (class String, either the first argument, or if missing the sourcenick), and args (class Array, an array of arguments). Example: 'script add greet m.reply( 'Hello ' + user )'. Invoke the script just like a plugin: '<botnick>: greet'."
+    else  
+      "Create mini plugins on IRC. 'script add <name> <code>' => Create script named <name> with the Ruby program <code>. 'script list' => Show a list of all known scripts. 'script show <name>' => Show the source code for <name>. 'script del <name>' => Delete the script <name>. 'script eval <expr>' => evaluate expression <expr>. 'script echo <expr>' => evaluate and display expression <expr>."
+    end
+  end
+
+  def report_error(m, name, e)
+    # ed = e.backtrace.unshift(e.inspect).join(' ')
+    ed = e.inspect
+    m.reply( "Script '#{name}' crapped out :( #{ed}" )
+  end
+
+
+  def listen( m )
+    name = m.message.split.first
+
+    if m.address? and @commands.has_key?( name )
+      code = @commands[name].code.dup.untaint
+
+      # Convenience variables, can be accessed by scripts:
+      args = m.message.split
+      args.delete_at( 0 ) 
+      user = args.empty? ? m.sourcenick : args.first  
+
+      Thread.start {
+        # TODO allow different safe levels for different botusers
+        $SAFE = 3
+
+        begin
+          eval( code )
+        rescue Exception => e
+          report_error(m, name, e)
+        end
+      }
+      m.replied = true
+    end
+  end
+
+
+  def handle_eval( m, params )
+    code = params[:code].to_s.dup.untaint
+    Thread.start {
+      # TODO allow different safe levels for different botusers
+      begin
+        eval( code )
+      rescue Exception => e
+        report_error(m, code, e)
+      end
+    }
+    m.replied = true
+  end
+
+
+  def handle_echo( m, params )
+    code = params[:code].to_s.dup.untaint
+    Thread.start {
+      # TODO allow different safe levels for different botusers
+      begin
+        m.reply eval( code ).to_s
+      rescue Exception => e
+        report_error(m, code, e)
+      end
+    }
+    m.replied = true
+  end
+
+
+  def handle_add( m, params, force = false )
+    name    = params[:name]
+    if !force and @commands.has_key?( name )
+      m.reply( "#{m.sourcenick}: #{name} already exists. Use 'add -f' if you really want to overwrite it." )
+      return
+    end
+
+    code    = params[:code].to_s
+    nick    = m.sourcenick
+    created = Time.new.strftime '%Y/%m/%d %H:%m'
+    channel = m.target.to_s
+
+    command = Command.new( code, nick, created, channel )
+    @commands[name] = command
+
+    m.okay
+  end
+
+
+  def handle_add_force( m, params )
+    handle_add( m, params, true )
+  end
+    
+
+  def handle_del( m, params )
+    name = params[:name]
+    unless @commands.has_key?( name )
+      m.reply( "Script does not exist." ); return
+    end
+
+    @commands.delete( name )
+    m.okay
+  end
+
+
+  def handle_list( m, params )
+    if @commands.length == 0
+      m.reply( "No scripts available." ); return
+    end
+
+    cmds_per_page = 30
+    cmds = @commands.keys.sort
+    num_pages = cmds.length / cmds_per_page + 1
+    page = params[:page].to_i
+    page = [page, 1].max
+    page = [page, num_pages].min
+    str = cmds[(page-1)*cmds_per_page, cmds_per_page].join(', ') 
+
+    m.reply "Available scripts (page #{page}/#{num_pages}): #{str}" 
+  end
+
+
+  def handle_show( m, params )
+    name = params[:name]
+    unless @commands.has_key?( name )
+      m.reply( "Script does not exist." ); return
+    end
+
+    cmd = @commands[name]
+    m.reply( "#{cmd.code} [#{cmd.nick}, #{cmd.created} in #{cmd.channel}]" )
+ end
+
+end
+
+
+plugin = ScriptPlugin.new
+
+plugin.default_auth( 'edit', false )
+plugin.default_auth( 'eval', false )
+plugin.default_auth( 'echo', false )
+
+plugin.map 'script add -f :name *code', :action => 'handle_add_force', :auth_path => 'edit'
+plugin.map 'script add :name *code',    :action => 'handle_add',       :auth_path => 'edit'
+plugin.map 'script del :name',          :action => 'handle_del',       :auth_path => 'edit'
+plugin.map 'script eval *code',         :action => 'handle_eval'
+plugin.map 'script echo *code',         :action => 'handle_echo'
+plugin.map 'script list :page',         :action => 'handle_list',      :defaults => { :page => '1' }
+plugin.map 'script show :name',         :action => 'handle_show'
+
+

data/data/rbot/plugins/search.rb

@@ -0,0 +1,233 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Google and Wikipedia search plugin for rbot
+#
+# Author:: Tom Gilbert (giblet) <tom@linuxbrit.co.uk>
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# Copyright:: (C) 2002-2005 Tom Gilbert
+# Copyright:: (C) 2006 Tom Gilbert, Giuseppe Bilotta
+# Copyright:: (C) 2006-2007 Giuseppe Bilotta
+
+# TODO:: use lr=lang_<code> or whatever is most appropriate to let google know
+#        it shouldn't use the bot's location to find the preferred language
+# TODO:: support localized uncyclopedias -- not easy because they have different names
+#        for most languages
+
+GOOGLE_SEARCH = "http://www.google.com/search?oe=UTF-8&q="
+GOOGLE_WAP_SEARCH = "http://www.google.com/wml/search?hl=en&q="
+GOOGLE_WAP_LINK = /<a accesskey="(\d)" href=".*?u=(.*?)">(.*?)<\/a>/im
+GOOGLE_CALC_RESULT = %r{<img src=/images/calc_img\.gif(?: width=40 height=30 alt="")?></td><td>&nbsp;</td><td nowrap(?: dir=ltr)?>(?:<h2 class=r>)?<font size=\+1><b>(.+)</b>(?:</h2>)?</td>}
+GOOGLE_COUNT_RESULT = %r{<font size=-1>Results <b>1<\/b> - <b>10<\/b> of about <b>(.*)<\/b> for}
+GOOGLE_DEF_RESULT = %r{<p> (Web definitions for .*?)<br/>(.*?)<br/>(.*?)\s-\s+<a href}
+
+class SearchPlugin < Plugin
+  Config.register Config::IntegerValue.new('google.hits',
+    :default => 3,
+    :desc => "Number of hits to return from Google searches")
+  Config.register Config::IntegerValue.new('google.first_par',
+    :default => 0,
+    :desc => "When set to n > 0, the bot will return the first paragraph from the first n search hits")
+  Config.register Config::IntegerValue.new('wikipedia.hits',
+    :default => 3,
+    :desc => "Number of hits to return from Wikipedia searches")
+  Config.register Config::IntegerValue.new('wikipedia.first_par',
+    :default => 1,
+    :desc => "When set to n > 0, the bot will return the first paragraph from the first n wikipedia search hits")
+
+  def help(plugin, topic="")
+    case topic
+    when "search", "google"
+      "#{topic} <string> => search google for <string>"
+    when "gcalc"
+      "gcalc <equation> => use the google calculator to find the answer to <equation>"
+    when "gdef"
+      "gdef <term(s)> => use the google define mechanism to find a definition of <term(s)>"
+    when "wp"
+      "wp [<code>] <string> => search for <string> on Wikipedia. You can select a national <code> to only search the national Wikipedia"
+    when "unpedia"
+      "unpedia <string> => search for <string> on Uncyclopedia"
+    else
+      "search <string> (or: google <string>) => search google for <string> | wp <string> => search for <string> on Wikipedia | unpedia <string> => search for <string> on Uncyclopedia"
+    end
+  end
+
+  def google(m, params)
+    what = params[:words].to_s
+    searchfor = CGI.escape what
+    # This method is also called by other methods to restrict searching to some sites
+    if params[:site]
+      site = "site:#{params[:site]}+"
+    else
+      site = ""
+    end
+    # It is also possible to choose a filter to remove constant parts from the titles
+    # e.g.: "Wikipedia, the free encyclopedia" when doing Wikipedia searches
+    filter = params[:filter] || ""
+
+    url = GOOGLE_WAP_SEARCH + site + searchfor
+
+    hits = params[:hits] || @bot.config['google.hits']
+
+    first_pars = params[:firstpar] || @bot.config['google.first_par']
+
+    single = (hits == 1 and first_pars == 1)
+
+    begin
+      wml = @bot.httputil.get(url)
+      raise unless wml
+    rescue => e
+      m.reply "error googling for #{what}"
+      return
+    end
+    results = wml.scan(GOOGLE_WAP_LINK)
+    if results.length == 0
+      m.reply "no results found for #{what}"
+      return
+    end
+    single ||= (results.length==1)
+    urls = Array.new
+    results = results[0...hits].map { |res|
+      n = res[0]
+      t = Utils.decode_html_entities res[2].gsub(filter, '').strip
+      u = URI.unescape res[1]
+      urls.push(u)
+      single ? u : "#{n}. #{Bold}#{t}#{Bold}: #{u}"
+    }.join(" | ")
+
+    # If we return a single, full result, change the output to a more compact representation
+    if single
+      m.reply "Result for %s: %s -- %s" % [what, results, Utils.get_first_pars(urls, first_pars)], :overlong => :truncate
+      return
+    end
+
+    m.reply "Results for #{what}: #{results}", :split_at => /\s+\|\s+/
+
+    return unless first_pars > 0
+
+    Utils.get_first_pars urls, first_pars, :message => m
+
+  end
+
+  def gcalc(m, params)
+    what = params[:words].to_s
+    searchfor = CGI.escape(what)
+    
+    debug "Getting gcalc thing: #{searchfor.inspect}"
+    url = GOOGLE_SEARCH + searchfor
+
+    begin
+      html = @bot.httputil.get(url)
+    rescue => e
+      m.reply "error googlecalcing #{what}"
+      return
+    end
+
+    debug "#{html.size} bytes of html recieved"
+    
+    results = html.scan(GOOGLE_CALC_RESULT)
+    debug "results: #{results.inspect}"
+    
+    if results.length != 1
+      m.reply "couldn't calculate #{what}"
+      return
+    end
+    
+    result = results[0][0].ircify_html
+    debug "replying with: #{result.inspect}"
+    m.reply "#{result}"
+  end
+  
+  def gcount(m, params)
+    what = params[:words].to_s
+    searchfor = CGI.escape(what)
+    
+    debug "Getting gcount thing: #{searchfor.inspect}"
+    url = GOOGLE_SEARCH + searchfor
+
+    begin
+      html = @bot.httputil.get(url)
+    rescue => e
+      m.reply "error googlecounting #{what}"
+      return
+    end
+
+    debug "#{html.size} bytes of html recieved"
+    
+    results = html.scan(GOOGLE_COUNT_RESULT)
+    debug "results: #{results.inspect}"
+    
+    if results.length != 1
+      m.reply "couldn't count #{what}"
+      return
+    end
+    
+    result = results[0][0].ircify_html
+    debug "replying with: #{result.inspect}"
+    m.reply "total results: #{result}"
+
+  end
+
+  def gdef(m, params)
+    what = params[:words].to_s
+    searchfor = CGI.escape("define " + what)
+    
+    debug "Getting gdef thing: #{searchfor.inspect}"
+    url = GOOGLE_WAP_SEARCH + searchfor
+
+    begin
+      html = @bot.httputil.get(url)
+    rescue => e
+      m.reply "error googledefining #{what}"
+      return
+    end
+
+    debug html
+    results = html.scan(GOOGLE_DEF_RESULT)
+    debug "results: #{results.inspect}"
+    
+    if results.length != 1
+      m.reply "couldn't find a definition for #{what} on Google"
+      return
+    end
+    
+    head = results[0][0].ircify_html
+    text = results[0][1].ircify_html
+    link = results[0][2]
+    m.reply "#{head} -- #{link}\n#{text}"
+  end
+
+  def wikipedia(m, params)
+    lang = params[:lang]
+    site = "#{lang.nil? ? '' : lang + '.'}wikipedia.org"
+    debug "Looking up things on #{site}"
+    params[:site] = site
+    params[:filter] = / - Wikipedia.*$/
+    params[:hits] = @bot.config['wikipedia.hits']
+    params[:firstpar] = @bot.config['wikipedia.first_par']
+    return google(m, params)
+  end
+
+  def unpedia(m, params)
+    site = "uncyclopedia.org"
+    debug "Looking up things on #{site}"
+    params[:site] = site
+    params[:filter] = / - Uncyclopedia.*$/
+    params[:hits] = @bot.config['wikipedia.hits']
+    params[:firstpar] = @bot.config['wikipedia.first_par']
+    return google(m, params)
+  end
+end
+
+plugin = SearchPlugin.new
+
+plugin.map "search *words", :action => 'google', :threaded => true
+plugin.map "google *words", :action => 'google', :threaded => true
+plugin.map "gcount *words", :action => 'gcount', :threaded => true 
+plugin.map "gcalc *words", :action => 'gcalc', :threaded => true
+plugin.map "gdef *words", :action => 'gdef', :threaded => true
+plugin.map "wp :lang *words", :action => 'wikipedia', :requirements => { :lang => /^\w\w\w?$/ }, :threaded => true
+plugin.map "wp *words", :action => 'wikipedia', :threaded => true
+plugin.map "unpedia *words", :action => 'unpedia', :threaded => true
+