translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/translator/base.rb

@@ -1,128 +0,0 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-
-    # Base class for interfaces to translation APIs
-    # @abstract
-    class Base
-      include Translatomatic::DefineOptions
-
-      # Listener for translation events
-      attr_accessor :listener
-
-      def initialize(options = {})
-        @listener = options[:listener]
-      end
-
-      # @return [String] The name of this translator.
-      def name
-        self.class.name.demodulize
-      end
-
-      # @return [Array<String>] A list of languages supported by this translator.
-      def languages
-        []
-      end
-
-      # Translate strings from one locale to another
-      # @param strings [Array<String>] A list of strings to translate.
-      # @param from [String, Translatomatic::Locale] The locale of the given strings.
-      # @param to [String, Translatomatic::Locale] The locale to translate to.
-      # @return [Array<String>] Translated strings
-      def translate(strings, from, to)
-        @updated_listener = false
-        strings = [strings] unless strings.kind_of?(Array)
-        from = locale(from)
-        to = locale(to)
-        return strings if from.language == to.language
-        translated = perform_translate(strings, from, to)
-        update_translated(translated) unless @updated_listener
-        translated
-      end
-
-      private
-
-      include Translatomatic::Util
-
-      TRANSLATION_RETRIES = 3
-
-      # Fetch translations for the given strings, one at a time, by
-      # opening a http connection to the given url and calling
-      # fetch_translation() on each string. Error handling and recovery
-      # is performed by this method.
-      # (subclass must implement fetch_translation if this method is used)
-      def perform_fetch_translations(url, strings, from, to)
-        translated = []
-        untranslated = strings.dup
-        request = Translatomatic::HTTPRequest.new(url)
-        fail_count = 0  # number of consecutive translation failures
-
-        while !untranslated.empty?  # request start block
-
-          request.start do |http|
-            while !untranslated.empty?
-              # get next string to translate
-              string = untranslated[0]
-              begin
-                # fetch translation
-                result = fetch_translation(request, string, from, to)
-
-                # successful translation
-                fail_count = 0  # reset fail count
-                translated << result
-                update_translated(result)
-                untranslated.shift
-
-              rescue Exception => e
-                # translation error
-                log.error(e)
-                fail_count += 1
-                if fail_count >= TRANSLATION_RETRIES
-                  raise e  # re-raise exception
-                else
-                  # need to restart http connection
-                  # break back out to request.start block
-                  break
-                end
-              end  # exception
-            end    # while untranslated
-          end      # request.start
-        end        # while untranslated
-
-        translated
-      end
-
-      def fetch_translation(request, strings, from, to)
-        raise "subclass must implement fetch_translation"
-      end
-
-      def update_translated(texts)
-        texts = [texts] unless texts.kind_of?(Array)
-        @updated_listener = true
-        @listener.translated_texts(texts) if @listener
-      end
-
-      def perform_translate(strings, from, to)
-        raise "subclass must implement perform_translate"
-      end
-
-      # Attempt to run a block of code up to retries times.
-      # Reraises the exception if the block fails retries times.
-      # @param retries [Number] The maximum number of times to run
-      # @return [Object] the return value of the block
-      def attempt_with_retries(retries)
-        fail_count = 0
-        begin
-          yield
-        rescue Exception => e
-          log.error(e.message)
-          fail_count += 1
-          retry if fail_count < retries
-          raise e
-        end
-      end
-
-    end
-  end
-end

data/lib/translatomatic/translator/frengly.rb

@@ -1,62 +0,0 @@
-require 'net/http'
-
-module Translatomatic
-  module Translator
-
-    # Interface to the Frengly translation API
-    # @see http://www.frengly.com/api
-    class Frengly < Base
-
-      define_options({
-        name: :frengly_api_key, use_env: true,
-        desc: t("translator.frengly_api_key"),
-      },
-      { name: :frengly_email, use_env: true,
-        desc: t("translator.email_address")
-      },
-      { name: :frengly_password, use_env: true,
-        desc: t("translator.password")
-        })
-
-        # Create a new Frengly translator instance
-      def initialize(options = {})
-        super(options)
-        @key = options[:frengly_api_key] || ENV["FRENGLY_API_KEY"] # optional
-        @email = options[:frengly_email]
-        @password = options[:frengly_password]
-        raise t("translator.email_required") unless @email
-        raise t("translator.password_required") unless @password
-      end
-
-      # (see Translatomatic::Translator::Base#languages)
-      def languages
-        ['en','fr','de','es','pt','it','nl','tl','fi','el','iw','pl','ru','sv']
-      end
-
-      private
-
-      URL = 'http://frengly.com/frengly/data/translateREST'
-
-      def perform_translate(strings, from, to)
-        perform_fetch_translations(URL, strings, from, to)
-      end
-
-      def fetch_translation(request, string, from, to)
-        body = {
-          src: from.language,
-          dest: to.language,
-          text: string,
-          email: @email,
-          password: @password,
-          premiumkey: @key
-        }.to_json
-
-        # TODO: work out what the response looks like
-        response = request.post(body, content_type: 'application/json')
-        data = JSON.parse(response.body)
-        data['text']
-      end
-
-    end # class
-  end   # module
-end

data/lib/translatomatic/translator/google.rb

