translatomatic 0.1.0 → 0.1.1

data/lib/translatomatic/translator/base.rb

@@ -1,47 +1,83 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-    @abstract
-    class Base
-
-      class << self
-        attr_reader :options
-        private
-        include Translatomatic::DefineOptions
-      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, Locale] from The locale of the given strings.
-      # @param [String, 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 = parse_locale(from) if from.kind_of?(String)
-        to = parse_locale(to) if to.kind_of?(String)
-        return strings if from.language == to.language
-        perform_translate(strings, from, to)
-      end
-
-      private
-
-      include Translatomatic::Util
-
-      def perform_translate(strings, from, to)
-        raise "subclasses must implement perform_translate"
-      end
-
-    end
-  end
-end
+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

data/lib/translatomatic/translator/frengly.rb

@@ -1,64 +1,57 @@
-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 = {})
-        @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)
-        translated = []
-        uri = URI.parse(URL)
-
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          strings.each do |string|
-            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
-            req = Net::HTTP::Post.new(uri)
-            req.body = body
-            req.content_type = 'application/json'
-            response = http.request(req)
-            raise response.body unless response.kind_of? Net::HTTPSuccess
-            data = JSON.parse(response.body)
-            translated << data['text']
-          end
-          translated
-        end
-      end
-
-    end # class
-  end   # module
-end
+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

data/lib/translatomatic/translator/google.rb

@@ -1,30 +1,31 @@
-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 = {})
-        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
+
+    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

data/lib/translatomatic/translator/microsoft.rb

@@ -1,32 +1,33 @@
-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 = {})
-        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
+
+    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

data/lib/translatomatic/translator/my_memory.rb

@@ -1,55 +1,64 @@
-require 'bing_translator'
-
-module Translatomatic
-  module Translator
-
-    class MyMemory < Base
-
-      define_options(
-        { name: :mymemory_api_key, desc: "MyMemory API key", use_env: true },
-        { name: :mymemory_email, desc: "Email address", use_env: true }
-        )
-
-      # Create a new MyMemory translator instance
-      def initialize(options = {})
-        @key = options[:mymemory_api_key] || ENV["MYMEMORY_API_KEY"]
-        @email = options[:mymemory_email] || ENV["MYMEMORY_EMAIL"]
-      end
-
-      # TODO: implement language list
-      # (see Translatomatic::Translator::Base#languages)
-      #def languages
-      #end
-
-      private
-
-      URL = 'https://api.mymemory.translated.net/get'
-
-      def perform_translate(strings, from, to)
-        translated = []
-        uri = URI.parse(URL)
-
-        http_options = { use_ssl: uri.scheme == "https" }
-        Net::HTTP.start(uri.host, uri.port, http_options) do |http|
-          strings.each do |string|
-            query = {
-              langpair: from.to_s + "|" + to.to_s,
-              q: string
-            }
-            query.merge!(de: @email) if @email
-            query.merge!(key: @key) if @key
-            uri.query = URI.encode_www_form(query)
-
-            req = Net::HTTP::Get.new(uri)
-            response = http.request(req)
-            raise response.body unless response.kind_of? Net::HTTPSuccess
-            data = JSON.parse(response.body)
-            translated << data['responseData']['translatedText']
-          end
-          translated
-        end
-      end
-
-    end
-  end
-end
+require 'bing_translator'
+
+module Translatomatic
+  module Translator
+
+    class MyMemory < Base
+
+      define_options(
+        { name: :mymemory_api_key, desc: "MyMemory API key", use_env: true },
+        { name: :mymemory_email, desc: "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 [Translatomatic::TMX::Document] TMX document
+      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("share response: #{response.body}")
+        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
+          }.merge(@query_options)
+        )
+        data = JSON.parse(response.body)
+        data['responseData']['translatedText']
+      end
+    end
+  end
+end

data/lib/translatomatic/translator/yandex.rb

@@ -1,37 +1,39 @@
-require 'yandex-translator'
-
-module Translatomatic
-  module Translator
-
-    class Yandex < Base
-
-      define_options({
-        name: :yandex_api_key, desc: "Yandex API key", use_env: true
-        })
-
-      # Create a new Yandex translator instance
-      def initialize(options = {})
-        key = options[:yandex_api_key] || ENV["YANDEX_API_KEY"]
-        raise "yandex api key required" if key.nil?
-        @impl = ::Yandex::Translator.new(key)
-      end
-
-      # (see Translatomatic::Translator::Base#languages)
-      def languages
-        @languages ||= @impl.langs.collect { |i| i[0, 2] }.uniq
-      end
-
-      private
-
-      def perform_translate(strings, from, to)
-        translated = []
-        strings.each do |string|
-          result = @impl.translate(string, from: from.language, to: to.language) || ""
-          translated.push(result)
-        end
-        translated
-      end
-
-    end # class
-  end   # module
-end
+require 'yandex-translator'
+
+module Translatomatic
+  module Translator
+
+    class Yandex < Base
+
+      define_options({
+        name: :yandex_api_key, desc: "Yandex API key", use_env: true
+        })
+
+      # Create a new Yandex translator instance
+      def initialize(options = {})
+        super(options)
+        key = options[:yandex_api_key] || ENV["YANDEX_API_KEY"]
+        raise "yandex api key required" if key.nil?
+        @impl = ::Yandex::Translator.new(key)
+      end
+
+      # (see Translatomatic::Translator::Base#languages)
+      def languages
+        @languages ||= @impl.langs.collect { |i| i[0, 2] }.uniq
+      end
+
+      private
+
+      def perform_translate(strings, from, to)
+        translated = []
+        strings.each do |string|
+          result = @impl.translate(string, from: from.language, to: to.language) || ""
+          translated.push(result)
+          update_translated(result)
+        end
+        translated
+      end
+
+    end # class
+  end   # module
+end