tr8n_core 4.0.4 → 4.0.5

data/lib/tr8n/config.rb

@@ -1,7 +1,6 @@
-#!ruby19
-# encoding: utf-8
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -286,6 +285,17 @@ module Tr8n
     #  @default_level
     #end
 
+    def default_language
+      @default_language ||= begin
+        file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tr8n_core', 'languages', "#{Tr8n.config.default_locale}.json"))
+        Tr8n::Language.new(JSON.parse(File.read(file)))
+      end
+    end
+
+    def default_application
+      @default_application ||= Tr8n::Application.new(:host => Tr8n::ApiClient::API_HOST)
+    end
+
     #########################################################
     ## Decorations
     #########################################################

data/lib/tr8n/decorators/base.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/decorators/default.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/decorators/html.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/exception.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/language.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -26,7 +27,12 @@ class Tr8n::Language < Tr8n::Base
   attributes  :locale, :name, :english_name, :native_name, :right_to_left, :flag_url
   has_many    :contexts, :cases
 
-  def initialize(attrs = {})
+  def fetch
+    update_attributes(application.api_client.get("language", {:locale => locale}))
+    self
+  end
+
+  def update_attributes(attrs)
     super
 
     self.attributes[:contexts] = {}
@@ -52,7 +58,7 @@ class Tr8n::Language < Tr8n::Base
     contexts.values.detect{|ctx| ctx.applies_to_token?(token_name)}
   end
 
-  def language_case_by_keyword(keyword)
+  def case_by_keyword(keyword)
     cases[keyword]
   end
 

data/lib/tr8n/language_case.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -49,6 +50,9 @@ class Tr8n::LanguageCase < Tr8n::Base
 
   def apply(value, object = nil, options = {})
     value = value.to_s
+
+    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, "")
 

data/lib/tr8n/language_case_rule.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/language_context.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -78,6 +79,8 @@ class Tr8n::LanguageContext < Tr8n::Base
           else
             vars[key] = object.send(method)
           end
+        elsif obj.is_a?(String)
+          vars[key] = obj
         else
           vars[key] = obj.send(method)
         end

data/lib/tr8n/language_context_rule.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/logger.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -55,7 +56,7 @@ module Tr8n
 
     def trace_api_call(path, params)
       [:client_secret, :access_token].each do |param|
-        params = params.merge(param => "##filtered##")
+        params = params.merge(param => "##filtered##") if params[param]
       end
       debug("api: [/#{path}] #{params.inspect}")
       stack.push(caller)

data/lib/tr8n/rules_engine/evaluator.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/rules_engine/parser.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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

data/lib/tr8n/session.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -27,20 +28,26 @@ module Tr8n
     Thread.current[:session] ||= Tr8n::Session.new
   end
 
-  # Acts as a global singleton that holds all Tr8n configuration
-  # The class can be extended with a different implementation, as long as the interface is supported
   class Session
     # Session Attributes - Move to Session
     attr_accessor :application, :current_user, :current_language, :current_translator,
                   :current_source, :current_component, :block_options
 
-    def init
-      return unless Tr8n.config.application # not configured
+    def init(key = nil, secret = nil, host = nil)
+      key     ||= Tr8n.config.application[:key]
+      secret  ||= Tr8n.config.application[:secret]
+      host    ||= Tr8n.config.application[:host]
 
-      unless @application
-        Tr8n::Application.init(Tr8n.config.application[:key], Tr8n.config.application[:secret], Tr8n.config.application[:host])
+      Tr8n.cache.reset_version
+
+      self.application = Tr8n.cache.fetch(Tr8n::Application.cache_key(key)) do
+        Tr8n.logger.info("Initializing application...")
+        Tr8n::Application.new(:host => host, :key => key, :secret => secret).fetch
       end
+
       self.current_source = "/tr8n/core"
+
+      self.application
     end
 
     def reset
@@ -53,6 +60,13 @@ module Tr8n
       self.block_options= nil
     end
 
