tr8n_core 4.0.17 → 4.2

data/lib/tr8n/language_case.rb

@@ -59,12 +59,14 @@ class Tr8n::LanguageCase < Tr8n::Base
   def apply(value, object = nil, options = {})
     value = value.to_s
 
+    decorator = Tr8n::Decorators::Base.decorator
+
     options = options.merge(:skip_decorations => true) if value.index('not_translated')
 
     html_tokens = value.scan(TR8N_HTML_TAGS_REGEX).uniq
-    sanitized_value = value.gsub(TR8N_HTML_TAGS_REGEX, "")
+    sanitized_value = value.gsub(TR8N_HTML_TAGS_REGEX, '')
 
-    if application.to_s == "phrase"
+    if application.to_s == 'phrase'
       words = [sanitized_value]
     else
       words = sanitized_value.split(/[\s\/\\]/).uniq
@@ -84,7 +86,7 @@ class Tr8n::LanguageCase < Tr8n::Base
     words.each do |word|
       case_rule = find_matching_rule(word, object)
       case_value = case_rule ? case_rule.apply(word) : word
-      transformed_words << decorate(word, case_value, case_rule, options)
+      transformed_words << decorator.decorate_language_case(self, case_rule, word, case_value, options)
     end
 
     # replace back the temporary placeholders with the html tokens
@@ -100,30 +102,4 @@ class Tr8n::LanguageCase < Tr8n::Base
     value
   end
 
-  #######################################################################################################
-  ##  Decoration Methods - TODO: move to decorators
-  #######################################################################################################
-
-  def decorate(word, case_value, case_rule, options = {})
-    return case_value if options[:skip_decorations]
-    return case_value if language.default?
-    return case_value unless Tr8n.session.current_translator
-    return case_value unless Tr8n.session.current_translator.inline?
-
-    "<span class='tr8n_language_case' data-case_id='#{id}' data-rule_id='#{case_rule ? case_rule.id : ''}' data-case_key='#{word.gsub("'", "\'")}'>#{case_value}</span>"
-  end
-
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def to_cache_hash
-    hash = to_hash(:id, :keyword, :description, :latin_name, :native_name, :application)
-    hash["rules"] = []
-    rules.each do |rule|
-      hash["rules"] << rule.to_cache_hash
-    end
-    hash
-  end
-
 end

data/lib/tr8n/language_case_rule.rb

@@ -35,39 +35,32 @@ class Tr8n::LanguageCaseRule < Tr8n::Base
   attributes  :id, :description, :examples, :conditions, :conditions_expression, :operations, :operations_expression
 
   def conditions_expression
-    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(conditions).parse
+    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(self.conditions).parse
   end
 
   def operations_expression
-    self.attributes[:operations_expression] ||= Tr8n::RulesEngine::Parser.new(operations).parse
+    self.attributes[:operations_expression] ||= Tr8n::RulesEngine::Parser.new(self.operations).parse
   end
 
   def gender_variables(object)
-    return {} unless conditions.index('@gender')
-    return {"@gender" => "unknown"} unless object
+    return {} unless self.conditions.index('@gender')
+    return {'@gender' => 'unknown'} unless object
     context = language_case.language.context_by_keyword(:gender)
-    return {"@gender" => "unknown"} unless context
+    return {'@gender' => 'unknown'} unless context
     context.vars(object)
   end
 
-  #######################################################################################################
-  ##  Evaluation Methods
-  #######################################################################################################
-
   def evaluate(value, object = nil)
     return false if conditions.nil?
 
     re = Tr8n::RulesEngine::Evaluator.new
-    re.evaluate(["let", "@value", value])
+    re.evaluate(['let', '@value', value])
 
     gender_variables(object).each do |key, value|
-      re.evaluate(["let", key, value])
+      re.evaluate(['let', key, value])
     end
 
     re.evaluate(conditions_expression)
-  rescue Exception => ex
-    Tr8n.logger.error("Failed to evaluate language case #{conditions}: #{ex.message}")
-    value
   end
 
   def apply(value)
@@ -75,20 +68,9 @@ class Tr8n::LanguageCaseRule < Tr8n::Base
     return value if operations.nil?
 
     re = Tr8n::RulesEngine::Evaluator.new
