translatomatic 0.1.0

data/lib/translatomatic/resource_file/properties.rb

@@ -0,0 +1,60 @@
+module Translatomatic::ResourceFile
+  class Properties < Base
+
+    def self.extensions
+      %w{properties}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#initialize)
+    def initialize(path, locale = nil)
+      super(path, locale)
+      @valid = true
+      @properties = @path.exist? ? read(@path) : {}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#save(target))
+    def save(target = path)
+      out = ""
+      properties.each do |key, value|
+        # TODO: maintain original line ending format?
+        value = value.gsub("\n", "\\n")  # convert newlines to \n
+        out += "#{key} = #{value}\n"
+      end
+      # escape unicode characters
+      out = Translatomatic::EscapedUnicode.escape(out)
+      target.write(out)
+    end
+
+    private
+
+    # parse key = value property file
+    def read(path)
+      contents = path.read
+      # convert escaped unicode characters into unicode
+      contents = Translatomatic::EscapedUnicode.unescape(contents)
+      result = {}
+      contents.gsub!(/\\\s*\n\s*/m, '')  # put multi line strings on one line
+      lines = contents.split("\n")
+
+      lines.each do |line|
+        line.strip!
+        next if line.length == 0
+        equal_idx = line.index("=")
+
+        if line[0] == ?! || line[0] == ?#
+          # comment
+          # TODO: translate comments or keep originals?
+          next
+        elsif equal_idx.nil?
+          @valid = false
+          return {}
+        end
+        name, value = line.split(/\s*=\s*/, 2)
+        value = value.gsub("\\n", "\n")      # convert \n to newlines
+        result[name] = value
+      end
+      result
+    end
+
+  end
+end

data/lib/translatomatic/resource_file/text.rb

@@ -0,0 +1,28 @@
+module Translatomatic::ResourceFile
+  class Text < Base
+
+    def self.extensions
+      %w{txt md text}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#initialize)
+    def initialize(path, locale = nil)
+      super(path, locale)
+      @valid = true
+      @properties = @path.exist? ? read(@path) : {}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#save(target))
+    def save(target = path)
+      values = @properties.values.collect { |i| i.strip + "\n" }
+      target.write(values.join)
+    end
+
+    private
+
+    def read(path)
+      text = path.read
+      { "text" => text }
+    end
+  end
+end

data/lib/translatomatic/resource_file/xcode_strings.rb