+    def current_language
+      @current_language ||= Tr8n.config.default_language
+    end
+
+    def application
+      @application ||= Tr8n::Application.new(:host => Tr8n::ApiClient::API_HOST)
+    end
     #########################################################
     ## Block Options
     #########################################################

data/lib/tr8n/source.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2014 Michael Berkovich, tr8nhub.com
+# 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
@@ -56,7 +57,7 @@ class Tr8n::Source < Tr8n::Base
   def fetch_translations_for_language(language, options = {})
     return translation_keys if translation_keys
 
-    keys_with_translations = application.get("source/translations",
+    keys_with_translations = application.api_client.get("source/translations",
                                              {:source => source, :locale => language.locale},
                                              {:class => Tr8n::TranslationKey, :attributes => {:application => application}})
 

data/lib/tr8n/tokens/data.rb

@@ -1,5 +1,6 @@
+# encoding: UTF-8
 #--
-# Copyright (c) 2013 Michael Berkovich, tr8nhub.com
+# 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
@@ -21,390 +22,383 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-#######################################################################
-#
-# Data Token Forms:
-#
-# {count}
-# {count:number}
-# {user:gender}
-# {today:date}
-# {user_list:list}
-# {long_token_name}
-# {user1}
-# {user1:user}
-# {user1:user::pos}
-#
-# Data tokens can be associated with any rules through the :dependency
-# notation or using the naming convention of the token suffix, defined
-# in the tr8n configuration file
-#
-#######################################################################
-
-class Tr8n::Tokens::Data < Tr8n::Base
-  attr_reader :label, :full_name, :short_name, :case_keys, :context_keys
-
-  def self.expression
-    /(\{[^_:][\w]*(:[\w]+)*(::[\w]+)*\})/
-  end
-
-  def self.parse(label, opts = {})
-    tokens = []
-    label.scan(expression).uniq.each do |token_array|
-      tokens << self.new(label, token_array.first)
-    end
-    tokens
-  end
-
-  def initialize(label, token)
-    @label = label
-    @full_name = token
-    parse_elements
-  end
+module Tr8n
+  module Tokens
+    class Data
 
-  def parse_elements
-    name_without_parens = self.full_name[1..-2]
-    name_without_case_keys = name_without_parens.split('::').first.strip
+      attr_reader :label, :full_name, :short_name, :case_keys, :context_keys
 
-    @short_name = name_without_parens.split(':').first.strip
-    @case_keys = name_without_parens.scan(/(::\w+)/).flatten.uniq.collect{|c| c.gsub('::', '')}
-    @context_keys = name_without_case_keys.scan(/(:\w+)/).flatten.uniq.collect{|c| c.gsub(':', '')}
-  end
-
-  def name(opts = {})
-    val = short_name
-    val = "#{val}:#{context_keys.join(':')}" if opts[:context_keys] and context_keys.any?
-    val = "#{val}::#{case_keys.join('::')}" if opts[:case_keys] and case_keys.any?
-    val = "{#{val}}" if opts[:parens]
-    val
-  end
+      def self.expression
+        /(\{[^_:][\w]*(:[\w]+)*(::[\w]+)*\})/
+      end
 
-  def key
-    short_name.to_sym
-  end
+      def self.parse(label, opts = {})
+        tokens = []
+        label.scan(expression).uniq.each do |token_array|
+          tokens << self.new(label, token_array.first)
+        end
+        tokens
+      end
 
-  # used by the translator submit dialog
-  def name_for_case_keys(keys)
-    keys = [keys] unless keys.is_a?(Array)
-    "#{name}::#{keys.join('::')}"
-  end
+      def initialize(label, token)
+        @label = label
+        @full_name = token
+        parse_elements
+      end
 
-  def sanitize(object, value, options, language)
-    value = "#{value.to_s}" unless value.is_a?(String)
+      def parse_elements
+        name_without_parens = @full_name[1..-2]
+        name_without_case_keys = name_without_parens.split('::').first.strip
 
-    unless Tr8n.session.block_options[:skip_html_escaping]
-      if options[:sanitize_values]
-        value = ERB::Util.html_escape(value)
+        @short_name = name_without_parens.split(':').first.strip
+        @case_keys = name_without_parens.scan(/(::\w+)/).flatten.uniq.collect{|c| c.gsub('::', '')}
+        @context_keys = name_without_case_keys.scan(/(:\w+)/).flatten.uniq.collect{|c| c.gsub(':', '')}
       end
-    end
 
-    if Tr8n.session.application and not Tr8n.session.application.feature_enabled?(:language_cases)
-      return value
-    end
+      def name(opts = {})
+        val = short_name
+        val = "#{val}:#{context_keys.join(':')}" if opts[:context_keys] and context_keys.any?
+        val = "#{val}::#{case_keys.join('::')}" if opts[:case_keys] and case_keys.any?
+        val = "{#{val}}" if opts[:parens]
+        val
+      end
 
-    case_keys.each do |key|
-      value = apply_case(key, value, object, options, language)
-    end
+      def key
+        short_name.to_sym
+      end
 
-    value
-  end
+      # used by the translator submit dialog
+      def name_for_case_keys(keys)
+        keys = [keys] unless keys.is_a?(Array)
+        "#{name}::#{keys.join('::')}"
+      end
 
-  def context_for_language(language, opts = {})
-    if context_keys.any?
-      ctx = language.context_by_keyword(context_keys.first)
-    else
-      ctx = language.context_by_token_name(short_name)
-    end
+      def context_for_language(language, opts = {})
+        if context_keys.any?
+          ctx = language.context_by_keyword(context_keys.first)
+        else
+          ctx = language.context_by_token_name(short_name)
+        end
 
-    unless opts[:silent]
-      raise Tr8n::Exception.new("Unknown context for a token: #{full_name} in #{language.locale}") unless ctx
-    end
+        unless opts[:silent]
+          raise Tr8n::Exception.new("Unknown context for a token: #{full_name} in #{language.locale}") unless ctx
+        end
 
-    ctx
-  end
+        ctx
+      end
 
-  ##############################################################################
-  #
-  # chooses the appropriate case for the token value. case is identified with ::
-  #
-  # examples:
-  #
-  # tr("Hello {user::nom}", "", :user => current_user)
-  # tr("{actor} gave {target::dat} a present", "", :actor => user1, :target => user2)
-  # tr("This is {user::pos} toy", "", :user => current_user)
-  #
-  ##############################################################################
-  def apply_case(key, value, object, options, language)
-    lcase = language.language_case_by_keyword(key)
-    return value unless lcase
-    lcase.apply(value, object, options)
-  end
+      ##############################################################################
+      #
+      # returns token object from tokens param
+      #
+      ##############################################################################
+
+      def self.token_object(token_values, token_name)
+        return nil if token_values.nil?
+        token_object = Tr8n::Utils.hash_value(token_values, token_name)
+        return token_object.first if token_object.is_a?(Array)
+        if token_object.is_a?(Hash)
+          object = Tr8n::Utils.hash_value(token_object, :object)
+          return object if object
+        end
+        token_object
+      end
 
-  def decoration?
-    false
-  end
+      ##############################################################################
+      #
+      # tr("Hello {user_list}!", "", {:user_list => [[user1, user2, user3], :name]}}
+      #
+      # first element is an array, the rest of the elements are similar to the
+      # regular tokens lambda, symbol, string, with parameters that follow
+      #
+      # if you want to pass options, then make the second parameter an array as well
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], :name]})
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], lambda{|user| user.name}]})
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], {:attribute => :name})
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], {:attribute => :name, :value => "<strong>{$0}</strong>"})
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], "<strong>{$0}</strong>")
+      #
+      # tr("{users} joined the site", {:users => [[user1, user2, user3], :name, {
+      #   :limit => 4,
+      #   :separator => ', ',
+      #   :joiner => 'and',
+      #   :remainder => lambda{|elements| tr("#{count||other}", :count => elements.size)},
+      #   :expandable => true,
+      #   :collapsable => true
+      # })
+      #
+      #
+      ##############################################################################
+      def token_value_from_array(params, language, options)
+        list_options = {
+         :description => "List joiner",
+         :limit => 4,
+         :separator => ", ",
+         :joiner => 'and',
+         :less => '{laquo} less',
+         :expandable => true,
+         :collapsable => true
+        }
+
+        objects = params[0]
+        method = params[1]
+        list_options.merge!(params[2]) if params.size > 2
+        list_options[:expandable] = false if options[:skip_decorations]
+
+        values = objects.collect do |obj|
+          if method.is_a?(String)
+            method.gsub("{$0}", sanitize(obj.to_s, obj, language, options.merge(:safe => false)))
+          elsif method.is_a?(Symbol)
+            if obj.is_a?(Hash)
+              value = Tr8n::Utils.hash_value(obj, method)
+            else
+              value = obj.send(method)
+            end
+            sanitize(value, obj, language, options.merge(:safe => false))
+          elsif method.is_a?(Hash)
+            attr = Tr8n::Utils.hash_value(method, :attribute) || Tr8n::Utils.hash_value(method, :property)
+            if obj.is_a?(Hash)
+              value = Tr8n::Utils.hash_value(obj, attr)
+            else
+              value = obj.send(method)
+            end
+
+            hash_value = Tr8n::Utils.hash_value(method, :value)
+            if hash_value
+              hash_value.gsub("{$0}", sanitize(value, obj, language, options.merge(:safe => false)))
+            else
+              sanitize(value, obj, language, options.merge(:safe => false))
+            end
+          elsif method.is_a?(Proc)
+            sanitize(method.call(obj), obj, language, options.merge(:safe => true))
+          end
+        end
 
