rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/figlet.rb

@@ -1,24 +1,133 @@
-#DEFAULT_FONT="smslant"
-DEFAULT_FONT="rectangles"
-MAX_WIDTH=68
+#-- vim:sw=2:et
+#++
+#
+# :title: Figlet plugin
 
 class FigletPlugin < Plugin
+  MAX_WIDTH=68
+
+  Config.register Config::StringValue.new('figlet.path',
+     :default => 'figlet',
+     :desc => _('Path to the figlet program'),
+     :on_change => Proc.new { |bot, v| bot.plugins['figlet'].test_figlet })
+
+  Config.register Config::StringValue.new('figlet.font',
+     :default => 'smslant',
+     :desc => _('figlet font to use'),
+     :validate => Proc.new { |v| v !~ /\s|`/ },
+     :on_change => Proc.new { |bot, v| bot.plugins['figlet'].test_figlet })
+
+  Config.register Config::StringValue.new('toilet.path',
+     :default => 'toilet',
+     :desc => _('Path to the toilet program'),
+     :on_change => Proc.new { |bot, v| bot.plugins['figlet'].test_toilet })
+
+  Config.register Config::StringValue.new('toilet.font',
+     :default => 'smslant',
+     :desc => _('toilet font to use'),
+     :validate => Proc.new { |v| v !~ /\s|`/ },
+     :on_change => Proc.new { |bot, v| bot.plugins['figlet'].test_toilet })
+
+  Config.register Config::ArrayValue.new('toilet.filters',
+     :default => [],
+     :desc => _('toilet filters to use (e.g. gay, metal)'),
+     :validate => Proc.new { |v| v !~ /\s|`/ },
+     :on_change => Proc.new { |bot, v| bot.plugins['figlet'].test_toilet })
+
+  def figlet_path
+    @bot.config['figlet.path']
+  end
+
+  def toilet_path
+    @bot.config['toilet.path']
+  end
+
+  def figlet_font
+    @bot.config['figlet.font']
+  end
+
+  def toilet_font
+    @bot.config['toilet.font']
+  end
+
+  def toilet_filters
+    @bot.config['toilet.filters']
+  end
+
+  attr_reader :has, :params
+
+  def test_figlet
+    #check that figlet is present
+    @has[:figlet] = !!(Utils.safe_exec("#{figlet_path} -v") ; $?)
+
+    # check that figlet actually has the font installed
+    @has[:figlet_font] = !!(Utils.safe_exec("#{figlet_path} -f #{figlet_font} test test test") ; $?)
+
+    # set the commandline params
+    @params[:figlet] = ['-k', '-w', MAX_WIDTH.to_s, '-C', 'utf8']
+
+    # add the font from DEFAULT_FONTS to the cmdline (if figlet has that font)
+    @params[:figlet] += ['-f', figlet_font] if @has[:figlet_font]
+  end
+
+  def test_toilet
+    #check that toilet is present
+    @has[:toilet] = !!(Utils.safe_exec("#{toilet_path} -v") ; $?)
+
+    # check that toilet actually has the font installed
+    @has[:toilet_font] = !!(Utils.safe_exec("#{toilet_path} -f #{toilet_font} test test test") ; $?)
+
+    # set the commandline params
+    @params[:toilet] = ['-k', '-w', MAX_WIDTH.to_s, '-E', 'utf8', '--irc']
+
+    # add the font from DEFAULT_FONTS to the cmdline (if toilet has that font)
+    @params[:toilet] += ['-f', toilet_font] if @has[:toilet_font]
+
+    # add the filters, if any
+    toilet_filters.each { |f| @params[:toilet] += ['-F', f.dup] }
+  end
+
+  def initialize
+    super
+
+    @has = {}
+    @params = {}
+
+    # test for figlet and font presence
+    test_figlet
+    # ditto for toilet
+    test_toilet
+  end
+
   def help(plugin, topic="")
-    "figlet [<message>] => print using figlet"
-  end
-  def privmsg(m)
-	  case m.params
-	  when nil
-		  m.reply "incorrect usage: " + help(m.plugin)
-		  return
-	  when (/^-/)
-		  m.reply "incorrect usage: " + help(m.plugin)
-		  return
-	  else
-		  m.reply Utils.safe_exec("/usr/bin/figlet", "-k", "-w", "#{MAX_WIDTH}", "-f", DEFAULT_FONT, m.params)
-		  return
-	  end
+    "figlet|toilet <message> => print using figlet or toilet"
   end
+
+  def figlet(m, params)
+    key = params[:plugin] || m.plugin.intern
+    unless @has[key]
+      m.reply("%{cmd} couldn't be found. if it's installed, you should set the %{cmd}.path config key to its path" % {
+        :cmd => key
+      })
+      return
+    end
+
+    message = params[:message].to_s
+    if message =~ /^-/
+      m.reply "the message can't start with a - sign"
+      return
+    end
+
+    # collect the parameters to pass to safe_exec
+    exec_params = [send(:"#{key}_path")] + @params[key] + [message]
+
+    # run the program
+    m.reply Utils.safe_exec(*exec_params), :max_lines => 0
+  end
+  alias :toilet :figlet
+
 end
+
 plugin = FigletPlugin.new
-plugin.register("figlet")
+plugin.map "figlet *message"
+plugin.map "toilet *message"

data/data/rbot/plugins/fish.rb

@@ -1,26 +1,50 @@
-require 'net/http'
-require 'uri/common'
-Net::HTTP.version_1_2
-
 class BabelPlugin < Plugin
+  LANGS = %w{en fr de it pt es nl ru zh zt el ja ko}
+  BASEURL = 'http://babelfish.yahoo.com'
+
+  Config.register Config::EnumValue.new('translate.default_from',
+    :values => LANGS, :default => 'en',
+    :desc => "Default language to translate from")
+  Config.register Config::EnumValue.new('translate.default_to',
+    :values => LANGS, :default => 'en',
+    :desc => "Default language to translate to")
+
   def help(plugin, topic="")
-    "translate to <lang> <string> => translate from english to <lang>, translate from <lang> <string> => translate to english from <lang>, translate <fromlang> <tolang> <string> => translate from <fromlang> to <tolang>. Languages: en, fr, de, it, pt, es, nl"
+    case topic
+    when 'cache'
+      "translate cache [view|clear] => view or clear the translate cache contents"
+    else
+      from = @bot.config['translate.default_from']
+      to = @bot.config['translate.default_to']
+      "translate to <lang> <string> => translate from #{from} to <lang>, translate from <lang> <string> => translate to #{to} from <lang>, translate <fromlang> <tolang> <string> => translate from <fromlang> to <tolang>. If <string> is an http url, translates the referenced webpage and returns the 1st content paragraph. Languages: #{LANGS.join(', ')}. Other topics: cache"
+    end
   end
+
   def translate(m, params)
-    langs = ["en", "fr", "de", "it", "pt", "es", "nl"]
-    trans_from = params[:fromlang] ? params[:fromlang] : 'en'
-    trans_to = params[:tolang] ? params[:tolang] : 'en'
+    langs = LANGS
+    trans_from = params[:fromlang] ? params[:fromlang] : @bot.config['translate.default_from']
+    trans_to = params[:tolang] ? params[:tolang] : @bot.config['translate.default_to']
     trans_text = params[:phrase].to_s
     
-    query = "/babelfish/tr"
     lang_match = langs.join("|")
     unless(trans_from =~ /^(#{lang_match})$/ && trans_to =~ /^(#{lang_match})$/)
       m.reply "invalid language: valid languagess are: #{langs.join(' ')}"
       return
     end
 
-    data_text = URI.escape trans_text
+    data_text = CGI.escape trans_text
     trans_pair = "#{trans_from}_#{trans_to}"
+
+    if (trans_text =~ /^http:\/\//) && (URI.parse(trans_text) rescue nil)
+      m.reply 'webpage translation is not currently supported'
+      return
+      # TODO FIXME
+      # url = BASEURL+'/translate_url' +
+      #   "?lp=#{trans_pair}&trurl=#{data_text}"
+      #
+      # return Utils.get_first_pars([url], 1, :message => m)
+    end
+
     data = "lp=#{trans_pair}&doit=done&intl=1&tt=urltext&urltext=#{data_text}"
 
     # check cache for previous lookups
@@ -29,33 +53,69 @@ class BabelPlugin < Plugin
       return
     end
 
-    http = @bot.httputil.get_proxy(URI.parse("http://babelfish.altavista.com"))
-
-    http.start {|http|
-      resp = http.post(query, data, {"content-type",
-      "application/x-www-form-urlencoded"})
-  
-  if (resp.code == "200")
-    resp.body.each_line do |l|
-      if(l =~ /^\s+<td bgcolor=white class=s><div style=padding:10px;>(.*)<\/div>/)
-        answer = $1
-        # cache the answer
-        if(answer.length > 0)
-          @registry["#{trans_pair}/#{data_text}"] = answer
-        end
-        m.reply answer
-        return
+    headers = {
+      "content-type" => "application/x-www-form-urlencoded; charset=utf-8"
+    }
+
+    query = "/translate_txt"
+
+    begin
+      body = @bot.httputil.get(BASEURL+query,
+                               :method => :post,
+                               :body => data,
+                               :headers => headers)
+    rescue Exception => e
+      m.reply "http error: #{e.message}"
+      return
+    end
+
+    case body
+    when nil
+      m.reply "couldn't talk to babelfish :("
+    when /^\s*<div id="result"><div style="[^"]*">(.*?)<\/div><\/div>\s*$/
+      answer = $1
+      # cache the answer
+      if(answer.length > 0)
+        @registry["#{trans_pair}/#{data_text}"] = answer
       end
+      m.reply answer
+      return
+    when /^\s+<option value="#{trans_pair}"\s+SELECTED>/
+      m.reply "couldn't parse babelfish response html :("
+    else
+      m.reply "babelfish doesn't support translation from #{trans_from} to #{trans_to}"
     end
-    m.reply "couldn't parse babelfish response html :("
-  else
-    m.reply "couldn't talk to babelfish :("
   end
-  }
+
+  def cache_mgmt(m, params)
+    cmd = params[:cmd].intern
+    case cmd
+    when :view
+      cache = []
+      @registry.each { |key, val|
+        cache << "%s => %s" % [key, val]
+      }
+      m.reply "translate cache: #{cache.inspect}"
+    when :clear
+      keys = []
+      @registry.each { |key, val|
+        keys << key
+      }
+      keys.each { |key|
+        @registry.delete(key)
+      }
+      cache_mgmt(m, :cmd => 'view')
+    end
   end
+
 end
+
 plugin = BabelPlugin.new
-plugin.map 'translate to :tolang *phrase'
-plugin.map 'translate from :fromlang *phrase'
-plugin.map 'translate :fromlang :tolang *phrase'
+
+plugin.default_auth('cache', false)
+
+plugin.map 'translate to :tolang *phrase', :thread => true
+plugin.map 'translate from :fromlang *phrase', :thread => true
+plugin.map 'translate cache :cmd', :action => :cache_mgmt, :auth_path => 'cache!', :requirements => { :cmd => /view|clear/ }
+plugin.map 'translate :fromlang :tolang *phrase', :thread => true
 

data/data/rbot/plugins/forecast.rb

@@ -1,10 +1,14 @@
+#-- vim:sw=2:et
+#++
 #
-# Forecast plugin for rbot
-# by MrChucho (mrchucho@mrchucho.net)
-# Copyright (C) 2006 Ralph M. Churchill
+# :title: Forecast plugin for rbot
 #
+# Author:: MrChucho (mrchucho@mrchucho.net)
+# Copyright:: (C) 2006 Ralph M. Churchill
+
 require 'soap/wsdlDriver'
-require 'open-uri'
+# TODO why not use HttpUtil instead of open-uri?
+require 'open-uri' 
 require 'rexml/document'
 require 'erb'
 
@@ -84,6 +88,7 @@ class ForecastPlugin < Plugin
             end
         end
         @forecast_cache = Hash.new
+        @cache_mutex = Mutex.new
     end
 
     def forecast(m,params)
@@ -102,32 +107,40 @@ class ForecastPlugin < Plugin
     end
     
     def get_forecast(m,loc)
-        begin
-            if @forecast_cache.has_key?(loc) and
-                Time.new - @forecast_cache[loc][:date] < 3600
-                forecast = @forecast_cache[loc][:forecast]
-                forecast_date = @forecast_cache[loc][:date]
-            else
-                begin
-                    l = LatLong.new
-                    f = Forecast.new(*l.get_lat_long(loc))
-                    forecast,forecast_date = f.forecast
-                rescue => err
-                    m.reply err
-                end
-            end
+      begin
+        @cache_mutex.synchronize do
+          if @forecast_cache.has_key?(loc) and
+            Time.new - @forecast_cache[loc][:date] < 3600
+            forecast = @forecast_cache[loc][:forecast]
             if forecast
-                m.reply forecast
-                @forecast_cache[loc] = {}
-                @forecast_cache[loc][:forecast] = forecast
-                @forecast_cache[loc][:date] = forecast_date
-            else
-                m.reply "Couldn't find forecast for #{loc}"
+              m.reply forecast
+              return
             end
-        rescue => e
-            m.reply "ERROR: #{e}"
+          end
+        end
+        begin
+          l = LatLong.new
+          f = Forecast.new(*l.get_lat_long(loc))
+          forecast,forecast_date = f.forecast
+        rescue => err
+          m.reply err
+        end
+        if forecast
+          m.reply forecast
+          @cache_mutex.synchronize do
+            @forecast_cache[loc] = {
+              :forecast => forecast,
+              :date => forecast_date
+            }
+          end
+        else
+          m.reply "Couldn't find forecast for #{loc}"
         end
+      rescue => e
+        m.reply "ERROR: #{e}"
+      end
     end
 end
 plugin = ForecastPlugin.new
-plugin.map 'forecast *location', :defaults => {:location => false}
+plugin.map 'forecast *location',
+  :defaults => {:location => false}, :thread => true

data/data/rbot/plugins/fortune.rb

@@ -1,22 +1,97 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Fortune plugin
+
 class FortunePlugin < Plugin
+  Config.register Config::StringValue.new('fortune.path',
+    :default => '',
+    :desc => "Full path to the fortune executable")
+
   def help(plugin, topic="")
-    "fortune [<module>] => get a (short) fortune, optionally specifying fortune db"
+    "fortune [<category>] => get a (short) fortune, optionally specifying fortune category || fortune categories => show categories"
   end
-  def fortune(m, params)
-    db = params[:db]
-    fortune = nil
-    ["/usr/games/fortune", "/usr/bin/fortune", "/usr/local/bin/fortune"].each {|f|
+
+  def find_fortune
+    fortune = @bot.config['fortune.path']
+    return fortune if fortune
+
+    ["/usr/bin/fortune",
+     "/usr/share/bin/fortune",
+     "/usr/games/fortune",
+     "/usr/local/games/fortune",
+     "/usr/local/bin/fortune"].each do |f|
       if FileTest.executable? f
         fortune = f
         break
       end
-    }
-    m.reply "fortune binary not found" unless fortune
-    ret = Utils.safe_exec(fortune, "-n", "255", "-s", db)
-    m.reply ret.gsub(/\t/, "  ").split(/\n/).join(" ")
-    return
+    end
+
+    return nil unless fortune
+      
+    # Try setting the config entry
+    config_par = {:key => 'fortune.path', :value => [fortune], :silent => true }
+    debug "Setting fortune.path to #{fortune}"
+    set_path = @bot.plugins['config'].handle_set(m, config_par)
+    if set_path
+      debug "fortune.path set to #{@bot.config['fortune.path']}"
+    else
+      debug "couldn't set fortune.path"
+    end
+
+    return fortune
+  end
+
+  ## Pick a fortune
+  def fortune(m, params)
+    db = params[:db]
+    fortune = find_fortune
+    m.reply "fortune executable not found (try setting the 'fortune.path' variable)" unless fortune
+
+    begin
+      ret = Utils.safe_exec(fortune, "-n", "350", "-s", db)
+
+      ## cleanup ret
+      ret = ret.split(/\n+/).map do |l|
+        # check if this is a "  -- Some Dood" line
+        if l =~ /^\s+-{1,3}\s+\w/
+          # turn "-" into "--"
+          l.gsub!(/^\s+-\s/, '-- ')
+          # extra space
+          " " + l.strip
+        else
+          # just remove leading and trailing whitespace
+          l.strip
+        end
+      end.join(" ")
+
+    rescue
+      ret = "failed to execute fortune"
+      # TODO reset fortune.path when execution fails
+    end
+
+    m.reply ret
+  end
+
+  # Print the fortune categories
+  def categories(m, params)
+    fortune = find_fortune
+    m.reply "fortune executable not found (try setting the 'fortune.path' variable)" unless fortune
+
+    ## list all fortune databases
+    categories = Utils.safe_exec(fortune, "-f").split(/\n+ */).map{ |f|
+      f.split[1]
+    }.select{ |f|
+      f[0..0] != '/'
+    }.sort
+
+    ## say 'em!
+    m.reply "Fortune categories: #{categories.join ', '}"
   end
+ 
 end
 plugin = FortunePlugin.new
-plugin.map 'fortune :db', :defaults => {:db => 'fortunes'},
+plugin.map 'fortune categories', :action => "categories"
+plugin.map 'fortune list', :action => "categories"
+plugin.map 'fortune :db', :defaults => {:db => ''},
                           :requirements => {:db => /^[^-][\w-]+$/}