X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=data%2Frbot%2Fplugins%2Ftranslator.rb;h=41f4cf8e8ea73670eaef192e3d95380032847d5e;hb=8b811d21babf8f9e5a10a953b595d55ebd08820d;hp=76392ccc85c5e32ebaa2c606e0100e5ecf5e78ff;hpb=b640b14d732d457fec50b89738206a911ec9de7a;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git

diff --git a/data/rbot/plugins/translator.rb b/data/rbot/plugins/translator.rb
index 76392ccc..41f4cf8e 100644
--- a/data/rbot/plugins/translator.rb
+++ b/data/rbot/plugins/translator.rb
@@ -8,6 +8,11 @@
 # 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'
@@ -19,35 +24,47 @@ require 'timeout'
 #             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={})
+  def initialize(directions, cache={}, bot)
     @directions = directions
     @cache = cache
+    @bot = bot
   end
 
- 
   # whether the translator supports this direction
   def support?(from, to)
     from != to && @directions[from].include?(to)
   end
 
-  # this implements checking of languages and caching. subclasses should define the
+  # 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)
-    @cache[[text, from, to]] ||= do_translate(text, 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_all(languages)
+      directions = all_to_none(languages)
       languages.each {|l| directions[l] = languages.to_set}
       directions
     end
@@ -86,200 +103,201 @@ class Translator
   end
 end
 
+class YandexTranslator < Translator
+  INFO = 'Yandex Translator <http://translate.yandex.com/>'
+  LANGUAGES = %w{ar az be bg ca cs da de el en es et fi fr he hr hu hy it ka lt lv mk nl no pl pt ro ru sk sl sq sr sv tr uk}
 
-class NiftyTranslator < Translator
-  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
+  URL = 'https://translate.yandex.net/api/v1.5/tr.json/translate?key=%s&lang=%s-%s&text=%s'
+  KEY = 'trnsl.1.1.20140326T031210Z.1e298c8adb4058ed.d93278fea8d79e0a0ba76b6ab4bfbf6ac43ada72'
+  def initialize(cache, bot)
+    require 'uri'
+    require 'json'
+    super(Translator::Direction.all_to_all(LANGUAGES), cache, bot)
   end
 
-  def do_translate(text, from, to)
-    @form.radiobuttons.name('langpair').value = "#{from},#{to}".upcase
-    @form.fields.name('sourceText').value = text
+  def translate(text, from, to)
+    res = @bot.httputil.get_response(URL % [KEY, from, to, URI.escape(text)])
+    res = JSON.parse(res.body)
 
-    @form.submit(@form.buttons.name('translate')).
-          forms.name('translateForm').fields.name('translatedText').value
+    if res['code'] != 200
+      raise Translator::NoTranslationError
+    else
+      res['text'].join(' ')
+    end
   end
-end
-
 
-class ExciteTranslator < Translator
+end
 
-  def initialize(cache={})
-    require 'mechanize'
-    require 'iconv'
+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"))
+  Config.register Config::StringValue.new('translator.destination',
+    :default => "en",
+    :desc => _("Default destination language to be used with translate command"))
 
-    super(Translator::Direction.all_from_to(%w[ja en zh_CN zh_TW ko], %w[ja]), cache)
+  TRANSLATORS = {
+    'yandex' => YandexTranslator,
+  }
 
-    @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')
+  def initialize
+    super
+    @failed_translators = []
+    @translators = {}
+    TRANSLATORS.each_pair do |name, c|
+      watch_for_fail(name) do
+        @translators[name] = c.new(@registry.sub_registry(name), @bot)
+        map "#{name} :from :to *phrase",
+          :action => :cmd_translate, :thread => true
       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
 
+    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
-end
-
 
-class GoogleTranslator < Translator
-  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('-', '_')}
+  def watch_for_fail(name, &block)
+    begin
+      yield
+    rescue Exception
+      debug 'Translator error: '+$!.to_s
+      debug $@.join("\n")
+      @failed_translators << { :name => name, :reason => $!.to_s }
+
+      warning _("Translator %{name} cannot be used: %{reason}") %
+             {:name => name, :reason => $!}
+      map "#{name} [*args]", :action => :failed_translator,
+                             :defaults => {:name => name, :reason => $!}
     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
-  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)
+  def failed_translator(m, params)
+    m.reply _("Translator %{name} cannot be used: %{reason}") %
+            {:name => params[:name], :reason => params[:reason]}
   end
 
-  def do_translate(text, from, to)
-    if @form.fields.name('trtext').empty?
-      @form.add_field!('trtext', text)
+  def help(plugin, topic=nil)
+    case (topic.intern rescue nil)
+    when :failed
+      unless @failed_translators.empty?
+        failed_list = @failed_translators.map { |t| _("%{bold}%{translator}%{bold}: %{reason}") % {
+          :translator => t[:name],
+          :reason => t[:reason],
+          :bold => Bold
+        }}
+
+        _("Failed translators: %{list}") % { :list => failed_list.join(", ") }
+      else
+        _("None of the translators failed")
+      end
     else