-  ##############################################################################
-  #
-  # gets the value based on various evaluation methods
-  #
-  # examples:
-  #
-  # tr("Hello {user}", "", {:user => [current_user, current_user.name]}}
-  # tr("Hello {user}", "", {:user => [current_user, "{$0} {$1}", "param1"]}}
-  # tr("Hello {user}", "", {:user => [current_user, :name]}}
-  # tr("Hello {user}", "", {:user => [current_user, :method_name, "param1"]}}
-  # tr("Hello {user}", "", {:user => [current_user, lambda{|user| user.name}]}}
-  # tr("Hello {user}", "", {:user => [current_user, lambda{|user, param1| user.name}, "param1"]}}
-  #
-  ##############################################################################
-  def evaluate_token_method_array(object, method_array, options, language)
-    # if single object in the array return string value of the object
-    if method_array.size == 1
-      return sanitize(object, object.to_s, options, language)
-    end
+        return values.first if objects.size == 1
+        return values.join(list_options[:separator]) unless list_options[:joiner]
 
-    # second params identifies the method to be used with the object
-    method = method_array[1]
-    params = method_array[2..-1]
-    params_with_object = [object] + params
-
-    # if the second param is a string, substitute all of the numeric params,
-    # with the original object and all the following params
-    if method.is_a?(String)
-      parametrized_value = method.clone
-      if parametrized_value.index("{$")
-        params_with_object.each_with_index do |val, i|
-          parametrized_value.gsub!("{$#{i}}", sanitize(object, val, options.merge(:skip_decorations => true), language))
+        if values.size <= list_options[:limit]
+          return "#{values[0..-2].join(list_options[:separator])} #{language.translate(list_options[:joiner], list_options[:description], {}, options)} #{values.last}"
         end