@@ -1,37 +0,0 @@
-require 'easy_translate'
-
-module Translatomatic
-  module Translator
-
-    # Interface to the Google translation API
-    # @see https://cloud.google.com/translate/
-    class Google < Base
-
-      define_options(name: :google_api_key,
-        desc: t("translator.google_api_key"), use_env: true
-      )
-
-      # Create a new Google translator instance
-      def initialize(options = {})
-        super(options)
-        key = options[:google_api_key] || ENV["GOOGLE_API_KEY"]
-        raise t("translator.google_key_required") if key.nil?
-        EasyTranslate.api_key = key
-      end
-
-      # (see Translatomatic::Translator::Base#languages)
-      def languages
-        EasyTranslate::LANGUAGES.keys
-      end
-
-      private
-
-      def perform_translate(strings, from, to)
-        attempt_with_retries(3) do
-          EasyTranslate.translate(strings, from: from.language, to: to.language)
-        end
-      end
-
-    end # class
-  end   # module
-end

data/lib/translatomatic/translator/microsoft.rb

@@ -1,41 +0,0 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-
-    # Interface to the Microsoft translation API
-    # @see https://www.microsoft.com/en-us/translator/translatorapi.aspx
-    class Microsoft < Base
-
-      define_options({
-        name: :microsoft_api_key, desc: t("translator.microsoft_api_key"), use_env: true
-        })
-
-      # Create a new Microsoft translator instance
-      def initialize(options = {})
-        super(options)
-        key = options[:microsoft_api_key] || ENV["MICROSOFT_API_KEY"]
-        raise t("translator.microsoft_key_required") if key.nil?
-        @impl = BingTranslator.new(key)
-      end
-
-      # TODO: implement language list
-      # (see Translatomatic::Translator::Base#languages)
-      #def languages
-      #end
-
-      private
-
-      def perform_translate(strings, from, to)
-        attempt_with_retries(3) do
-          translations = @impl.translate_array(strings,
-            from: from.language,
-            to: to.language
-          )
-          translations.collect { |i| i.to_s }
-        end
-      end
-
-    end
-  end
-end

data/lib/translatomatic/translator/my_memory.rb

@@ -1,68 +0,0 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-
-    # Interface to the MyMemory translation API
-    # @see https://mymemory.translated.net/doc/
-    class MyMemory < Base
-
-      define_options(
-        { name: :mymemory_api_key, desc: t("translator.mymemory_api_key"), use_env: true },
-        { name: :mymemory_email, desc: t("translator.email_address"), use_env: true }
-      )
-
-      # Create a new MyMemory translator instance
-      def initialize(options = {})
-        super(options)
-        @key = options[:mymemory_api_key] || ENV["MYMEMORY_API_KEY"]
-        @email = options[:mymemory_email] || ENV["MYMEMORY_EMAIL"]
-        @query_options = {}
-        @query_options.merge!(de: @email) if @email
-        @query_options.merge!(key: @key) if @key
-      end
-
-      # TODO: implement language list
-      # (see Translatomatic::Translator::Base#languages)
-      #def languages
-      #end
-
-      # Upload a set of translations to MyMemory
-      # @param tmx [Translatomatic::TMX::Document] TMX document
-      # @return [void]
-      def upload(tmx)
-        request = Translatomatic::HTTPRequest.new(UPLOAD_URL)
-        request.start do |http|
-          body = [
-            request.file(key: :tmx, filename: "import.tmx",
-              content: tmx.to_xml, mime_type: "application/xml"
-            ),
-            request.param(key: :private, value: 0)
-          ]
-          response = request.post(body, multipart: true)
-          log.debug(t("translator.share_response",
-            response: response.body.inspect))
-        end
-      end
-
-      private
-
-      GET_URL = 'https://api.mymemory.translated.net/get'
-      UPLOAD_URL = 'https://api.mymemory.translated.net/tmx/import'
-
-      def perform_translate(strings, from, to)
-        perform_fetch_translations(GET_URL, strings, from, to)
-      end
-
-      def fetch_translation(request, string, from, to)
-        response = request.get({
-            langpair: from.to_s + "|" + to.to_s,
-            q: string  # multiple q strings not supported (tested 20180101)
-          }.merge(@query_options)
-        )
-        data = JSON.parse(response.body)
-        data['responseData']['translatedText']
-      end
-    end
-  end
-end

data/lib/translatomatic/translator/yandex.rb

@@ -1,56 +0,0 @@
-module Translatomatic
-  module Translator
-
-    # Interface to the Yandex translation API
-    # @see https://tech.yandex.com/translate/
-    class Yandex < Base
-
-      define_options({
-        name: :yandex_api_key, desc: t("translator.yandex_api_key"), use_env: true
-        })
-
-      # Create a new Yandex translator instance
-      def initialize(options = {})
-        super(options)
-        @api_key = options[:yandex_api_key] || ENV["YANDEX_API_KEY"]
-        raise t("translator.yandex_key_required") if @api_key.nil?
-      end
-
-      # (see Translatomatic::Translator::Base#languages)
-      def languages
-        @languages ||= begin
-          request = Translatomatic::HTTPRequest.new(LANGUAGES_URL)
-          response = request.post(key: @api_key, ui: "en")
-          data = JSON.parse(response.body) || {}
-          langs = data["langs"] || {}
-          langs.keys.flatten.uniq
-        end
-      end
-
-      private
-
-      TRANSLATE_URL = 'https://translate.yandex.net/api/v1.5/tr.json/translate'
-      LANGUAGES_URL = 'https://translate.yandex.net/api/v1.5/tr.json/getLangs'
-
-      def perform_translate(strings, from, to)
-        attempt_with_retries(3) do
-          fetch_translations(strings, from, to)
-        end
-      end
-
-      def fetch_translations(strings, from, to)
-        request = Translatomatic::HTTPRequest.new(TRANSLATE_URL)
-        body = {
-          key: @api_key,
-          text: strings,
-          lang: from.language + "-" + to.language,
-          format: "plain"
-        }
-        response = request.post(body)
-        data = JSON.parse(response.body)
-        data['text']
-      end
-
-    end # class
-  end   # module
-end