rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/threat.rb

@@ -16,36 +16,39 @@ class ThreatPlugin < Plugin
   end
 
   def privmsg(m)
-	color = ""
+    color = ""
     red = "\x0304" # severe
-	orange = "\x0307" # high
-	yellow = "\x0308" # elevated
-	blue = "\x0312" # guarded
-	green = "\x0303" # low
-	black = "\x0301" # default
-
-	page = @bot.httputil.get URI.parse("http://www.dhs.gov/dhspublic/")
-	if page =~ / <img.*dhs\/images\/dhs-advisory-(.*).gif.*/
+    orange = "\x0307" # high
+    yellow = "\x0308" # elevated
+    blue = "\x0312" # guarded
+    green = "\x0303" # low
+    black = "\x0301" # default
+
+    page = @bot.httputil.get("http://www.dhs.gov/index.shtm")
+
+    if page =~ /\"Current National Threat Level is (.*?)\"/
       state = $1
-    end
-    case state
+      case state
       when "severe"
-		color = red
+        color = red
       when "high"
-		color = orange
+        color = orange
       when "elevated"
-		color = yellow
+        color = yellow
       when "guarded"
-		color = blue
+        color = blue
       when "low"
-		color = green
-	else
-	  color = black
-	end
-
-	m.reply color + "Today " + m.sourcenick + " the threat level is " + state.capitalize
+        color = green
+      else
+        color = black
+      end
+
+      m.reply color + "Today " + m.sourcenick + " the threat level is " + state.capitalize
+    else
+      m.reply "I was unable to retrieve the threat level"
+    end
 
-	return
+    return
   end
 
 end

data/data/rbot/plugins/time.rb

@@ -0,0 +1,135 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Time Zone Plugin for rbot
+#
+# Author:: Ian Monroe <ian@monroe.nu>
+# Copyright:: (C) 2006 Ian Monroe
+# License:: MIT license
+
+require 'tzinfo'
+
+class TimePlugin < Plugin
+
+  def help(plugin, topic="")
+  "time <time zone> to get the local time of a certain location. <time zone> can be <Continent/City> or <two character country code>. time <nick> to see the local time of that person if their time zone is set. time admin set <nick> <time zone> to set the time zone for another user. time [admin] reset [nick] to let the bot forget about the tzinfo about someone"
+  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 getTime(m, zone )
+    if zone.length == 2 then #country code
+      zone.upcase!
+      zone = 'GB' if zone == 'UK' #country doesn't know its own name
+      begin
+        nationZones = TZInfo::Country.get(zone).zone_identifiers
+        if nationZones.size == 1 then
+          zone = nationZones[0]
+        else
+          m.reply "#{zone} has the cities of #{nationZones.join( ', ' )}."
+        end
+      rescue TZInfo::InvalidCountryCode
+        m.reply "#{zone} is not a valid country code."
+      end
+    end
+    ['/', '_'].each { |sp|
+        arr = Array.new
+        zone.split(sp).each{ |s| 
+            s[0] = s[0,1].upcase
+            s[1, s.length] = s[1, s.length].downcase if sp == '/'
+            arr.push(s) }
+            zone = arr.join( sp )
+        }
+    
+    tz = TZInfo::Timezone.get( zone )
+    "#{tz.friendly_identifier} - #{tz.now.strftime( '%a %b %d %H:%M' )} #{tz.current_period.abbreviation}"
+  end
+
+  def showTime(m, params)
+    zone = params[:where].join('_')
+    if params[:where].size > 0 then
+      begin
+        m.reply getTime( m,  zone )
+      rescue TZInfo::InvalidTimezoneIdentifier
+        if @registry.has_key?( zone ) then
+          zone =  @registry[ zone ]
+          m.reply getTime( m,  zone )
+        else
+          m.reply "#{zone} is an unknown time."
+        end
+      end
+    else
+      if @registry.has_key?( m.sourcenick) then
+        zone = @registry[ m.sourcenick ]
+        m.reply "#{m.sourcenick}: #{getTime( m,  zone )}"
+      else
+        m.reply "#{m.sourcenick}: use time set <Continent/City> to set your timezone."
+      end
+    end
+  end
+
+  def setUserZone( m, params )
+    if params[:where].size > 0 then
+      s = setZone( m, m.sourcenick, params[:where].join('_') )
+    else
+      m.reply "Requires Continent/City or country code"
+    end
+  end
+
+  def resetUserZone( m, params )
+    s = resetZone( m, m.sourcenick)
+  end
+
+  def setAdminZone( m, params )
+    if params[:who] and params[:where].size > 0 then
+      s = setZone( m, params[:who], params[:where].join('_') )
+    else
+      m.reply "Requires a nick and the Continent/City or country code"
+    end
+  end
+
+  def resetAdminZone( m, params )
+    if params[:who]
+      s = resetZone( m, params[:who])
+    else
+      m.reply "Requires a nick"
+    end
+  end
+
+  def setZone( m, user, zone )
+    begin
+      getTime( m,  zone )
+    rescue TZInfo::InvalidTimezoneIdentifier
+      m.reply "#{zone} is an invalid timezone. Format is Continent/City or a two character country code."
+      return
+    end
+    @registry[ user ] = zone
+    m.reply "Ok, I'll remember that #{user} is on the #{zone} timezone"
+  end
+
+  def resetZone( m, user )
+    @registry.delete(user)
+    m.reply "Ok, I've forgotten #{user}'s timezone"
+  end
+end
+
+plugin = TimePlugin.new
+
+plugin.default_auth('admin', false)
+
+plugin.map 'time set [time][zone] [to] *where', :action=> 'setUserZone', :defaults => {:where => false}
+plugin.map 'time reset [time][zone]', :action=> 'resetUserZone'
+plugin.map 'time admin set [time][zone] [for] :who [to] *where', :action=> 'setAdminZone', :defaults => {:who => false, :where => false}
+plugin.map 'time admin reset [time][zone] [for] :who', :action=> 'resetAdminZone', :defaults => {:who => false}
+plugin.map 'time *where', :action => 'showTime', :defaults => {:where => false}