-    re.evaluate(["let", "@value", value])
+    re.evaluate(['let', '@value', value])
 
     re.evaluate(operations_expression)
-  rescue Exception => ex
-    Tr8n.logger.error("Failed to apply language case rule [case: #{language_case.id}] [rule: #{id}] [conds: #{conditions_expression}] [opers: #{operations_expression}]: #{ex.message}")
-    value
-  end
-
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def to_cache_hash
-    to_hash(:id, :description, :examples, :conditions, :conditions_expression, :operations, :operations_expression)
   end
 
 end

data/lib/tr8n/language_context.rb

@@ -41,14 +41,17 @@ class Tr8n::LanguageContext < Tr8n::Base
     self.attributes[:rules] = {}
     if hash_value(attrs, :rules)
       hash_value(attrs, :rules).each do |key, rule|
-        self.attributes[:rules][key] = Tr8n::LanguageContextRule.new(rule.merge(:language_context => self))
+        self.attributes[:rules][key] = Tr8n::LanguageContextRule.new(rule.merge(
+         :keyword => key,
+         :language_context => self
+        ))
       end
     end
   end
 
   def config
     context_rules = Tr8n.config.context_rules
-    hash_value(context_rules, keyword.to_sym) || {}
+    hash_value(context_rules, self.keyword.to_sym) || {}
   end
 
   def token_expression
@@ -111,17 +114,4 @@ class Tr8n::LanguageContext < Tr8n::Base
     fallback_rule
   end
 
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def to_cache_hash
-    hash = to_hash(:keyword, :description, :keys, :default_key, :token_expression, :variables, :token_mapping)
-    hash[:rules] = {}
-    rules.each do |key, rule|
-      hash[:rules][key] = rule.to_cache_hash
-    end
-    hash
-  end
-
 end

data/lib/tr8n/language_context_rule.rb

@@ -35,37 +35,22 @@ class Tr8n::LanguageContextRule < Tr8n::Base
   attributes  :keyword, :description, :examples, :conditions, :conditions_expression
 
   def fallback?
-    keyword.to_s.to_sym == :other
+    self.keyword.to_s.to_sym == :other
   end
 
   def conditions_expression
-    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(conditions).parse
+    self.attributes[:conditions_expression] ||= Tr8n::RulesEngine::Parser.new(self.conditions).parse
   end
 
-  #######################################################################################################
-  ##  Evaluation Methods
-  #######################################################################################################
-
   def evaluate(vars = {})
     return true if fallback?
 
     re = Tr8n::RulesEngine::Evaluator.new
     vars.each do |key, value|
-      re.evaluate(["let", key, value])
+      re.evaluate(['let', key, value])
     end
 
     re.evaluate(conditions_expression)
-  #rescue Exception => ex
-  #  Tr8n.logger.error("Failed to evaluate settings context rule #{conditions_expression}: #{ex.message}")
-  #  false
-  end
-
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def to_cache_hash
-    to_hash(:keyword, :description, :examples, :conditions, :conditions_expression)
   end
 
 end

data/lib/tr8n/logger.rb

@@ -62,11 +62,15 @@ module Tr8n
       @stack ||= []
     end
 
-    def trace_api_call(path, params)
-      [:client_secret, :access_token].each do |param|
-        params = params.merge(param => "##filtered##") if params[param]
+    def trace_api_call(path, params, opts = {})
+      #[:client_secret, :access_token].each do |param|
+      #  params = params.merge(param => "##filtered##") if params[param]
+      #end
+      if opts[:method] == :post
+        debug("post: [#{path}] #{params.inspect}")
+      else
+        debug("get: #{path}?#{to_query(params)}")
       end
-      debug("api: [/#{path}] #{params.inspect}")
       stack.push(caller)
       t0 = Time.now
       if block_given?
@@ -78,6 +82,14 @@ module Tr8n
       ret
     end
 
+    def to_query(hash)
+      query = []
+      hash.each do |key, value|
+        query << "#{key}=#{value}"
+      end
+      query.join('&')
+    end
+
     def trace(message)
       debug(message)
       stack.push(caller)

data/lib/tr8n/session.rb

