tr8n_core 4.0.17 → 4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 470f4942f0fab2b30f5a0d7b712ae1a23794303c
-  data.tar.gz: b7066bedabf3daa74aaad31d11ca3cb8bf76b45b
+  metadata.gz: 0baac64dd209fa38abfdbd9e9b74dc73a8bef620
+  data.tar.gz: 9c3aee8e89c3aad83151f5ce1ec5970d96de34e5
 SHA512:
-  metadata.gz: 2d17fb49dd55b1f0fd6e6798060dc6e90694f3e77bec6771fa00ef41aae6b0b446a4e6f331db0ee0f67a0b99890a7085c6a1d502160c52cfb37a18da3967425f
-  data.tar.gz: 86a847db7c7af547f2c036d3b38c0eb2c51bd13b3310cfc2f565f9f2997c01f0768b61348f951699ecb482346ce643a048442a410a9c92cb12dbcb6be429c8c0
+  metadata.gz: b8c57324b77a158776980bcbac2d4d439d150105aa2fabf3baeaf33c6f920ad04f7d064d263ed6e1f7db23cbaed62601bff4a5ea6b264f0f66b6d38aa5d7c78d
+  data.tar.gz: 1eb5e3b4a46aa22dbf63a99ae85755ac821e22bcb84f9e14206162d1cc447c644e79c0fe199123a12dec6e06f1c5338af4dc44e9027333030a8c63762bfc5f3d

data/README.md

@@ -13,8 +13,8 @@ Tr8n Core Library For Ruby
 Tr8n core library for Ruby is a set of classes that provide translation functionality for any Ruby based application.
 The library uses Tr8n's TML (Translation Markup Language) that allows you to encode complex language structures in simple, yet powerful forms.
 
-The library works in conjunctions with tr8nhub.com service that provides machine and human translations for your application.
-In order to use the library, you should sign up at tr8nhub.com, create a new application and copy the application key and secret.
+The library works in conjunctions with TranslationExchange.com service that provides machine and human translations for your application.
+In order to use the library, you should sign up at TranslationExchange.com, create a new application and copy the application key and secret.
 
 
 Rails Integration
@@ -38,7 +38,7 @@ gem install tr8n_core
 Registering Your App
 ===================================
 
-Before you can proceed with the integration, please register with https://translationexchange.com and create a new application.
+Before you can proceed with the integration, please register with http://translationexchange.com and create a new application.
 
 At the end of the registration process you will be given a key and a secret. You will need to enter them in the initialization function of the Tr8n SDK.
 
@@ -208,23 +208,21 @@ irb(main)> russian.translate('This is a new phrase without translations')
 Links
 ==================
 
-* Register on TranslationExchange.com: https://translationexchange.com
+* Register on TranslationExchange.com: http://translationexchange.com
 
-* Read TranslationExchange's documentation: http://wiki.tr8nhub.com
-
-* Visit TranslationExchange's blog: http://blog.tr8nhub.com
+* Read TranslationExchange's documentation: http://translationexchange.com/docs
 
 * Follow TranslationExchange on Twitter: https://twitter.com/translationx
 
 * Connect with TranslationExchange on Facebook: https://www.facebook.com/translationexchange
 
-* If you have any questions or suggestions, contact us: info@translationexchange.com
+* If you have any questions or suggestions, contact us: feedback@translationexchange.com
 
 
 Copyright and license
 ==================
 
-Copyright (c) 2014 Michael Berkovich, TranslationExchange.com
+Copyright (c) 2015 Translation Exchange, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/tr8n/{api_client.rb → api/client.rb}

@@ -32,38 +32,39 @@
 
 require 'faraday'
 
-class Tr8n::ApiClient < Tr8n::Base
-  API_HOST = 'https://translationexchange.com'
-  API_PATH = '/tr8n/api/'
+class Tr8n::Api::Client < Tr8n::Base
+  API_HOST = 'https://api.translationexchange.com'
+  API_PATH = '/v1'
 
   attributes :application
 
   def access_token
     application.access_token ||= begin
