tr8n_core 4.0.7 → 4.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c63616cd107057912d9e4751712da3a7b57f1d52
-  data.tar.gz: 39d042996c73c584256c6d68977e8ef05fb938ea
+  metadata.gz: c5d6598f1871117da1975503815421dff165daf9
+  data.tar.gz: e60f6a755c7fede60e1b47daf39ff93e0145636f
 SHA512:
-  metadata.gz: 44f82a0d70a1dace61537bd714b77cdeabe30ca5eea5720753607de6218a1095d0e3642d6c31beb0dd607c6e87a503b1a7ab3d0c66cbd76ad57e76f07b36ba0a
-  data.tar.gz: 6d470e0719c0524271f14ab2e178a83e75dcbf65f45c10701fe7ed5350e227d505f59cbe4e0af3724bf4855a74cde3135c183675a843f9101626fa672e81481e
+  metadata.gz: ccdd9f1b867a34c5bd87f195f57983606b18bacf0f65a0d227637fb761fd40d9a0050744d617d5d2a422be2c9fb4001f6dd7790a5fc406114716ccb68814a367
+  data.tar.gz: 0c718d53381c1ae518576653bd3db3c7a0c57834e2f38593f39c7ab87f66801b000f1cfc13cc0279f2142768c151abc92168ecbd0bcd26888d586088e88a6b8f

data/README.md