@@ -38,19 +38,65 @@ module Tr8n
 
   class Session
     # Session Attributes - Move to Session
-    attr_accessor :application, :current_user, :current_language, :current_translator,
-                  :current_source, :current_component, :block_options
+    attr_accessor :application, :current_user, :current_locale, :current_language, :current_translator,
+                  :current_source, :current_component, :block_options, :cookie_params, :access_token
 
-    def init(key = nil, secret = nil, host = nil)
+    def self.access_token
+      @access_token
+    end
+
+    def self.access_token=(token)
+      @access_token = token
+    end
+
+    def init(opts = {})
       return unless Tr8n.config.enabled? and Tr8n.config.application
 
-      key     ||= Tr8n.config.application[:key]
-      secret  ||= Tr8n.config.application[:secret]
-      host    ||= Tr8n.config.application[:host]
+      key     = opts[:key]    || Tr8n.config.application[:key]
+      secret  = opts[:secret] || Tr8n.config.application[:secret]
+      host    = opts[:host]   || Tr8n.config.application[:host]
+
+      self.cookie_params = begin
+        cookie_name = "tr8n_#{key}"
+        if opts[:cookies] and opts[:cookies][cookie_name]
+          begin
+            HashWithIndifferentAccess.new(Tr8n::Utils.decode_and_verify_params(opts[:cookies][cookie_name], secret))
+          rescue Exception => ex
+            Tr8n.logger.error("Failed to parse tr8n cookie: #{ex.message}")
+            {}
+          end
+        else
+          {}
+        end
+      end
+
+      # Tr8n.logger.info(self.cookie_params.inspect)
+
+      self.access_token = opts[:access_token]
+      self.current_user = opts[:user]
+      self.current_source = opts[:source] || '/tr8n/core'
+      self.current_component = opts[:component]
+      self.current_locale = self.cookie_params[:locale] || opts[:locale] || Tr8n.config.default_locale
+
+      if self.cookie_params['translator']
+        self.current_translator = Tr8n::Translator.new(self.cookie_params['translator'])
+      end
 
       Tr8n.cache.reset_version
-      self.current_source = '/tr8n/core' # default source
-      self.application = Tr8n::Application.new(:host => host, :key => key, :secret => secret).fetch
+
+      self.application = Tr8n.memory.fetch(Tr8n::Application.cache_key) do
+        Tr8n::Application.new(:host => host, :key => key, :secret => secret, :access_token => self.class.access_token).fetch
+      end
+
+      if Tr8n.cache.read_only?
+        self.class.access_token = self.application.access_token
+      end
+
+      if self.current_translator
+        self.current_translator.application = self.application
+      end
+
+      self.current_language = self.application.language(self.current_locale)
     end
 
     def reset
@@ -68,7 +114,7 @@ module Tr8n
     end
 
     def application
-      @application ||= Tr8n::Application.new(:host => Tr8n::ApiClient::API_HOST)
+      @application ||= Tr8n::Application.new(:host => Tr8n::Api::Client::API_HOST)
     end
 
     def source_language
@@ -82,26 +128,38 @@ module Tr8n
     def target_language
       arr = @block_options || []
       arr.reverse.each do |opts|
-        return application.language(opts[:target_locale]) unless opts[:target_locale].blank?
+        return application.language(opts[:target_locale]) unless opts[:target_locale].nil?
       end
       current_language
     end
 
+    def inline_mode?
+      current_translator and current_translator.inline?
+    end
+
     #########################################################
     ## Block Options
     #########################################################
 
+    def push_block_options(opts)
+      (@block_options ||= []).push(opts)
+    end
+
+    def pop_block_options
+      return unless @block_options
+      @block_options.pop
+    end
+
     def block_options
       (@block_options ||= []).last || {}
     end
 
     def with_block_options(opts)
-      @block_options ||= []
-      @block_options.push(opts)
+      push_block_options(opts)
       if block_given?
         ret = yield
       end
-      @block_options.pop if @block_options
+      pop_block_options
       ret
     end
 

data/lib/tr8n/source.rb

@@ -30,10 +30,12 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'digest/md5'
+
 class Tr8n::Source < Tr8n::Base
   belongs_to  :application