@@ -0,0 +1,65 @@
+module Translatomatic::ResourceFile
+
+  # XCode strings file
+  # @see https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/LoadingResources/Strings/Strings.html
+  class XCodeStrings < Base
+
+    def self.extensions
+      %w{strings}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#initialize)
+    def initialize(path, locale = nil)
+      super(path, locale)
+      @valid = true
+      @properties = @path.exist? ? read(@path) : {}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#locale_path)
+    # @note localization files in XCode use the following file name
+    #   convention: Project/locale.lproj/filename
+    def locale_path(locale)
+      if path.to_s.match(/\/([-\w]+).lproj\/.+.strings$/)
+        # xcode style
+        filename = path.basename
+        path.parent.parent + (locale.to_s + ".lproj") + filename
+      else
+        super(locale)
+      end
+    end
+
+    # (see Translatomatic::ResourceFile::Base#save(target))
+    def save(target = path)
+      out = ""
+      properties.each do |key, value|
+        key = escape(key)
+        value = escape(value)
+        out += %Q{"#{key}" = "#{value}";\n}
+      end
+      target.write(out)
+    end
+
+    private
+
+    def read(path)
+      result = {}
+      content = path.read
+      uncommented = content.gsub(/\/\*.*?\*\//, '')
+      key_values = uncommented.scan(/"(.*?[^\\])"\s*=\s*"(.*?[^\\])"\s*;/m)
+      key_values.each do |entry|
+        key, value = entry
+        result[unescape(key)] = unescape(value)
+      end
+      result
+    end
+
+    def unescape(string)
+      string ? string.gsub(/\\(["'])/) { |i| i } : ''
+    end
+
+    def escape(string)
+      string ? string.gsub(/["']/) { |i| "\\#{i}" } : ''
+    end
+
+  end
+end

data/lib/translatomatic/resource_file/xml.rb

@@ -0,0 +1,64 @@
+module Translatomatic::ResourceFile
+  class XML < Base
+
+    def self.extensions
+      %w{xml}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#initialize)
+    def initialize(path, locale = nil)
+      super(path, locale)
+      @valid = true
+      @properties = @path.exist? ? read(@path) : {}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#set)
+    def set(key, value)
+      super(key, value)
+      @nodemap[key].content = value if @nodemap.include?(key)
+    end
+
+    # (see Translatomatic::ResourceFile::Base#save(target))
+    def save(target = path)
+      target.write(@doc.to_xml) if @doc
+    end
+
+    private
+
+    # initialize nodemap from nokogiri document
+    # returns property hash
+    def init_nodemap(doc)
+      # map of key1 => node, key2 => node, ...
+      @nodemap = flatten_xml(doc)
+      # map of key => node content
+      @nodemap.transform_values { |v| v.content }
+    end
+
+    # parse key = value property file
+    def read(path)
+      begin
+        # parse xml with nokogiri
+        @doc = Nokogiri::XML(path.open) do |config|
+          config.noblanks
+        end
+        init_nodemap(@doc)
+      rescue Exception
+        @valid = false
+        {}
+      end
+    end
+
+    def flatten_xml(doc)
+      result = {}
+      text_nodes = doc.search(text_nodes_xpath)
+      text_nodes.each_with_index do |node, i|
+        result["key#{i + 1}"] = node
+      end
+      result
+    end
+
+    def text_nodes_xpath
+      '//text()'
+    end
+  end # class
+end   # module

data/lib/translatomatic/resource_file/yaml.rb

@@ -0,0 +1,80 @@
+require 'yaml'
+
+module Translatomatic::ResourceFile
+  class YAML < Base
+
+    def self.extensions
+      %w{yml yaml}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#initialize)
+    def initialize(path, locale = nil)
+      super(path, locale)
+      @valid = true
+      @data = {}
+      @properties = @path.exist? ? read : {}
+    end
+
+    # (see Translatomatic::ResourceFile::Base#locale_path)
+    # @note localization files in rails use the following file name
+    #   convention: config/locales/en.yml.
+    def locale_path(locale)
+      if path.to_s.match(/config\/locales\/[-\w]+.yml$/)
+        # rails style
+        filename = locale.to_s + path.extname
+        path.dirname + filename
+      else
+        super(locale)
+      end
+    end
+
+    # (see Translatomatic::ResourceFile::Base#set)
+    def set(key, value)
+      super(key, value)
+
+      hash = @data
+      path = key.split(/\./)
+      last_key = path.pop
+      path.each { |i| hash = (hash[i] ||= {}) }
+      hash[last_key] = value
+    end
+
+    # (see Translatomatic::ResourceFile::Base#save(target))
+    def save(target = path)
+      out = @data.to_yaml
+      out.sub!(/^---\n/m, '')
+      target.write(out)
+    end
+
+    private
+
+    def read
+      begin
+        @data = ::YAML.load_file(@path) || {}
+        flatten_data(@data)
+      rescue Exception
+        @valid = false
+        {}
+      end
+    end
+
+    def flatten_data(data)
+      result = {}
+      unless data.kind_of?(Hash)
+        @valid = false
+        return {}
+      end
+      data.each do |key, value|
+        if value.kind_of?(Hash)
+          children = flatten_data(value)
+          children.each do |ck, cv|
+            result[key + "." + ck] = cv
+          end
+        else
+          result[key] = value
+        end
+      end
+      result
+    end
+  end
+end

data/lib/translatomatic/resource_file.rb

@@ -0,0 +1,74 @@
+
+module Translatomatic
+  module ResourceFile
+    class << self
+      include Translatomatic::Util
+    end
+
+    # Load a resource file. If locale is not specified, the locale of the
+    # file will be determined from the filename, or else the current default
+    # locale will be used.
+    # @param [String] path Path to the resource file
+    # @param [String] locale Locale of the resource file
+    # @return [Translatomatic::ResourceFile::Base] The resource file, or nil
+    #   if the file type is unsupported.
+    def self.load(path, locale = nil)
+      path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      modules.each do |mod|
+        # match on entire filename to support extensions containing locales
+        if extension_match(mod, path)
+          log.debug("attempting to load #{path.to_s} using #{mod.name.demodulize}")
+          file = mod.new(path, locale)
+          return file if file.valid?
+        end
+      end
+      nil
+    end
+
+    # Find all resource files under the given directory. Follows symlinks.
+    # @param [String, Pathname] path The path to search from
+    # @return [Array<Translatomatic::ResourceFile>] Resource files found
+    def self.find(path, options = {})
+      files = []
+      include_dot_directories = options[:include_dot_directories]
+      path = Pathname.new(path) unless path.kind_of?(Pathname)
+      path.find do |file|
+        if !include_dot_directories && file.basename.to_s[0] == ?.
+          Find.prune
+        else
+          resource = load(file)
+          files << resource if resource
+        end
+      end
+      files
+    end
+
+    # Find all configured resource file classes
+    # @return [Array<Class>] Available resource file classes
+    def self.modules
+      self.constants.map { |c| self.const_get(c) }.select do |klass|
+        klass.is_a?(Class) && klass != Base
+      end
+    end
+
+    private
+
+    def self.extension_match(mod, path)
+      filename = path.basename.to_s.downcase
+      mod.extensions.each do |extension|
+        # don't match end of line in case file has locale extension
+        return true if filename.match(/\.#{extension}/)
+      end
+      false
+    end
+  end
+end
+
+require 'translatomatic/resource_file/base'
+require 'translatomatic/resource_file/yaml'
+require 'translatomatic/resource_file/properties'
+require 'translatomatic/resource_file/text'
+require 'translatomatic/resource_file/xml'
+require 'translatomatic/resource_file/html'
+require 'translatomatic/resource_file/plist'
+require 'translatomatic/resource_file/xcode_strings'

data/lib/translatomatic/translation_result.rb

@@ -0,0 +1,68 @@
+require 'set'
+
+module Translatomatic
+  class TranslationResult
+
+    # Translation results
+    # @return [Hash<String,String>] Translation results
+    attr_reader :properties
+
+    # @return [Locale] The locale of the original strings
+    attr_reader :from_locale
+
+    # @return [Locale] The target locale
+    attr_reader :to_locale
+
+    # @return [Set<String>] Untranslated strings
+    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)
+      @properties = properties.dup
+      @value_to_keys = {}
+      @untranslated = Set.new
+      properties.each do |key, value|
+        @untranslated << value
+        keylist = (@value_to_keys[value] ||= [])
+        keylist << key
+      end
+      @from_locale = from_locale
+      @to_locale = to_locale
+    end
+
+    # Update result with a list of translated strings.
+    # @param [Array<String>] original Original strings
+    # @param [Array<String>] translated Translated strings
+    # @return [void]
+    def update_strings(original, translated)
+      raise "strings length mismatch" unless original.length == translated.length
+      original.zip(translated).each do |text1, text2|
+        update(text1, text2)
+      end
+    end
+
+    # Update result with texts from the database.
+    # @param [Array<Translatomatic::Model::Text>] list Texts from database
+    # @return [void]
+    def update_db_strings(list)
+      list.each do |t|
+        original = t.from_text.value
+        translated = t.value
+        update(original, translated)
+      end
+    end
+
+    private
+
+    def update(original, translated)
+      keys = @value_to_keys[original]
+      raise "no key mapping for text '#{original}'" unless keys
+      keys.each { |key| @properties[key] = translated }
+
+      @untranslated.delete(original)
+    end
+  end
+end

data/lib/translatomatic/translator/base.rb

@@ -0,0 +1,47 @@
+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

data/lib/translatomatic/translator/frengly.rb

@@ -0,0 +1,64 @@
+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

data/lib/translatomatic/translator/google.rb

@@ -0,0 +1,30 @@
+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

data/lib/translatomatic/translator/microsoft.rb

@@ -0,0 +1,32 @@
+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

data/lib/translatomatic/translator/my_memory.rb

@@ -0,0 +1,55 @@
+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