-      end
-      return sanitize(object, parametrized_value, options, language)
-    end
 
-    # if second param is symbol, invoke the method on the object with the remaining values
-    if method.is_a?(Symbol)
-      return sanitize(object, object.send(method, *params), options.merge(:sanitize_values => true), language)
-    end
+        display_ary = values[0..(list_options[:limit]-1)]
+        remaining_ary = values[list_options[:limit]..-1]
+        result = "#{display_ary.join(list_options[:separator])}"
+
+        unless list_options[:expandable]
+          result << " " << language.translate(list_options[:joiner], list_options[:description], {}, options) << " "
+          if list_options[:remainder] and list_options[:remainder].is_a?(Proc)
+            result << list_options[:remainder].call(remaining_ary)
+          else
+            result << language.translate("{count||other}", list_options[:description], {:count => remaining_ary.size}, options)
+          end
+          return result
+        end
 
-    # if second param is lambda, call lambda with the remaining values
-    if method.is_a?(Proc)
-      return sanitize(object, method.call(*params_with_object), options, language)
-    end
+        joiner = language.translate(list_options[:joiner], list_options[:description], {}, options)
 
-    if method.is_a?(Hash)
-      value = hash_value(method, :value)
-      attr  = hash_value(method, :attribute)
+        uniq_id = Tr8n::TranslationKey.generate_key(label, values.join(","))
+        result << "<span id=\"tr8n_other_link_#{uniq_id}\">"
+        result << " #{joiner} "
 