-  attributes  :source, :url, :name, :description
-  has_many    :translation_keys
+  attributes  :key, :source, :url, :name, :description
+  has_many    :translations
 
   def self.normalize(url)
     return nil if url.nil? or url == ''
@@ -49,24 +51,56 @@ class Tr8n::Source < Tr8n::Base
     path
   end
 
-  def self.cache_key(key, locale)
-    "#{locale}/[#{key.gsub(/[\.\/]/, '-')}]"
+  def self.generate_key(source)
+    "#{Digest::MD5.hexdigest("#{source}")}~"[0..-2]
+  end
+
+  def self.cache_key(locale, source)
+    File.join(locale, 'sources', source.split('/'))
   end
 
   def initialize(attrs = {})
     super
+    self.key ||= Tr8n::Source.generate_key(attrs[:source])
+  end
+
+  def fetch_translations(locale)
+    self.translations ||= {}
+    return self if self.translations[locale]
 
-    self.translation_keys = {}
-    if hash_value(attrs, :translation_keys)
-      hash_value(attrs, :translation_keys).each do |tk|
-        tkey = Tr8n::TranslationKey.new(tk.merge(:application => application))
-        self.translation_keys[tkey.key] = application.cache_translation_key(tkey)
+    self.translations[locale] = {}
+
+    results = self.application.api_client.get(
+      "sources/#{self.key}/translations",
+      {:locale => locale, :per_page => 10000},
+      {:cache_key => Tr8n::Source.cache_key(locale, self.source)}
+    )
+
+    results.each do |key, data|
+      translations_data = data.is_a?(Hash) ? data['translations'] : data
+      self.translations[locale][key] = translations_data.collect do |t|
+        Tr8n::Translation.new(
+          :locale => t['locale'] || locale,
+          :label => t['label'],
+          :context => t['context']
+        )
       end
     end
+
+    self
+  rescue Tr8n::Exception => ex
+    self
   end
 
-  def translation_key(key)
-    self.translation_keys[key]
+  def cached_translations(locale, key)
+    self.translations ||= {}
+    self.translations[locale] ||= {}
+    self.translations[locale][key]
   end
 
+  def reset_cache
+    application.languages.each do |lang|
+      Tr8n.cache.delete(Tr8n::Source.cache_key(lang.locale, self.source))
+    end
+  end
 end

data/lib/tr8n/translation.rb

@@ -34,45 +34,10 @@ class Tr8n::Translation < Tr8n::Base
   belongs_to :translation_key, :language
   attributes :locale, :label, :context, :precedence
 
-  def initialize(attrs = {})
-    super
-
-    if locale
-      self.language = self.translation_key.application.language(locale)
-    end
-
-    calculate_precedence
-  end
-
-  # switches to a new translation key
-  def set_translation_key(tkey)
-    self.translation_key = tkey
-    self.language = tkey.application.language(locale)
-  end
-
   def has_context_rules?
     context and context.any?
   end
 
-  #
-  # the precedence is based on the number of fallback rules in the context.
-  # a fallback rule is indicated by the keyword "other"
-  # the more "others" are used the lower the precedence will be
-  #
-  # 0 indicates the highest precedence
-  #
-  # deprecated - this is now done by the service
-  def calculate_precedence
-    self.precedence = 0
-    return unless has_context_rules?
-
-    context.values.each do |rules|
-      rules.values.each do |rule_key|
-        self.precedence += 1 if rule_key == "other"
-      end
-    end
-  end
-
   # checks if the translation is valid for the given tokens
   #{
   #    "count" => {"number":"one"},
@@ -86,7 +51,7 @@ class Tr8n::Translation < Tr8n::Base
       return false unless token_object
 
       rules.each do |context_key, rule_key|
-        next if rule_key == "other"
+        next if rule_key == 'other'
 
         context = language.context_by_keyword(context_key)
         return false unless context
@@ -99,12 +64,4 @@ class Tr8n::Translation < Tr8n::Base
     true
   end
 
-  #######################################################################################################
-  ##  Cache Methods
-  #######################################################################################################
-
-  def to_cache_hash
-    to_hash(:locale, :label, :context, :precedence)
-  end
-
 end