@@ -7,7 +7,7 @@ Tr8n Core Library For Ruby
 [![Build Status](https://travis-ci.org/tr8n/tr8n_ruby_core.png?branch=master)](https://travis-ci.org/tr8n/tr8n_ruby_core)
 [![Coverage Status](https://coveralls.io/repos/tr8n/tr8n_ruby_core/badge.png?branch=master)](https://coveralls.io/r/tr8n/tr8n_ruby_core?branch=master)
 [![Gem Version](https://badge.fury.io/rb/tr8n_core.png)](http://badge.fury.io/rb/tr8n_core)
-[![Dependency Status](https://www.versioneye.com/user/projects/52e36cc8ec1375c6f4000078/badge.png)](https://www.versioneye.com/user/projects/52e36cc8ec1375c6f4000078)
+[![Dependency Status](https://www.versioneye.com/user/projects/53cda688225426d5d500015b/badge.svg?style=flat)](https://www.versioneye.com/user/projects/53cda688225426d5d500015b)
 [![Project status](http://stillmaintained.com/tr8n/tr8n_ruby_core.png)](http://stillmaintained.com/tr8n/tr8n_ruby_core.png)
 
 Tr8n core library for Ruby is a set of classes that provide translation functionality for any Ruby based application.
@@ -210,9 +210,9 @@ Links
 
 * Register on TranslationExchange.com: https://translationexchange.com
 
-* Read TranslationExchange's documentation: http://wiki.translationexchange.com
+* Read TranslationExchange's documentation: http://wiki.tr8nhub.com
 
-* Visit TranslationExchange's blog: http://blog.translationexchange.com
+* Visit TranslationExchange's blog: http://blog.tr8nhub.com
 
 * Follow TranslationExchange on Twitter: https://twitter.com/translationx
 

data/lib/tr8n/api_client.rb

@@ -55,7 +55,7 @@ class Tr8n::ApiClient < Tr8n::Base
   end
 
   def get(path, params = {}, opts = {})
-    api(path, params.merge(:access_token => access_token, :t => Time.now.to_i), opts)
+    api(path, params.merge(:client_id => application.key, :t => Time.now.to_i), opts.merge(:method => :get))
   end
 
   def post(path, params = {}, opts = {})
@@ -70,28 +70,37 @@ class Tr8n::ApiClient < Tr8n::Base
     application.host || API_HOST
   end
 
+  def connection
+    @connection ||= Faraday.new(:url => host) do |faraday|
+      faraday.request(:url_encoded)               # form-encode POST params
+      # faraday.response :logger                  # log requests to STDOUT
+      faraday.adapter(Faraday.default_adapter)    # make requests with Net::HTTP
+    end
+  end
+
   def api(path, params = {}, opts = {})
-    Tr8n.logger.trace_api_call(path, params) do
-      conn = Faraday.new(:url => host) do |faraday|
-        faraday.request(:url_encoded)               # form-encode POST params
-                                                    # faraday.response :logger                  # log requests to STDOUT
-        faraday.adapter(Faraday.default_adapter)    # make requests with Net::HTTP
+    if opts[:method] == :get and opts[:cache_key]
+      data = Tr8n.cache.fetch(opts[:cache_key]) do
+        execute_request(path, params, opts)
       end
+      process_response(data, opts)
+    else
+      process_response(execute_request(path, params, opts), opts)
+    end
+  end
 
+  def execute_request(path, params = {}, opts = {})
+    response = nil
+    Tr8n.logger.trace_api_call(path, params) do
       if opts[:method] == :post
-        response = conn.post("#{API_PATH}#{path}", params)
+        response = connection.post("#{API_PATH}#{path}", params)
       else
-        response = conn.get("#{API_PATH}#{path}", params)
-      end
-
-      data = JSON.parse(response.body)
-
-      unless data["error"].nil?
-        raise Tr8n::Exception.new("Error: #{data["error"]}")
+        response = connection.get("#{API_PATH}#{path}", params)
       end
-
-      process_response(data, opts)
     end
+    data = JSON.parse(response.body)
+    raise Tr8n::Exception.new("Error: #{data["error"]}") unless data["error"].nil?
+    data
   end
 
   def object_class(opts)
@@ -101,7 +110,7 @@ class Tr8n::ApiClient < Tr8n::Base
 
   def process_response(data, opts)
     if data["results"]
-      Tr8n.logger.debug("recieved #{data["results"].size} result(s)")
+      Tr8n.logger.debug("received #{data["results"].size} result(s)")
       return data["results"] unless object_class(opts)
       objects = []
       data["results"].each do |data|
@@ -111,7 +120,8 @@ class Tr8n::ApiClient < Tr8n::Base
     end
 
     return data unless object_class(opts)
-    Tr8n.logger.debug("constructing #{object_class(opts).name}")
+    #Tr8n.logger.debug("constructing #{object_class(opts).name}")
     object_class(opts).new(data.merge(opts[:attributes] || {}))
   end
+
 end

data/lib/tr8n/application.rb

@@ -37,13 +37,14 @@ class Tr8n::Application < Tr8n::Base
   has_many :features, :languages, :featured_locales, :sources, :components, :tokens, :css, :shortcuts
 
   def fetch
-    update_attributes(api_client.get("application", {:definition => true}))
-    self
+    update_attributes(api_client.get("application", {:definition => true}, {:cache_key => key}))
   end
 
   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)) }
@@ -65,60 +66,56 @@ class Tr8n::Application < Tr8n::Base
 
     @languages_by_locale      = nil
     @missing_keys_by_sources  = nil
+
+    self
   end
 
-  def language(locale = nil, fetch = true)
+  def language(locale = nil)
     locale ||= default_locale || Tr8n.config.default_locale
-
     @languages_by_locale ||= {}
     return @languages_by_locale[locale] if @languages_by_locale[locale]
-
-    if Tr8n.config.cache[:enabled]
-      language = Tr8n.cache.fetch(Tr8n::Language.cache_key(locale))
-      if language
-        language.application = self
-        @languages_by_locale[locale] = language
-        return language
-      end
-    end
-
-    return nil unless fetch
-
     @languages_by_locale[locale] = Tr8n::Language.new(:locale => locale, :application => self).fetch
-
-    if Tr8n.config.cache[:enabled] and not Tr8n.cache.read_only?
-      Tr8n.cache.store(Tr8n::Language.cache_key(locale), @languages_by_locale[locale])
-    end
-
-    @languages_by_locale[locale]
-  end
-
-  def locales
-    @locales ||= languages.collect{|lang| lang.locale}
-  end
-
-  def url_for(path)
-    "#{host}#{path}"
   end
 
   # Mostly used for testing
   def add_language(new_language)
-    lang = language(new_language.locale, false)
-    return lang if lang
-
+    @languages_by_locale ||= {}
+    return @languages_by_locale[new_language.locale] if @languages_by_locale[new_language.locale]
     new_language.application = self
     self.languages << new_language
     @languages_by_locale[new_language.locale] = new_language
     new_language
   end
 
-  def source(key, register = true)
-    key = key.source if key.is_a?(Tr8n::Source)
+  def locales
+    @locales ||= languages.collect{|lang| lang.locale}
+  end
 
+  def url_for(path)
+    "#{host}#{path}"
+  end
+
+  def source(key, locale)
+    @sources_by_key ||= {}
     return @sources_by_key[key] if @sources_by_key[key]
-    return nil unless register
 
-    @sources_by_key[key] ||= api_client.post("source/register", {:source => key}, {:class => Tr8n::Source, :attributes => {:application => self}})
+    unless Tr8n.session.current_translator and Tr8n.session.current_translator.inline?
+      cache_key = Tr8n::Source.cache_key(key, locale)
+    end
+
+    begin
+      @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)
+    end
   end
 
   def component(key, register = true)
@@ -165,10 +162,10 @@ class Tr8n::Application < Tr8n::Base
     @components_by_key = {}
   end
 
-  def register_missing_key(tkey, source)
+  def register_missing_key(source_key, tkey)
     @missing_keys_by_sources ||= {}
-    @missing_keys_by_sources[source.source] ||= {}
-    @missing_keys_by_sources[source.source][tkey.key] ||= tkey
+    @missing_keys_by_sources[source_key] ||= {}
+    @missing_keys_by_sources[source_key][tkey.key] ||= tkey
     submit_missing_keys if Tr8n.config.submit_missing_keys_realtime
   end
 
@@ -214,30 +211,6 @@ class Tr8n::Application < Tr8n::Base
     hash_value(features, key.to_s)
   end
 
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def self.cache_prefix
-    'a@'
-  end
-
-  def self.cache_key(key)
-    "#{cache_prefix}_[#{key}]"
-  end
-
-  def to_cache_hash
-    hash = to_hash(:host, :key, :secret, :access_token,
-                   :name, :description, :threshold,
-                   :default_locale, :default_level, :features,
-                   :tokens, :css, :shortcuts)
-    hash["languages"] = []
-    languages.each do |lang|
-      hash["languages"] << lang.to_hash(:locale, :name, :english_name, :native_name, :right_to_left, :flag_url)
-    end
-    hash
-  end
-
   #######################################################################################################
   ##  API Methods
   #######################################################################################################

data/lib/tr8n/cache.rb

@@ -32,6 +32,8 @@
 
 module Tr8n
 
+  CACHE_VERSION_KEY = "__tr8n_version__"
+
   def self.cache
     @cache ||= begin
       if Tr8n.config.cache[:enabled]
@@ -48,13 +50,15 @@ module Tr8n
 
     def version
       @version ||= begin
-        v = fetch('tr8n_cache_version', :skip_version => true)
-        v ? v['version'] : Tr8n.config.cache[:version]
+        v = fetch(CACHE_VERSION_KEY) do
+          {'version' => Tr8n.config.cache[:version]}
+        end
+        v['version']
       end
     end
 
     def upgrade_version
-      store('tr8n_cache_version', {'version' => version + 1}, :ttl => 0, :skip_version => true)
+      store(CACHE_VERSION_KEY, {'version' => version + 1}, :ttl => 0)
       @version = nil
     end
 
@@ -87,7 +91,7 @@ module Tr8n
     end
 
     def versioned_key(key, opts = {})
-      return key if opts[:skip_version]
+      return key if CACHE_VERSION_KEY == key
       "tr8n_rc_v#{version}_#{key}"
     end
 
@@ -112,42 +116,5 @@ module Tr8n
       # do nothing
     end
 
-    def serialize_object(key, data)
-      if [Tr8n::Application.cache_prefix,
-              Tr8n::Language.cache_prefix,
-              Tr8n::Source.cache_prefix,
-              Tr8n::Component.cache_prefix,
-              Tr8n::TranslationKey.cache_prefix].include?(key[0..1])
-        json_data = data.to_cache_hash.to_json
-      else
-        # the data must be in cacheable form - usually API responses
-        json_data = data.to_json
-      end
-
-      #info(json_data)
-      json_data
-    end
-
-    def deserialize_object(key, data)
-      #info(data.inspect)
-
-      case key[0..1]
-        when Tr8n::Application.cache_prefix
-          return Tr8n::Application.new(JSON.parse(data))
-        when Tr8n::Language.cache_prefix
-          return Tr8n::Language.new(JSON.parse(data).merge(:application => Tr8n.session.application))
-        when Tr8n::Source.cache_prefix
-          return Tr8n::Source.new(JSON.parse(data).merge(:application => Tr8n.session.application))
-        when Tr8n::Component.cache_prefix
-          return Tr8n::Component.new(JSON.parse(data).merge(:application => Tr8n.session.application))
-        when Tr8n::TranslationKey.cache_prefix
-          return Tr8n::TranslationKey.new(JSON.parse(data).merge(:application => Tr8n.session.application))
-      end
-
-      # API response form will be here
-      JSON.parse(data)
-    end
-
-
   end
 end

data/lib/tr8n/cache_adapters/file.rb

@@ -53,8 +53,7 @@ class Tr8n::CacheAdapters::File < Tr8n::Cache
 
     if File.exists?(path)
       info("Cache hit: #{key}")
-      data = File.read(path)
-      return deserialize_object(key, data)
+      return File.read(path)
     end
 
     info("Cache miss: #{key}")

data/lib/tr8n/cache_adapters/memcache.rb

@@ -51,7 +51,7 @@ class Tr8n::CacheAdapters::Memcache < Tr8n::Cache
     data = @cache.get(versioned_key(key, opts))
     if data
       info("Cache hit: #{key}")
-      return deserialize_object(key, data)
+      return data
     end
 
     info("Cache miss: #{key}")
@@ -72,7 +72,7 @@ class Tr8n::CacheAdapters::Memcache < Tr8n::Cache
   def store(key, data, opts = {})
     info("Cache store: #{key}")
     ttl = opts[:ttl] || Tr8n.config.cache[:timeout]
-    @cache.set(versioned_key(key, opts), serialize_object(key, data), ttl)
+    @cache.set(versioned_key(key, opts), data, ttl)
     data
   rescue Exception => ex
     warn("Failed to store data: #{ex.message}")

data/lib/tr8n/cache_adapters/redis.rb

@@ -55,7 +55,7 @@ class Tr8n::CacheAdapters::Redis < Tr8n::Cache
     data = @cache.get(versioned_key(key, opts))
     if data
       info("Cache hit: #{key}")
-      return deserialize_object(key, data)
+      return data
     end
 
     info("Cache miss: #{key}")
@@ -78,7 +78,7 @@ class Tr8n::CacheAdapters::Redis < Tr8n::Cache
     ttl = opts[:ttl] || Tr8n.config.cache[:timeout]
     versioned_key = versioned_key(key, opts)
 
-    @cache.set(versioned_key, serialize_object(key, data))
+    @cache.set(versioned_key, data)
     @cache.expire(versioned_key, ttl) if ttl and ttl > 0
   rescue Exception => ex
     warn("Failed to store data: #{ex.message}")

data/lib/tr8n/config.rb

@@ -78,7 +78,7 @@ module Tr8n
     attr_accessor :enabled, :default_locale, :default_level, :format, :application, :context_rules, :logger, :cache, :default_tokens, :localization
 
     # Used by Rails and Sinatra extensions
-    attr_accessor :current_locale_method, :current_user_method
+    attr_accessor :current_locale_method, :current_user_method, :translator_options
 
     # Used for IRB only
     attr_accessor :submit_missing_keys_realtime
@@ -90,19 +90,41 @@ module Tr8n
       @format = :html
 
       # if running from IRB, make it default to TRUE
-      @submit_missing_keys_realtime = (['irb', 'pry'].include?($0 || ''))
+      @submit_missing_keys_realtime = (%w(irb pry).include?($0 || ''))
 
       @current_locale_method = :current_locale
       @current_user_method = :current_user
 
-      #@application = {
-      #  :host     => 'https://localhost:3000',
-      #  :key      => 'default',
-      #  :secret   => '12345',
-      #}
-
       @application = nil
 
+      @translator_options = {
+        debug: false,
+        debug_format_html: "<span style='font-size:20px;color:red;'>{</span> {$0} <span style='font-size:20px;color:red;'>}</span>",
+        debug_format: '{{{{$0}}}}',
+        split_sentences: false,
+        nodes: {
+            ignored:    [],
+            scripts:    %w(style script),
+            inline:     %w(a span i b img strong s em u sub sup),
+            short:      %w(i b),
+            splitters:  %w(br hr)
+        },
+        attributes: {
+            labels:     %w(title alt)
+        },
+        name_mapping: {
+            b:    'bold',
+            i:    'italic',
+            a:    'link',
+            img:  'picture'
+        },
+        data_tokens: {
+            special: false,
+            numeric: false,
+            numeric_name: 'num'
+        }
+      }
+
       @context_rules = {
         :number => {
           :variables => {
@@ -110,16 +132,16 @@ module Tr8n
         },
         :gender => {
           :variables => {
-              "@gender" => "gender",
+              '@gender' => 'gender',
           }
         },
         :genders => {
           :variables => {
-            "@genders" => lambda{|list| list.collect do |u|
-              u.is_a?(Hash) ? (u["gender"] || u[:gender]) : u.gender
+            '@genders' => lambda{|list| list.collect do |u|
+                u.is_a?(Hash) ? (u['gender'] || u[:gender]) : u.gender
             end
             },
-            "@size" => lambda{|list| list.size}
+            '@size' => lambda{ |list| list.size }
           }
         },
         :date => {
@@ -132,7 +154,7 @@ module Tr8n
         },
         :list => {
           :variables => {
-            "@count" => lambda{|list| list.size}
+            '@count' => lambda{|list| list.size}
           }
         },
       }
@@ -279,6 +301,19 @@ module Tr8n
       not enabled?
     end
 
+    def nested_value(hash, key, default_value = nil)
+      parts = key.split('.')
+      parts.each do |part|
+        return default_value unless hash[part.to_sym]
+        hash = hash[part.to_sym]
+      end
+      hash
+    end
+
+    def translator_option(key)
+      nested_value(self.translator_options, key)
+    end
+
     #########################################################
     ## Application
     #########################################################

data/lib/tr8n/decorators/html.rb

@@ -40,15 +40,8 @@ class Tr8n::Decorators::Html < Tr8n::Decorators::Base
     return translated_label unless Tr8n.session.current_translator and Tr8n.session.current_translator.inline?
     return translated_label if translation_key.locked? and not Tr8n.session.current_translator.manager?
 
-    element = 'span'
-    if options[:use_div]
-      element = 'div'
-    end
-
-    if translation_key.id.nil?
-      return "<#{element} class='tr8n_pending'>#{translated_label}</#{element}>"
-    end
-
+    element = 'tr8n:tr'
+    element = 'div' if options[:use_div]
     classes = ['tr8n_translatable']
     
     if translation_key.locked?
@@ -63,7 +56,7 @@ class Tr8n::Decorators::Html < Tr8n::Decorators::Base
       classes << 'tr8n_fallback'
     end
 
-    html = "<#{element} class='#{classes.join(' ')}' data-translation_key_id='#{translation_key.id}'>"
+    html = "<#{element} class='#{classes.join(' ')}' data-translation_key='#{translation_key.key}'>"
     html << translated_label
     html << "</#{element}>"
     html