-      unless attr.nil?
-        if object.is_a?(Hash)
-          value = hash_value(object, attr)
+        result << "<a href='#' onClick=\"Tr8n.Utils.Effects.hide('tr8n_other_link_#{uniq_id}'); Tr8n.Utils.Effects.show('tr8n_other_elements_#{uniq_id}'); return false;\">"
+        if list_options[:remainder] and list_options[:remainder].is_a?(Proc)
+          result << list_options[:remainder].call(remaining_ary)
         else
-          value = object.send(attr)
+          result << language.translate("{count||other}", list_options[:description], {:count => remaining_ary.size}, options)
+        end
+        result << "</a></span>"
+
+        result << "<span id=\"tr8n_other_elements_#{uniq_id}\" style='display:none'>"
+        result << list_options[:separator] << " "
+        result << remaining_ary[0..-2].join(list_options[:separator])
+        result << " #{joiner} "
+        result << remaining_ary.last
+
+        if list_options[:collapsable]
+          result << "<a href='#' style='font-size:smaller;white-space:nowrap' onClick=\"Tr8n.Utils.Effects.show('tr8n_other_link_#{uniq_id}'); Tr8n.Utils.Effects.hide('tr8n_other_elements_#{uniq_id}'); return false;\"> "
+          result << language.translate(list_options[:less], list_options[:description], {}, options)
+          result << "</a>"
         end
-      end
 
-      if value.nil?
-        return raise Tr8n::Exception.new("Hash object is missing a value or attribute key for a token: #{full_name}")
+        result << "</span>"
       end
 
-      return sanitize(object,value, options, language)
-    end
+      ##############################################################################
+      #
+      # gets the value based on various evaluation methods
+      #
+      # examples:
+      #
+      # tr("Hello {user}", {:user => [current_user, current_user.name]}}
+      # tr("Hello {user}", {:user => [current_user, :name]}}
+      #
+      # tr("Hello {user}", {:user => [{:name => "Michael", :gender => :male}, current_user.name]}}
+      # tr("Hello {user}", {:user => [{:name => "Michael", :gender => :male}, :name]}}
+      #
+      ##############################################################################
+
+      def token_value_from_param_array(array, language, options)
+        # if you provided an array, it better have some values
+        if array.size < 2
+          Tr8n.logger.error("Invalid value for array token #{full_name} in #{label}")
+          return full_name
+        end
 
-    raise Tr8n::Exception.new("Invalid array second token value: #{full_name} in #{label}")
-  end
+        # if the first value of an array is an array handle it here
+        if array[0].is_a?(Array)
+          return token_value_from_array(array, language, options)
+        end
 