data/data/rbot/plugins/topic.rb

@@ -1,4 +1,12 @@
-# Author: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#-- vim:sw=2:et
+#++
+#
+# :title: Topic manipulation plugin for rbot
+#
+# Author:: Giuseppe Bilotta <giuseppe.bilotta@gmail.com>
+# Copyright:: (C) 2006-2007 Giuseppe Bilotta
+# License:: GPL v2
+#
 # Add a bunch of topic manipulation features
 
 class TopicPlugin < Plugin
@@ -31,8 +39,10 @@ class TopicPlugin < Plugin
         return "topic clear => clears the topic"
       when "set"
         return "topic set <text> => sets the topic to <text>"
+      when "undo"
+        return "topic undo => undoes the latest change to the topic"
       else
-        return "topic add(at)|prepend|del(ete)|replace|sep(arator)|learn|restore|clear|set: " + \
+        return "topic add(at)|prepend|del(ete)|replace|sep(arator)|learn|restore|clear|set|undo: " + \
                "manipulate the topic of the current channel; use topic <#channel> <command> " + \
                "for private addressing"
       end
@@ -42,17 +52,16 @@ class TopicPlugin < Plugin
   def handletopic(m, param)
     return unless m.kind_of?(PrivMessage)
     if m.public?
-      ch = m.channel.downcase
+      ch = m.channel
     else
-      ch = param[:channel].downcase
+      ch = m.server.get_channel(param[:channel])
+      unless ch
+        m.reply("I am not in channel #{param[:channel]}")
+        return
+      end
     end
     cmd = param[:command]
-    txt = param[:text].join(" ")
-
-    unless @bot.channels.has_key?(ch)
-      m.reply "I am not in channel #{ch}"
-      return
-    end
+    txt = param[:text].to_s
 
     case cmd
     when /^a(dd|ppend)$/
