translatomatic 0.1.1 → 0.1.2

data/lib/translatomatic/translation_result.rb

@@ -1,11 +1,14 @@
 require 'set'
 
-module Translatomatic
+module Translatomatic
+  # Stores results of a translation
   class TranslationResult
+
+    # @return [Translatomatic::ResourceFile::Base] The resource file
+    attr_reader :file
 
-    # Translation results
     # @return [Hash<String,String>] Translation results
-    attr_reader :properties
+    attr_reader :properties
 
     # @return [Locale] The locale of the original strings
     attr_reader :from_locale
@@ -17,70 +20,67 @@ module Translatomatic
     attr_reader :untranslated
 
     # Create a translation result
-    # @param [Hash<String,String>] properties Untranslated properties
-    # @param [Locale] from_locale The locale of the untranslated strings
-    # @param [Locale] to_locale The target locale
-    def initialize(properties, from_locale, to_locale)
+    # @param file [Translatomatic::ResourceFile::Base] A resource file
+    # @param to_locale [Locale] The target locale
+    def initialize(file, to_locale)
+      @file = file
       @value_to_keys = {}
       @untranslated = Set.new
-      @from_locale = from_locale
-      @to_locale = to_locale
-
-      # duplicate strings
-      @properties = properties.transform_values { |i| i.dup }
-
-      properties.each do |key, value|
-        # split property value into sentences
-        string = string(value, from_locale)
+      @from_locale = file.locale
+      @to_locale = to_locale
+
+      # duplicate strings
+      @properties = file.properties.transform_values { |i| i.dup }
+
+      @properties.each do |key, value|
+        # split property value into sentences
+        string = string(value, from_locale)
         string.sentences.each do |sentence|
           @untranslated << sentence
           keylist = (@value_to_keys[sentence.to_s] ||= [])
-          keylist << key
+          keylist << key
         end
       end
     end
 
-    # Update result with a list of translated strings.
-    # @param [Array<String>] original Original strings
-    # @param [Array<String>] translated Translated strings
+    # Update result with a list of translated strings.
+    # @param translations [Array<Translatomatic::Translation>] Translations
     # @return [void]
-    def update_strings(original, translated)
-      raise "strings length mismatch" unless original.length == translated.length
-
-      # create list of [from, to] text conversions
-      conversions = []
-      original.zip(translated).each do |text1, text2|
-        conversions << [text1, text2]
-      end
-
-      # sort conversion list by largest offset first so that we replace
+    def update_strings(translations)
+      # sort translation list by largest offset first so that we replace
       # from the end of the string to the front, so substring offsets
       # are correct in the target string.
-      conversions.sort_by! do |t1, t2|
-        t1.respond_to?(:offset) ? -t1.offset : 0
-      end
 
-      conversions.each do |text1, text2|
-        update(text1, text2)
+      #translations.sort_by! do |translation|
+      #  t1 = translation.original
+      #  t1.respond_to?(:offset) ? -t1.offset : 0
+      #end
+      translations.sort_by! { |t| -t.original.offset }
+
+      translations.each do |translation|
+        update(translation.original, translation.result)
       end
-    end
+    end
+
+    private
 
-    private
-
     include Translatomatic::Util
 
     def update(original, translated)
       keys = @value_to_keys[original.to_s]
-      raise "no key mapping for text '#{original}'" unless keys
-      keys.each do |key|
+      raise "no key mapping for text '#{original}'" unless keys
+      keys.each do |key|
+        #value = @properties[key]
         if original.kind_of?(Translatomatic::String) && original.substring?
-          @properties[key][original.offset, original.length] = translated
-        else
-          @properties[key] = translated
-        end
+          #log.debug("#{value[original.offset, original.length]} -> #{translated}")
+          @properties[key][original.offset, original.length] = translated
+        else
+          #log.debug("#{key} -> #{translated}")
+          @properties[key] = translated
+        end
       end
 
-      @untranslated.delete(original)
+      @untranslated.delete(original) unless translated.nil?
     end
   end
 end

data/lib/translatomatic/translator/base.rb

@@ -1,83 +1,128 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-    # @abstract
-    class Base
-
-      class << self
-        attr_reader :options
-        private
-        include Translatomatic::DefineOptions
-      end
-
-      # @private
-      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 [Array<String>] strings A list of strings to translate.
-      # @param [String, Translatomatic::Locale] from The locale of the given strings.
-      # @param [String, Translatomatic::Locale] to The locale to translate to.
-      # @return [Array<String>] Translated strings
-      def translate(strings, from, to)
-        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
-
-      # 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.
-      # (subclass must implement fetch_translation if this method is used)
-      def perform_fetch_translations(url, strings, from, to)
-        translated = []
-        request = Translatomatic::HTTPRequest.new(url)
-        request.start do |http|
-          strings.each do |string|
-            result = fetch_translation(request, string, from, to)
-            translated << result
-            update_translated(result)
-          end
-        end
-        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
-
-    end
-  end
-end
+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)
+
+        while !untranslated.empty?  # request start block
+          fail_count = 0  # number of consecutive translation failures
+
+          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,57 +1,62 @@
-require 'net/http'
-
-module Translatomatic
-  module Translator
-
-    class Frengly < Base
-
-      define_options({
-        name: :frengly_api_key, desc: "Frengly API key", use_env: true
-      },
-      { name: :frengly_email, desc: "Email address", use_env: true
-      },
-      { name: :frengly_password, desc: "Password", use_env: true
-        })
-
-        # 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 "email address required" unless @email
-        raise "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
+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,31 +1,35 @@
-module Translatomatic
-  module Translator
-
-    class Google < Base
-
-      define_options({ name: :google_api_key, desc: "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 "google api 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)
-        EasyTranslate.translate(strings, from: from.language, to: to.language)
-      end
-
-    end # class
-  end   # module
-end
+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,33 +1,41 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-
-    class Microsoft < Base
-
-      define_options({
-        name: :microsoft_api_key, desc: "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 "microsoft api 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)
-        @impl.translate_array(strings, from: from.language, to: to.language)
-      end
-
-    end
-  end
-end
+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