-  def self.token_object(token_values, token_name)
-    return nil if token_values.nil?
-    object = token_values[token_name.to_s] || token_values[token_name.to_sym]
+        if array[1].is_a?(String)
+          return sanitize(array[1], array[0], language, options.merge(:safe => true))
+        end
 
-    # for arrays
-    return object.first if object.is_a?(Array)
+        if array[1].is_a?(Hash)
+          if array[1].is_a?(Symbol)
+            return sanitize(Tr8n::Utils.hash_value(array[0], array[1]), array[0], language, options.merge(:safe => false))
+          end
 
-    # hash maybe nested {:object => {}, :attribute => ""}
-    if object.is_a?(Hash)
-      sub_object = object[:object] || object['object']
-      return sub_object if sub_object
-    end
+          Tr8n.logger.error("Invalid value for array token #{full_name} in #{label}")
+          return full_name
+        end
 
-    object
-  end
+        # if second param is symbol, invoke the method on the object with the remaining values
+        if array[1].is_a?(Symbol)
+          return sanitize(array[0].send(array[1]), array[0], language, options.merge(:safe => false))
+        end
 
-  ##############################################################################
-  #
-  # tr("Hello {user_list}!", "", {:user_list => [[user1, user2, user3], :name]}}
-  #
-  # first element is an array, the rest of the elements are similar to the
-  # regular tokens lambda, symbol, string, with parameters that follow
-  #
-  # if you want to pass options, then make the second parameter an array as well
-  # tr("{user_list} joined the site", "",
-  #       {:user_list => [[user1, user2, user3],
-  #                         [:name],      # this can be any of the value methods
-  #                         { :expandable => true,
-  #                           :to_sentence => true,
-  #                           :limit => 4,
-  #                           :separator => ',',
-  #                           :andor => 'and',
-  #                           :translate_items => false,
-  #                           :minimizable => true
-  #                         }
-  #                       ]
-  #                      ]})
-  #
-  # acceptable params:  expandable,
-  #                     to_sentence,
-  #                     limit,
-  #                     andor,
-  #                     more_label,
-  #                     less_label,
-  #                     separator,
-  #                     translate_items,
-  #                     minimizable
-  #
-  ##############################################################################
-  def token_array_value(token_value, options, language)
-    objects = token_value.first
-
-    objects = objects.collect do |obj|
-      if token_value[1].is_a?(Array)
-        evaluate_token_method_array(obj, [obj] + token_value[1], options, language)
-      else
-        evaluate_token_method_array(obj, token_value, options, language)
+        Tr8n.logger.error("Invalid value for array token #{full_name} in #{label}")
+        full_name
       end
-    end
-
-    list_options = {
-        :translate_items => false,
-        :expandable => true,
-        :minimizable => true,
-        :to_sentence => true,
-        :limit => 4,
-        :separator => ", ",
-        :andor => 'and'
-    }
-
-    if token_value[1].is_a?(Array) and token_value.size == 3
-      list_options.merge!(token_value.last)
-    end
 
-    objects = objects.collect{|obj| obj.translate("List element", {}, options)} if list_options[:translate_items]
+      ##############################################################################
+      #
+      # examples:
+      #
+      # tr("Hello {user}", {:user => {:value => "Michael", :gender => :male}}}
+      #
+      # tr("Hello {user}", {:user => {:object => {:gender => :male}, :value => "Michael"}}}
+      # tr("Hello {user}", {:user => {:object => {:name => "Michael", :gender => :male}, :property => :name}}}
+      # tr("Hello {user}", {:user => {:object => {:name => "Michael", :gender => :male}, :attribute => :name}}}
+      #
+      # tr("Hello {user}", {:user => {:object => user, :value => "Michael"}}}
+      # tr("Hello {user}", {:user => {:object => user, :property => :name}}}
+      # tr("Hello {user}", {:user => {:object => user, :attribute => :name}}}
+      #
+      ##############################################################################
+
+      def token_value_from_param_hash(hash, language, options)
+        value = Tr8n::Utils.hash_value(hash, :value)
+        object = Tr8n::Utils.hash_value(hash, :object)
+
+        unless value.nil?
+          return sanitize(value, object || hash, language, options.merge(:safe => true))
+        end
 