-      api("oauth/request_token",
-        {
-            :client_id => application.key,
-            :client_secret => application.secret,
-            :grant_type => :client_credentials
-        },
-        {
-            :host => application.host
-        }
-      )
+      Tr8n.cache.fetch("#{application.key}/access_token") do
+        api('oauth/token', {
+          :client_id      => application.key,
+          :client_secret  => application.secret,
+          :grant_type     => :client_credentials
+        }, {:method => :post})
+      end
     end
-    application.access_token["access_token"]
+    application.access_token['access_token']
+  end
+
+  def results(path, params = {}, opts = {})
+    get(path, params, opts)['results']
   end
 
   def get(path, params = {}, opts = {})
-    api(path, params.merge(:client_id => application.key, :t => Time.now.to_i), opts.merge(:method => :get))
+    api(path, params, opts.merge(:method => :get))
   end
 
   def post(path, params = {}, opts = {})
-    api(path, params.merge(:access_token => access_token, :t => Time.now.to_i), opts.merge(:method => :post))
+    api(path, params, opts.merge(:method => :post))
   end
 
   def self.error?(data)
-    not data["error"].nil?
+    not data['error'].nil?
   end
 
   def host
@@ -79,9 +80,13 @@ class Tr8n::ApiClient < Tr8n::Base
   end
 
   def api(path, params = {}, opts = {})
+    if Tr8n.session.inline_mode?
+      return process_response(execute_request(path, params, opts), opts)
+    end
+
     if opts[:method] == :get and opts[:cache_key]
       data = Tr8n.cache.fetch(opts[:cache_key]) do
-        execute_request(path, params, opts)
+        Tr8n.cache.read_only? ? {} : execute_request(path, params, opts)
       end
       process_response(data, opts)
     else
@@ -89,19 +94,49 @@ class Tr8n::ApiClient < Tr8n::Base
     end
   end
 