@@ -89,12 +98,15 @@ class TopicPlugin < Plugin
       end
     when 'restore'
       restoretopic(m, ch)
+    when 'undo'
+      undotopic(m, ch)
     else
       m.reply 'unknown command'
     end
   end
 
   def topicsep(m, ch, txt)
+    return if !@bot.auth.allow?("topic::edit::separator", m.source, m.replyto)
     if txt
       sep = txt.strip
       if sep != ""
@@ -105,41 +117,50 @@ class TopicPlugin < Plugin
   end
 
   def setsep(ch, sep)
-    if @registry.has_key?(ch)
-      data = @registry[ch]
+    raise unless ch.class <= Irc::Channel
+    # TODO multiserver
+    k = ch.downcase
+
+    if @registry.has_key?(k)
+      data = @registry[k]
     else
       data = Hash.new
     end
 
     oldsep = getsep(ch)
-    topic = @bot.channels[ch].topic.to_s
+    topic = ch.topic.text
     topicarray = topic.split(/\s+#{Regexp.escape(oldsep)}\s*/)
 
     if sep != oldsep and topicarray.length > 0
       newtopic = topicarray.join(" #{sep} ")
-      @bot.topic ch, newtopic
+      @bot.topic ch, newtopic if newtopic != topic
     end
 
     data[:separator] = sep
-    @registry[ch] = data
+    @registry[k] = data
   end
 
   def getsep(ch)
-    if @registry.has_key?(ch)
-      if @registry[ch].has_key?(:separator)
-        return @registry[ch][:separator]
+    raise unless ch.class <= Irc::Channel
+    # TODO multiserver
+    k = ch.downcase
+
+    if @registry.has_key?(k)
+      if @registry[k].has_key?(:separator)
+        return @registry[k][:separator]
       end
     end
     return @separator
   end
 
-  def topicaddat(m, channel, num, txt)
-    sep = getsep(channel)
-    topic = @bot.channels[channel].topic.to_s
+  def topicaddat(m, ch, num, txt)
+    return if !@bot.auth.allow?("topic::edit::add", m.source, m.replyto)
+    sep = getsep(ch)
+    topic = ch.topic.text
     topicarray = topic.split(/\s+#{Regexp.escape(sep)}\s*/)
     topicarray.insert(num, txt)
     newtopic = topicarray.join(" #{sep} ")
-    @bot.topic channel, newtopic
+    changetopic(m, ch, newtopic)
   end
 
   def topicappend(m, ch, txt)
@@ -150,55 +171,91 @@ class TopicPlugin < Plugin
     topicaddat(m, ch, 0, txt)
   end
 
-  def topicdel(m, channel, num)
-    sep = getsep(channel)
-    topic = @bot.channels[channel].topic.to_s
+  def topicdel(m, ch, num)
+    return if !@bot.auth.allow?("topic::edit::del", m.source, m.replyto)
+    sep = getsep(ch)
+    topic = ch.topic.text
     topicarray = topic.split(/\s+#{Regexp.escape(sep)}\s*/)
     topicarray.delete_at(num)
     newtopic = topicarray.join(" #{sep} ")
-    @bot.topic channel, newtopic
+    changetopic(m, ch, newtopic)
   end
 
-  def learntopic(m, channel)
-    return if !@bot.auth.allow?("learntopic", m.source, m.replyto)
-    topic = @bot.channels[channel].topic.to_s
-    if @registry.has_key?(channel)
-      data = @registry[channel]
+  def learntopic(m, ch)
+    return if !@bot.auth.allow?("topic::store::store", m.source, m.replyto)
+    topic = ch.topic.text
+    k = ch.downcase
+    if @registry.has_key?(k)
+      data = @registry[k]
     else
       data = Hash.new
     end
     data[:topic] = topic
-    @registry[channel] = data
+    @registry[k] = data
     m.okay
   end
 
-  def replacetopic(m, channel, num, txt)
-    return if !@bot.auth.allow?("topic", m.source, m.replyto)
-    sep = getsep(channel)
-    topic = @bot.channels[channel].topic.to_s
+  def replacetopic(m, ch, num, txt)
+    return if !@bot.auth.allow?("topic::edit::replace", m.source, m.replyto)
+    sep = getsep(ch)
+    topic = ch.topic.text
     topicarray = topic.split(/\s+#{Regexp.escape(sep)}\s*/)
     topicarray[num] = txt
     newtopic = topicarray.join(" #{sep} ")
-    @bot.topic channel, newtopic
-  end
-  
-  def restoretopic(m, channel)
-    return if !@bot.auth.allow?("restoretopic", m.source, m.replyto)
-    if @registry.has_key?(channel) && @registry[channel].has_key?(:topic)
-      topic = @registry[channel][:topic]
-      @bot.topic channel, topic
+    changetopic(m, ch, newtopic)
+  end
+
+  def restoretopic(m, ch)
+    return if !@bot.auth.allow?("topic::store::restore", m.source, m.replyto)
+    k = ch.downcase
+    if @registry.has_key?(k) && @registry[k].has_key?(:topic)
+      topic = @registry[k][:topic]
+      topicset(m, ch, topic)
+    else
+      m.reply "I don't remember any topic for #{ch}"
+    end
+  end
+
+  def topicset(m, ch, text)
+    return if !@bot.auth.allow?("topic::edit::replace", m.source, m.replyto)
+    changetopic(m, ch, text)
+  end
+
+  # This method changes the topic on channel +ch+ to +text+, storing
+  # the previous topic for undo
+  def changetopic(m, ch, text)
+    k = ch.downcase
+    if @registry.has_key?(k)
+      data = @registry[k]
     else
-      m.reply "I don't remember any topic for this channel"
+      data = Hash.new
     end
+
+    data[:oldtopic] = ch.topic.text
+    @registry[k] = data
+
+    @bot.topic ch, text
   end
 
-  def topicset(m, channel, text)
-    return if !@bot.auth.allow?("topic", m.source, m.replyto)
-    @bot.topic channel, text
+  def undotopic(m, ch)
+    k = ch.downcase
+    if @registry.has_key?(k)
+      data = @registry[k]
+      if data.has_key?(:oldtopic)
+        changetopic(m, ch, data[:oldtopic].dup)
+        return
+      end
+    end
+
+    m.reply "No recent changes were recorded for #{ch}"
   end
 
 end
 plugin = TopicPlugin.new
-plugin.map 'topic :command *text', :action => 'handletopic', :public => true, :private => false
-plugin.map 'topic :channel :command *text', :action => 'handletopic', :public => false, :private => true
+
+plugin.map 'topic :command [*text]', :action => 'handletopic', :public => true, :private => false
+plugin.map 'topic :channel :command [*text]', :action => 'handletopic', :public => false, :private => true
+
+plugin.default_auth('*', false)
+
 

data/data/rbot/plugins/translator.rb

@@ -0,0 +1,360 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Translator plugin for rbot
+#
+# Author:: Yaohan Chen <yaohan.chen@gmail.com>
+# Copyright:: (C) 2007 Yaohan Chen
+# License:: GPLv2
+#
+# This plugin allows using rbot to translate text on a few translation services
+#
+# TODO
+#
+# * Configuration for whether to show translation engine
+# * Optionally sync default translators with karma.rb ranking
+
+require 'set'
+require 'timeout'
+
+# base class for implementing a translation service
+# = Attributes
+# direction:: supported translation directions, a hash where each key is a source
+#             language name, and each value is Set of target language names. The
+#             methods in the Direction module are convenient for initializing this
+#             attribute
+class Translator
+  INFO = 'Some translation service'
+
+  class UnsupportedDirectionError < ArgumentError
+  end
+
+  class NoTranslationError < RuntimeError
+  end
+
+  attr_reader :directions, :cache
+
+  def initialize(directions, cache={})
+    @directions = directions
+    @cache = cache
+  end
+
+ 
+  # whether the translator supports this direction
+  def support?(from, to)
+    from != to && @directions[from].include?(to)
+  end
+
+  # this implements argument checking and caching. subclasses should define the
+  # do_translate method to implement actual translation
+  def translate(text, from, to)
+    raise UnsupportedDirectionError unless support?(from, to)
+    raise ArgumentError, _("Cannot translate empty string") if text.empty?
+    request = [text, from, to]
+    unless @cache.has_key? request
+      translation = do_translate(text, from, to)
+      raise NoTranslationError if translation.empty?
+      @cache[request] = translation
+    else
+      @cache[request]
+    end
+  end
+
+  module Direction
+    # given the set of supported languages, return a hash suitable for the directions
+    # attribute which includes any language to any other language
+    def self.all_to_all(languages)
+      directions = all_to_none(languages)
+      languages.each {|l| directions[l] = languages.to_set}
+      directions
+    end
+
+    # a hash suitable for the directions attribute which includes any language from/to
+    # the given set of languages (center_languages)
+    def self.all_from_to(languages, center_languages)
+      directions = all_to_none(languages)
+      center_languages.each {|l| directions[l] = languages - [l]}
+      (languages - center_languages).each {|l| directions[l] = center_languages.to_set}
+      directions
+    end
+
+    # get a hash from a list of pairs
+    def self.pairs(list_of_pairs)
+      languages = list_of_pairs.flatten.to_set
+      directions = all_to_none(languages)
+      list_of_pairs.each do |(from, to)|
+        directions[from] << to
+      end
+      directions
+    end
+
+    # an empty hash with empty sets as default values
+    def self.all_to_none(languages)
+      Hash.new do |h, k|
+        # always return empty set when the key is non-existent, but put empty set in the
+        # hash only if the key is one of the languages
+        if languages.include? k
+          h[k] = Set.new
+        else
+          Set.new
+        end
+      end
+    end
+  end
+end
+
+
+class NiftyTranslator < Translator
+  INFO = '@nifty Translation <http://nifty.amikai.com/amitext/indexUTF8.jsp>'
+
+  def initialize(cache={})
+   require 'mechanize'
+   super(Translator::Direction.all_from_to(%w[ja en zh_CN ko], %w[ja]), cache)
+    @form = WWW::Mechanize.new.
+            get('http://nifty.amikai.com/amitext/indexUTF8.jsp').
+            forms.name('translateForm').first
+  end
+
+  def do_translate(text, from, to)
+    @form.radiobuttons.name('langpair').value = "#{from},#{to}".upcase
+    @form.fields.name('sourceText').value = text
+
+    @form.submit(@form.buttons.name('translate')).
+          forms.name('translateForm').fields.name('translatedText').value
+  end
+end
+
+
+class ExciteTranslator < Translator
+  INFO = 'Excite.jp Translation <http://www.excite.co.jp/world/>'
+
+  def initialize(cache={})
+    require 'mechanize'
+    require 'iconv'
+
+    super(Translator::Direction.all_from_to(%w[ja en zh_CN zh_TW ko], %w[ja]), cache)
+
+    @forms = Hash.new do |h, k|
+      case k
+      when 'en'
+        h[k] = open_form('english')
+      when 'zh_CN', 'zh_TW'
+        # this way we don't need to fetch the same page twice
+        h['zh_CN'] = h['zh_TW'] = open_form('chinese')
+      when 'ko'
+        h[k] = open_form('korean')
+      end
+    end
+  end
+
+  def open_form(name)
+    WWW::Mechanize.new.get("http://www.excite.co.jp/world/#{name}").
+                   forms.name('world').first
+  end
+
+  def do_translate(text, from, to)
+    non_ja_language = from != 'ja' ? from : to
+    form = @forms[non_ja_language]
+
+    if non_ja_language =~ /zh_(CN|TW)/
+      form.fields.name('wb_lp').value = "#{from}#{to}".sub(/_(?:CN|TW)/, '').upcase
+      form.fields.name('big5').value = ($1 == 'TW' ? 'yes' : 'no')
+    else
+      # the en<->ja page is in Shift_JIS while other pages are UTF-8
+      text = Iconv.iconv('Shift_JIS', 'UTF-8', text) if non_ja_language == 'en'
+      form.fields.name('wb_lp').value = "#{from}#{to}".upcase
+    end
+    form.fields.name('before').value = text
+    result = form.submit.forms.name('world').fields.name('after').value
+    # the en<->ja page is in Shift_JIS while other pages are UTF-8
+    if non_ja_language == 'en'
+      Iconv.iconv('UTF-8', 'Shift_JIS', result)
+    else
+      result
+    end
+
+  end
+end
+
+
+class GoogleTranslator < Translator
+  INFO = 'Google Translate <http://www.google.com/translate_t>'
+
+  def initialize(cache={})
+    require 'mechanize'
+    load_form!
+    language_pairs = @lang_list.options.map do |o|
+      # these options have values like "en|zh-CN"; map to things like ['en', 'zh_CN'].
+      o.value.split('|').map {|l| l.sub('-', '_')}
+    end
+    super(Translator::Direction.pairs(language_pairs), cache)
+  end
+
+  def load_form!
+    agent = WWW::Mechanize.new
+    # without faking the user agent, Google Translate will serve non-UTF-8 text
+    agent.user_agent_alias = 'Linux Konqueror'
+    @form = agent.get('http://www.google.com/translate_t').
+            forms.action('/translate_t').first
+    @lang_list = @form.fields.name('langpair')
+  end
+
+  def do_translate(text, from, to)
+    load_form!
+
+    @lang_list.value = "#{from}|#{to}".sub('_', '-')
+    @form.fields.name('text').value = text
+    @form.submit.parser.search('div#result_box').inner_html
+  end
+end
+
+
+class BabelfishTranslator < Translator
+  INFO = 'AltaVista Babel Fish Translation <http://babelfish.altavista.com/babelfish/>'
+
+  def initialize(cache)
+    require 'mechanize'
+
+    @form = WWW::Mechanize.new.get('http://babelfish.altavista.com/babelfish/').
+            forms.name('frmTrText').first
+    @lang_list = @form.fields.name('lp')
+    language_pairs = @lang_list.options.map {|o| o.value.split('_')}.
+                                            reject {|p| p.empty?}
+    super(Translator::Direction.pairs(language_pairs), cache)
+  end
+
+  def do_translate(text, from, to)
+    if @form.fields.name('trtext').empty?
+      @form.add_field!('trtext', text)
+    else
+      @form.fields.name('trtext').value = text
+    end
+    @lang_list.value = "#{from}_#{to}"
+    @form.submit.parser.search("td.s/div[@style]").inner_html
+  end
+end
+
+class WorldlingoTranslator < Translator
+  INFO = 'WorldLingo Free Online Translator <http://www.worldlingo.com/en/products_services/worldlingo_translator.html>'
+
+  LANGUAGES = %w[en fr de it pt es ru nl el sv ar ja ko zh_CN zh_TW]
+  def initialize(cache)
+    require 'uri'
+    super(Translator::Direction.all_to_all(LANGUAGES), cache)
+  end
+
+  def translate(text, from, to)
+    response = Irc::Utils.bot.httputil.get_response(URI.escape(
+               "http://www.worldlingo.com/SEfpX0LV2xIxsIIELJ,2E5nOlz5RArCY,/texttranslate?wl_srcenc=utf-8&wl_trgenc=utf-8&wl_text=#{text}&wl_srclang=#{from.upcase}&wl_trglang=#{to.upcase}"))
+    # WorldLingo seems to respond an XML when error occurs
+    case response['Content-Type']
+    when %r'text/plain'
+      response.body
+    else
+      raise Translator::NoTranslationError
+    end
+  end
+end
+
+class TranslatorPlugin < Plugin
+  Config.register Config::IntegerValue.new('translator.timeout',
+    :default => 30, :validate => Proc.new{|v| v > 0},
+    :desc => _("Number of seconds to wait for the translation service before timeout"))
+
+  TRANSLATORS = {
+    'nifty' => NiftyTranslator,
+    'excite' => ExciteTranslator,
+    'google_translate' => GoogleTranslator,
+    'babelfish' => BabelfishTranslator,
+    'worldlingo' => WorldlingoTranslator,
+  }
+
+  def initialize
+    super
+
+    @translators = {}
+    TRANSLATORS.each_pair do |name, c|
+      begin
+        @translators[name] = c.new(@registry.sub_registry(name))
+        map "#{name} :from :to *phrase",
+          :action => :cmd_translate, :thread => true
+      rescue Exception
+        warning _("Translator %{name} cannot be used: %{reason}") %
+               {:name => name, :reason => $!}
+      end
+    end
+
+    Config.register Config::ArrayValue.new('translator.default_list',
+      :default => TRANSLATORS.keys,
+      :validate => Proc.new {|l| l.all? {|t| TRANSLATORS.has_key?(t)}},
+      :desc => _("List of translators to try in order when translator name not specified"),
+      :on_change => Proc.new {|bot, v| update_default})
+    update_default
+  end
+
+  def help(plugin, topic=nil)
+    if @translators.has_key?(plugin)
+      translator = @translators[plugin]
+      _('%{translator} <from> <to> <phrase> => Look up phrase using %{info}, supported from -> to languages: %{directions}') % {
+        :translator => plugin,
+        :info => translator.class::INFO,
+        :directions => translator.directions.map do |source, targets|
+                         _('%{source} -> %{targets}') %
+                         {:source => source, :targets => targets.to_a.join(', ')}
+                       end.join(' | ')
+      }
+    else
+      _('Command: <translator> <from> <to> <phrase>, where <translator> is one of: %{translators}. If "translator" is used in place of the translator name, the first translator in translator.default_list which supports the specified direction will be picked automatically. Use "help <translator>" to look up supported from and to languages') %
+        {:translators => @translators.keys.join(', ')}
+    end
+  end
+
+  def update_default
+    @default_translators = bot.config['translator.default_list'] & @translators.keys 
+  end
+
+  def cmd_translator(m, params)
+    from, to = params[:from], params[:to]
+    translator = @default_translators.find {|t| @translators[t].support?(from, to)}
+    if translator
+      cmd_translate m, params.merge({:translator => translator, :show_provider => true})
+    else
+      m.reply _('None of the default translators (translator.default_list) supports translating from %{source} to %{target}') % {:source => from, :target => to}
+    end
+  end
+
+  def cmd_translate(m, params)
+    # get the first word of the command
+    tname = params[:translator] || m.message[/\A(\w+)\s/, 1]
+    translator = @translators[tname]
+    from, to, phrase = params[:from], params[:to], params[:phrase].to_s
+    if translator
+      begin
+        translation = Timeout.timeout(@bot.config['translator.timeout']) do
+          translator.translate(phrase, from, to)
+        end
+        m.reply(if params[:show_provider]
+                  _('%{translation} (provided by %{translator})') %
+                    {:translation => translation, :translator => tname}
+                else
+                  translation
+                end)
+
+      rescue Translator::UnsupportedDirectionError
+        m.reply _("%{translator} doesn't support translating from %{source} to %{target}") %
+                {:translator => tname, :source => from, :target => to}
+      rescue Translator::NoTranslationError
+        m.reply _('%{translator} failed to provide a translation') %
+                {:translator => tname}
+      rescue Timeout::Error
+        m.reply _('The translator timed out')
+      end
+    else
+      m.reply _('No translator called %{name}') % {:name => tname}
+    end
+  end
+end
+
+plugin = TranslatorPlugin.new
+plugin.map 'translator :from :to *phrase',
+           :action => :cmd_translator, :thread => true