-    # if there is only one element in the array, use it and get out
-    return objects.first if objects.size == 1
+        if object.nil?
+          Tr8n.logger.error("Missing value for hash token #{full_name} in #{label}")
+          return full_name
+        end
 
-    list_options[:expandable] = false if options[:skip_decorations]
+        attr  = Tr8n::Utils.hash_value(hash, :attribute) || Tr8n::Utils.hash_value(hash, :property)
 
-    return objects.join(list_options[:separator]) unless list_options[:to_sentence]
+        if object.is_a?(Hash)
+          unless attr.nil?
+            return sanitize(Tr8n::Utils.hash_value(object, attr), object, language, options.merge(:safe => false))
+          end
 
-    if objects.size <= list_options[:limit]
-      return "#{objects[0..-2].join(list_options[:separator])} #{list_options[:andor].translate("", {}, options)} #{objects.last}"
-    end
+          Tr8n.logger.error("Missing value for hash token #{full_name} in #{label}")
+          return full_name
+        end
 
-    display_ary = objects[0..(list_options[:limit]-1)]
-    remaining_ary = objects[list_options[:limit]..-1]
-    result = "#{display_ary.join(list_options[:separator])}"
+        sanitize(object.send(attr), object, language, options.merge(:safe => false))
+      end
 
-    unless list_options[:expandable]
-      result << " " << list_options[:andor].translate("", {}, options) << " "
-      result << "{num|| other}".translate("List elements joiner", {:num => remaining_ary.size}, options)
-      return result
-    end
+      # evaluate all possible methods for the token value and return sanitized result
+      def token_value(object, language, options = {})
+        return token_value_from_param_array(object, language, options) if object.is_a?(Array)
+        return token_value_from_param_hash(object, language, options) if object.is_a?(Hash)
+        sanitize(object, object, language, options)
+      end
 
-    uniq_id = Tr8n::TranslationKey.generate_key(label, objects.join(","))
-    result << "<span id=\"tr8n_other_link_#{uniq_id}\">" << " " << list_options[:andor].translate("", {}, options) << " "
-    result << "<a href='#' onClick=\"Tr8n.Utils.Effects.hide('tr8n_other_link_#{uniq_id}'); Tr8n.Utils.Effects.show('tr8n_other_elements_#{uniq_id}'); return false;\">"
-    result << (list_options[:more_label] ? list_options[:more_label] : "{num|| other}".translate("List elements joiner", {:num => remaining_ary.size}, options))
-    result << "</a></span>"
-    result << "<span id=\"tr8n_other_elements_#{uniq_id}\" style='display:none'>" << list_options[:separator]
-    result << "#{remaining_ary[0..-2].join(list_options[:separator])} #{list_options[:andor].translate("", {}, options)} #{remaining_ary.last}"
-
-    if list_options[:minimizable]
-      result << "<a href='#' style='font-size:smaller;white-space:nowrap' onClick=\"Tr8n.Utils.Effects.show('tr8n_other_link_#{uniq_id}'); Tr8n.Utils.Effects.hide('tr8n_other_elements_#{uniq_id}'); return false;\"> "
-      result << (list_options[:less_label] ? list_options[:less_label] : "{laquo} less".translate("List elements joiner", {}, options))
-      result << "</a>"
-    end
+      def sanitize(value, object, language, options)
+        value = value.to_s
 
-    result << "</span>"
-  end
+        unless Tr8n.session.block_options[:skip_html_escaping]
+          if options[:safe] == false
+            value = ERB::Util.html_escape(value)
+          end
+        end
 