+  def paginate(path, params = {}, opts = {})
+    data = get(path, params, opts.merge({'raw' => true}))
+
+    while data
+      if data['results'].is_a?(Array)
+        data['results'].each do |result|
+          yield(result)
+        end
+      else
+        yield(data['results'])
+      end
+
+      if data['pagination'] and data['pagination']['links']['next']
+        data = get(data['pagination']['links']['next'], {}, opts.merge({'raw' => true}))
+      else
+        data = nil
+      end
+    end
+  end
+
+  def prepare_api_path(path)
+    return path if path.index('oauth')
+    return path if path.match(/^https?:\/\//)
+    "#{API_PATH}#{path[0] == '/' ? '' : '/'}#{path}"
+  end
+
   def execute_request(path, params = {}, opts = {})
     response = nil
     error = nil
 
-    Tr8n.logger.trace_api_call(path, params) do
+    # oauth path is separate from versioned APIs
+    path = prepare_api_path(path)
+    params = params.merge(:access_token => access_token) unless path.index('oauth')
+
+    Tr8n.logger.trace_api_call(path, params, opts) do
       begin
         if opts[:method] == :post
-          response = connection.post("#{API_PATH}#{path}", params)
+          response = connection.post(path, params)
         else
-          response = connection.get("#{API_PATH}#{path}", params)
+          response = connection.get(path, params)
         end
       rescue Exception => ex
-        Tr8n.logger.error("Failed to execute request: #{ex}")
+        Tr8n.logger.error("Failed to execute request: #{ex.message[0..255]}")
         error = ex
         nil
       end
@@ -115,11 +150,11 @@ class Tr8n::ApiClient < Tr8n::Base
     begin
       data = JSON.parse(response.body)
     rescue Exception => ex
-      raise Tr8n::Exception.new("Error: #{ex}")
+      raise Tr8n::Exception.new("Failed to parse response: #{ex.message[0..255]}")
     end
 
-    unless data["error"].nil?
-      raise Tr8n::Exception.new("Error: #{data["error"]}")
+    if data.is_a?(Hash) and not data['error'].nil?
+      raise Tr8n::Exception.new("Error: #{data['error']}")
     end
 
     data
@@ -131,18 +166,19 @@ class Tr8n::ApiClient < Tr8n::Base
   end
 
   def process_response(data, opts)
-    if data["results"]
-      Tr8n.logger.debug("received #{data["results"].size} result(s)")
-      return data["results"] unless object_class(opts)
+    return data if opts['raw']
+
+    if data.is_a?(Hash) and data['results']
+      #Tr8n.logger.debug("received #{data['results'].size} result(s)")
+      return data['results'] unless object_class(opts)
       objects = []
-      data["results"].each do |data|
+      data['results'].each do |data|
         objects << object_class(opts).new(data.merge(opts[:attributes] || {}))
       end
       return objects
     end
 
     return data unless object_class(opts)
-    #Tr8n.logger.debug("constructing #{object_class(opts).name}")
     object_class(opts).new(data.merge(opts[:attributes] || {}))
   end
 

data/lib/tr8n/api/post_office.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+#--
+# Copyright (c) 2014 Michael Berkovich, TranslationExchange.com
+#
+#  _______                  _       _   _             ______          _
+# |__   __|                | |     | | (_)           |  ____|        | |
+#    | |_ __ __ _ _ __  ___| | __ _| |_ _  ___  _ __ | |__  __  _____| |__   __ _ _ __   __ _  ___
+#    | | '__/ _` | '_ \/ __| |/ _` | __| |/ _ \| '_ \|  __| \ \/ / __| '_ \ / _` | '_ \ / _` |/ _ \
+#    | | | | (_| | | | \__ \ | (_| | |_| | (_) | | | | |____ >  < (__| | | | (_| | | | | (_| |  __/
+#    |_|_|  \__,_|_| |_|___/_|\__,_|\__|_|\___/|_| |_|______/_/\_\___|_| |_|\__,_|_| |_|\__, |\___|
+#                                                                                        __/ |
+#                                                                                       |___/
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class Tr8n::Api::PostOffice < Tr8n::Api::Client
+  POST_OFFICE_HOST = 'https://postoffice.translationexchange.com'
+  POST_OFFICE_API_VERSION = 'v1'
+
+  attributes :application
+
+  def templates
+    api('templates', {
+      :access_token => access_token
+    })
+  end
+
+  def channels
+    api('channels', {
+      :access_token => access_token
+    })
+  end
+
+  def deliver(template, to, tokens = {}, options = {})
+    api("templates/#{template}/deliver", {
+      :access_token => access_token,
+      :tokens => tokens,
+      :to => to,
+      :via => options[:via],
+      :from => options[:from],
+      :locale => options[:locale],
+      :realtime => options[:realtime]
+    }, options.merge(:method => :post))
+  end
+
+  def host
+    application.tools['postoffice'] || POST_OFFICE_HOST
+  end
+
+  def prepare_api_path(path)
+    "/api/#{POST_OFFICE_API_VERSION}#{path.first == '/' ? '' : '/'}#{path}"
+  end
+
+end

data/lib/tr8n/application.rb

@@ -33,11 +33,19 @@
 require 'faraday'
 
 class Tr8n::Application < Tr8n::Base
-  attributes :host, :key, :secret, :access_token, :name, :description, :threshold, :default_locale, :default_level
-  has_many :features, :languages, :featured_locales, :sources, :components, :tokens, :css, :shortcuts
+  attributes :host, :id, :key, :secret, :access_token, :name, :description, :threshold, :default_locale, :default_level, :tools
+  has_many :features, :languages, :featured_locales, :sources, :components, :tokens, :css, :shortcuts, :translations
+
+  def self.cache_key
+    'application'
+  end
+
+  def self.translations_cache_key(locale)
+    "#{locale}/translations"
+  end
 
   def fetch
-    update_attributes(api_client.get("application", {:definition => true}, {:cache_key => key}))
+    update_attributes(api_client.get('applications/current', {:definition => true}, {:cache_key => self.class.cache_key}))
   rescue Tr8n::Exception => ex
     Tr8n.logger.error("Failed to load application: #{ex}")
     self
@@ -46,49 +54,26 @@ class Tr8n::Application < Tr8n::Base
   def update_attributes(attrs)
     super
 
-    self.host ||= "https://translationexchange.com"
-
     self.attributes[:languages] = []
     if hash_value(attrs, :languages)
       self.attributes[:languages] = hash_value(attrs, :languages).collect{ |l| Tr8n::Language.new(l.merge(:application => self)) }
     end
 
-    self.attributes[:sources] = []
-    if hash_value(attrs, :sources)
-      self.attributes[:sources] = hash_value(attrs, :sources).collect{ |l| Tr8n::Source.new(l.merge(:application => self)) }
-    end
-
-    self.attributes[:components] = []
-    if hash_value(attrs, :components)
-      self.attributes[:components] = hash_value(attrs, :components).collect{ |l| Tr8n::Component.new(l.merge(:application => self)) }
-    end
-
-    @translation_keys         = {}
-    @sources_by_key           = {}
-    @components_by_key        = {}
-
-    @languages_by_locale      = nil
-    @missing_keys_by_sources  = nil
-
     self
   end
 
   def language(locale = nil)
+    locale = nil if locale.strip == ''
     locale ||= default_locale || Tr8n.config.default_locale
     @languages_by_locale ||= {}
-
-    unless Tr8n.session.current_translator and Tr8n.session.current_translator.inline?
-      cache_key = "#{locale}/language"
-    end
-
     @languages_by_locale[locale] ||= api_client.get(
-        'language',
-        {:locale => locale},
-        {
-            :class => Tr8n::Language,
-            :attributes => {:locale => locale, :application => self},
-            :cache_key => cache_key
-        }
+      "languages/#{locale}",
+      {:definition => true},
+      {
+        :class => Tr8n::Language,
+        :attributes => {:locale => locale, :application => self},
+        :cache_key => Tr8n::Language.cache_key(locale)
+      }
     )
   rescue Tr8n::Exception => e
     Tr8n.logger.error(e)
@@ -110,76 +95,34 @@ class Tr8n::Application < Tr8n::Base
     @locales ||= languages.collect{|lang| lang.locale}
   end
 
-  def url_for(path)
-    "#{host}#{path}"
+  def tools
+    @attributes[:tools] || {}
   end
 
-  def source(key, locale)
-    @sources_by_key ||= {}
-    return @sources_by_key[key] if @sources_by_key[key]
-
-    unless Tr8n.session.current_translator and Tr8n.session.current_translator.inline?
-      cache_key = Tr8n::Source.cache_key(key, locale)
-    end
+  def url_for(path)
+    "#{tools['assets']}#{path}"
+  end
 
-    @sources_by_key[key] ||= api_client.get(
-        "source",
-        {:source => key, :locale => locale, :translations => true},
-        {
-          :class => Tr8n::Source,
-          :attributes => {:application => self},
-          :cache_key => cache_key
-        }
-    )
-  rescue
-    @sources_by_key[key] = Tr8n::Source.new(:source => key)
+  def source(source, locale)
+    self.sources ||= {}
+    self.sources[source] ||= Tr8n::Source.new(
+      :application => self,
+      :source => source
+    ).fetch_translations(locale)
   end
 
   def component(key, register = true)
     key = key.key if key.is_a?(Tr8n::Component)
 
-    return @components_by_key[key] if @components_by_key[key]
+    return self.components[key] if self.components[key]
     return nil unless register
 
-    @components_by_key[key] ||= api_client.post("component/register", {:component => key}, {:class => Tr8n::Component, :attributes => {:application => self}})
-  end
-
-  def translation_keys
-    @translation_keys ||= {}
-  end
-
-  def translation_key(key)
-    translation_keys[key]
-  end
-
-  def cache_translation_key(tkey)
-    cached_key = translation_key(tkey.key)
-
-    if cached_key
-      # move translations from tkey to the cached key
-      tkey.translations.each do |locale, translations|
-        cached_key.set_language_translations(language(locale), translations)
-      end
-      return cached_key
-    end
-
-    tkey.set_application(self)
-    @translation_keys[tkey.key] = tkey
-  end
-
-  def cache_translation_keys(tkeys)
-    tkeys.each do |tkey|
-      cache_translation_key(tkey)
-    end
-  end
-
-  def reset_translation_cache
-    @translation_keys = {}
-    @sources_by_key = {}
-    @components_by_key = {}
+    self.components[key] ||= api_client.post('components/register', {:component => key}, {:class => Tr8n::Component, :attributes => {:application => self}})
   end
 
   def register_missing_key(source_key, tkey)
+    return if Tr8n.cache.read_only? and not Tr8n.session.inline_mode?
+
     @missing_keys_by_sources ||= {}
     @missing_keys_by_sources[source_key] ||= {}
     @missing_keys_by_sources[source_key][tkey.key] ||= tkey
@@ -188,12 +131,14 @@ class Tr8n::Application < Tr8n::Base
 
   def register_keys(keys)
     params = []
-    keys.each do |source, keys|
+    keys.each do |source_key, keys|
       next unless keys.values.any?
-      params << {:source => source, :keys => keys.values.collect{|tkey| tkey.to_hash(:label, :description, :locale, :level)}}
+      source = Tr8n::Source.new(:source => source_key, :application => self)
+      params << {:source => source_key, :keys => keys.values.collect{|tkey| tkey.to_hash(:label, :description, :locale, :level)}}
+      source.reset_cache
     end
 
-    api_client.post('source/register_keys', {:source_keys => params.to_json})
+    api_client.post('sources/register_keys', {:source_keys => params.to_json})
   rescue Tr8n::Exception => e
     Tr8n.logger.error('Failed to register missing translation keys...')
     Tr8n.logger.error(e)
@@ -208,14 +153,82 @@ class Tr8n::Application < Tr8n::Base
 
   def featured_languages
     @featured_languages ||= begin
-      locales = api_client.get("application/featured_locales", {}, {:cache_key => "featured_locales"})
-      # use app languages, there is no need for rules for this call
+      locales = api_client.get('applications/current/featured_locales', {}, {:cache_key => 'featured_locales'})
       (locales.nil? or locales.empty?) ? [] : languages.select{|l| locales.include?(l.locale)}
     end
+  rescue
+    []
   end
  
   def translators
-    @translators ||= api_client.get("application/translators", {}, {:class => Tr8n::Translator, :attributes => {:application => self}})
+    @translators ||= api_client.get('applications/current/translators', {}, {:class => Tr8n::Translator, :attributes => {:application => self}})
+  rescue
+    []
+  end
+
+  def reset_translation_cache
+    self.sources = {}
+    self.translations = {}
+    @languages_by_locale      = nil
+    @missing_keys_by_sources  = nil
+  end
+
+  def fetch_translations(locale)
+    self.translations ||= {}
+    self.translations[locale] ||= begin
+      results = Tr8n.cache.fetch(Tr8n::Application.translations_cache_key(locale)) do
+        data = {}
+        unless Tr8n.cache.read_only?
+          api_client.paginate('applications/current/translations', :per_page => 1000) do |translations|
+            data.merge!(translations)
+          end
+        end
+        data
+      end
+
+      translations_by_key = {}
+      results.each do |key, data|
+        translations_data = data.is_a?(Hash) ? data['translations'] : data
+        translations_by_key[key] = translations_data.collect do |t|
+          Tr8n::Translation.new(
+            :locale => t['locale'] || locale,
+            :label => t['label'],
+            :context => t['context']
+          )
+        end
+      end
+      translations_by_key
+    end
+  rescue Tr8n::Exception => ex
+    {}
+  end
+
+  def cache_translations(locale, key, new_translations)
+    self.translations ||= {}
+    self.translations[locale] ||= {}
+    self.translations[locale][key] = new_translations.collect do |t|
+      Tr8n::Translation.new(
+        :locale => t['locale'] || locale,
+        :label => t['label'],
+        :context => t['context']
+      )
+    end
+  end
+
+  def cached_translations(locale, key)
+    return unless self.translations and self.translations[locale]
+    self.translations[locale][key]
+  end
+
+  def debug_translations
+    return 'no translations' unless self.translations
+    self.translations.each do |locale, keys|
+      pp [locale, keys.collect{|key, translations|
+        [key, translations.collect{|t|
+          [t.label, t.context]
+        }]
+      }]
+    end
   end
 
   def default_decoration_token(token)
@@ -230,12 +243,12 @@ class Tr8n::Application < Tr8n::Base
     hash_value(features, key.to_s)
   end
 
-  #######################################################################################################
-  ##  API Methods
-  #######################################################################################################
-
   def api_client
-    @api_client ||= Tr8n::ApiClient.new(:application => self)
+    @api_client ||= Tr8n::Api::Client.new(:application => self)
+  end
+
+  def postoffice
+    @postoffice ||= Tr8n::Api::PostOffice.new(:application => self)
   end
 
 end