-      @form.fields.name('trtext').value = text
+      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
+        help_str = _('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(', ')}
+
+        help_str << "\n" + _("%{bold}Note%{bold}: %{failed_amt} translators failed, see %{reverse}%{prefix}help translate failed%{reverse} for details") % {
+          :failed_amt => @failed_translators.size,
+          :bold => Bold,
+          :reverse => Reverse,
+          :prefix => @bot.config['core.address_prefix'].first
+        }
+
+        help_str
+      end
     end
-    @lang_list.value = "#{from}_#{to}"
-    @form.submit.parser.search("td.s/div[@style]").inner_html
   end
-end
-
-class TranslatorPlugin < Plugin
-  BotConfig.register BotConfigIntegerValue.new('translate.timeout',
-    :default => 30, :validate => Proc.new{|v| v > 0},
-    :desc => _("Number of seconds to wait for the translation service before timeout"))
-
-  def initialize
-    super
-    translator_classes = {
-      'nifty' => NiftyTranslator,
-      'excite' => ExciteTranslator,
-      'google_translate' => GoogleTranslator,
-      'babelfish' => BabelfishTranslator
-    }
 
-    @translators = {}
+  def languages
+    @languages ||= @translators.map { |t| t.last.directions.keys }.flatten.uniq
+  end
 
-    translator_classes.each_pair do |name, c|
-      begin
-        @translators[name] = c.new(@registry.sub_registry(name))
-        map "#{name} :from :to *phrase", :action => :cmd_translate
-      rescue
-        warning _("Translator %{name} cannot be used: %{reason}") %
-               {:name => name, :reason => $!}
-      end
-    end
+  def update_default
+    @default_translators = bot.config['translator.default_list'] & @translators.keys
   end
 
-  def help(plugin, topic=nil)
-    if @translators.has_key?(topic)
-      _('Supported directions of translation for %{translator}: %{directions}') % {
-        :translator => topic,
-        :directions => @translators[topic].directions.map do |source, targets|
-                         _('%{source} -> %{targets}') %
-                         {:source => source, :targets => targets.to_a.join(', ')}
-                       end.join(' | ')
-      }
+  def cmd_translator(m, params)
+    params[:to] = @bot.config['translator.destination'] if params[:to].nil?
+    params[:from] ||= 'auto'
+    translator = @default_translators.find {|t| @translators[t].support?(params[:from], params[:to])}
+
+    if translator
+      cmd_translate m, params.merge({:translator => translator, :show_provider => false})
     else
-      _('Command: <translator> <from> <to> <phrase>, where <translator> is one of: %{translators}. Use help <translator> to look up supported from and to languages') %
-        {:translators => @translators.keys.join(', ')}
+      m.reply _('None of the default translators (translator.default_list) supports translating from %{source} to %{target}') % {:source => params[:from], :target => params[:to]}
     end
   end
 
   def cmd_translate(m, params)
     # get the first word of the command
-    tname = m.message[/\A(\w+)\s/, 1]
+    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
-        if translator.support?(from, to)
-          translation = Timeout.timeout(@bot.config['translate.timeout']) do
+      watch_for_fail(tname) do
+        begin
+          translation = Timeout.timeout(@bot.config['translator.timeout']) do
             translator.translate(phrase, from, to)
           end
-          if translation.empty?
-            m.reply _('No translation returned')
-          else
-            m.reply translation
-          end
-        else
+          m.reply(if params[:show_provider]
+                    _('%{translation} (provided by %{translator})') %
+                      {:translation => translation, :translator => tname.gsub("_", " ")}
+                  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
-      rescue Timeout::Error
-        m.reply _('The translator timed out')
       end
     else
-      m.reply _('No translator called %{name}') % {:name => translator}
+      m.reply _('No translator called %{name}') % {:name => tname}
     end
   end
+
+  # URL translation has nothing to do with Translators so let's make it
+  # separate, and Google exclusive for now
+  def cmd_translate_url(m, params)
+    params[:to] = @bot.config['translator.destination'] if params[:to].nil?
+    params[:from] ||= 'auto'
+
+    translate_url = "http://translate.google.com/translate?sl=%{from}&tl=%{to}&u=%{url}" % {
+      :from => params[:from],
+      :to   => params[:to],
+      :url  => CGI.escape(params[:url].to_s)
+    }
+
+    m.reply(translate_url)
+  end
 end
 
 plugin = TranslatorPlugin.new
-
+req = Hash[*%w(from to).map { |e| [e.to_sym, /#{plugin.languages.join("|")}/] }.flatten]
+
+plugin.map 'translate [:from] [:to] :url',
+           :action => :cmd_translate_url, :requirements => req.merge(:url => %r{^https?://[^\s]*})
+plugin.map 'translator [:from] [:to] :url',
+           :action => :cmd_translate_url, :requirements => req.merge(:url => %r{^https?://[^\s]*})
+plugin.map 'translate [:from] [:to] *phrase',
+           :action => :cmd_translator, :thread => true, :requirements => req
+plugin.map 'translator [:from] [:to] *phrase',
+           :action => :cmd_translator, :thread => true, :requirements => req