-  # evaluate all possible methods for the token value and return sanitized result
-  def token_value(object, options, language)
-    # token is an array
-    if object.is_a?(Array)
-      # if you provided an array, it better have some values
-      if object.empty?
-        return raise Tr8n::Exception.new("Invalid array value for a token: #{full_name}")
+        return value unless language_cases_enabled?
+        apply_language_cases(value, object, language, options)
       end
 
-      # if the first value of an array is an array handle it here
-      if object.first.kind_of?(Enumerable)
-        return token_array_value(object, options, language)
+      def language_cases_enabled?
+        Tr8n.session.application and Tr8n.session.application.feature_enabled?(:language_cases)
       end
 
-      # if the first item in the array is an object, process it
-      return evaluate_token_method_array(object.first, object, options, language)
-    end
-
-    if object.is_a?(Hash)
-      # if object is a hash, it must be of a form: {:object => {}, :value => "", :attribute => ""}
-      # either value can be passed, or the attribute. attribute will be used first
-      if hash_value(object, :object).nil?
-        return raise Tr8n::Exception.new("Hash token is missing an object key for a token: #{full_name}")
+      ##############################################################################
+      #
+      # chooses the appropriate case for the token value. case is identified with ::
+      #
+      # examples:
+      #
+      # tr("Hello {user::nom}", "", :user => current_user)
+      # tr("{actor} gave {target::dat} a present", "", :actor => user1, :target => user2)
+      # tr("This is {user::pos} toy", "", :user => current_user)
+      #
+      ##############################################################################
+      def apply_case(key, value, object, language, options)
+        lcase = language.case_by_keyword(key)
+        return value unless lcase
+        lcase.apply(value, object, options)
       end
 
-      obj   = hash_value(object, :object)
-      value = hash_value(object, :value)
-      attr  = hash_value(object, :attribute)
-
-      unless attr.nil?
-        if obj.is_a?(Hash)
-          value = hash_value(obj, attr)
-        else
-          value = obj.send(attr)
+      def apply_language_cases(value, object, language, options)
+        case_keys.each do |key|
+          value = apply_case(key, value, object, language, options)
         end
-      end
 
-      if value.nil?
-        return raise Tr8n::Exception.new("Hash object is missing a value or attribute key for a token: #{full_name}")
+        value
       end
 
-      return sanitize(obj, value.to_s, options, language)
-    end
-
-    # simple token
-    sanitize(object, object.to_s, options, language)
-  end
+      def substitute(label, context, language, options = {})
+        # get the object from the values
+        object = Tr8n::Utils.hash_value(context, key)
 
-  def allowed_in_translation?
-    true
-  end
+        # see if the token is a default html token
+        object = Tr8n.config.default_token_value(key) if object.nil?
 
-  def implied?
-    false
-  end
-
-  def substitute(label, context, language, options = {})
-    # get the object from the values
-    object = hash_value(context, key, :whole => true)
-
-    # see if the token is a default html token
-    object = Tr8n.config.default_token_value(key) if object.nil?
+        if object.nil? and not context.key?(key)
+          Tr8n.logger.error("Missing value for #{full_name} in #{label}")
+          return label
+        end
 
-    #if object.nil?
-    #  raise Tr8n::Exception.new("Missing value for a token: #{full_name}")
-    #end
+        if object.nil? and not Tr8n::Config.allow_nil_token_values?
+          Tr8n.logger.error("Token value is nil for #{full_name} in #{label}")
+          return label
+        end
 
-    object = object.to_s if object.nil?
+        return label.gsub(full_name, "") if object.nil?
 
-    value = token_value(object, options, language)
-    label.gsub(full_name, value)
-  end
+        value = token_value(object, language, options)
+        label.gsub(full_name, value)
+      end
 
-  def sanitized_name
-    name(:parens => true)
-  end
+      def sanitized_name
+        name(:parens => true)
+      end
 
-  def to_s
-    full_name
+      def to_s
+        full_name
+      end
+    end
   end
 end