tml 4.4.7 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ee215776a93a3de80da5b0f4f432ea99e44e577
-  data.tar.gz: b2dd1de37941aaef3224de6a2458cbf5cc74c6ca
+  metadata.gz: 5a514613d1a01ea544a896e526f38e5f9843df78
+  data.tar.gz: b1dceccffd886b61d390dbf323da3578b181835f
 SHA512:
-  metadata.gz: 6a3a8087e25ca982bcc9ed6ed27e74ac53bac437738512bbe1a754f9d23e0ea82e3aaceeae1a6ae425cf53767ff558454a868985b09ff14cbc11a2510ba313a0
-  data.tar.gz: cc3e5c6524a9690e774a31b3aeefeae710a567b67e1e98bd03cf99b3f12799b7c71a4e75b105cc11e0b0fa8c7ab14115a10436d332b631b2f2d849caeac687d6
+  metadata.gz: f86dea985be31eaf6fcfc391615bc1287dd932704c736781834ba7d5acb029ff2f7e251893ff0593d5a1502442e62f392bc472d2f54279712661a4290e8267ed
+  data.tar.gz: 47cb409b52c980688d033f7e5b1588d1a4424d1e501f12bf564e17813b4fca668b2065ba23ccda4c24286a3a703c758c0386b1fc1b1fd45ec264c9a727e26dd1

data/lib/tml/api/client.rb

@@ -31,6 +31,8 @@
 #++
 
 require 'faraday'
+require 'zlib'
+require 'stringio'
 
 class Tml::Api::Client < Tml::Base
   CDN_HOST = 'https://cdn.translationexchange.com'
@@ -107,10 +109,12 @@ class Tml::Api::Client < Tml::Base
     return nil if Tml.cache.version == 'undefined' || Tml.cache.version.to_s == '0'
 
     response = nil
-    cdn_path = "#{Tml.config.access_token}/#{Tml.cache.version}/#{key}.json"
-    trace_api_call(cdn_path, params, opts) do
+    cdn_path = "/#{Tml.config.application[:key]}/#{Tml.cache.version}/#{key}.json.gz"
+    trace_api_call(cdn_path, params, opts.merge(:host => cdn_host)) do
       begin
-        response = cdn_connection.get(cdn_path, params)
+        response = cdn_connection.get do |request|
+          prepare_request(request, cdn_path, params)
+        end
       rescue Exception => ex
         Tml.logger.error("Failed to execute request: #{ex.message[0..255]}")
         return nil
@@ -119,8 +123,14 @@ class Tml::Api::Client < Tml::Base
     return if response.status >= 500 and response.status < 600
     return if response.body.nil? or response.body == '' or response.body.match(/xml/)
 
+    compressed_data = response.body
+    return if compressed_data.nil? or compressed_data == ''
+
+    data = Zlib::GzipReader.new(StringIO.new(compressed_data.to_s)).read
+    Tml.logger.debug("Compressed: #{compressed_data.length} Uncompressed: #{data.length}")
+
     begin
-      data = JSON.parse(response.body)
+      data = JSON.parse(data)
     rescue Exception => ex
       return nil
     end
@@ -172,19 +182,31 @@ class Tml::Api::Client < Tml::Base
     "#{API_PATH}#{path[0] == '/' ? '' : '/'}#{path}"
   end
 
+  def prepare_request(request, path, params)
+    request.options.timeout = 5
+    request.options.open_timeout = 2
+    request.headers['User-Agent']       = "tml-ruby v#{Tml::VERSION} (Faraday v#{Faraday::VERSION})"
+    request.headers['Accept']           = 'application/json'
+    request.headers['Accept-Encoding']  = 'gzip, deflate'
+    request.url(path, params)
+  end
+
   def execute_request(path, params = {}, opts = {})
     response = nil
     error = nil
 
+    token = Tml.config.application ? Tml.config.application[:token] : ''
+
     # oauth path is separate from versioned APIs
     path = prepare_api_path(path)
-    params = params.merge(:access_token => Tml.config.access_token) unless path.index('oauth')
+    params = params.merge(:access_token => token) unless path.index('oauth')
 
     if opts[:method] == :post
       params = params.merge(:api_key => application.key)
     end
 
-    trace_api_call(path, params, opts) do
+    @compressed = false
+    trace_api_call(path, params, opts.merge(:host => host)) do
       begin
         if opts[:method] == :post
           response = connection.post(path, params)
@@ -193,7 +215,10 @@ class Tml::Api::Client < Tml::Base
         elsif opts[:method] == :delete
           response = connection.delete(path, params)
         else
-          response = connection.get(path, params)
+          response = connection.get do |request|
+            @compressed = true
+            prepare_request(request, path, params)
+          end
         end
       rescue Exception => ex
         Tml.logger.error("Failed to execute request: #{ex.message[0..255]}")
@@ -207,11 +232,20 @@ class Tml::Api::Client < Tml::Base
       raise Tml::Exception.new("Error: #{response.body}")
     end
 
-    return if response.body.nil? or response.body == ''
-    return response.body if opts[:raw]
+    if @compressed
+      compressed_data = response.body
+      return if compressed_data.nil? or compressed_data == ''
+
+      data = Zlib::GzipReader.new(StringIO.new(compressed_data.to_s)).read
+      Tml.logger.debug("Compressed: #{compressed_data.length} Uncompressed: #{data.length}")
+    else
+      data = response.body
+    end
+
+    return data if opts[:raw]
 
     begin
-      data = JSON.parse(response.body)
+      data = JSON.parse(data)
     rescue Exception => ex
       raise Tml::Exception.new("Failed to parse response: #{ex.message[0..255]}")
     end
@@ -260,9 +294,13 @@ class Tml::Api::Client < Tml::Base
     #end
 
     if opts[:method] == :post
-      Tml.logger.debug("post: [#{path}]")
+      Tml.logger.debug("post: #{opts[:host]}#{path}")
     else
-      Tml.logger.debug("get: #{path}?#{to_query(params)}")
+      if params.any?
+        Tml.logger.debug("get: #{opts[:host]}#{path}?#{to_query(params)}")
+      else
+        Tml.logger.debug("get: #{opts[:host]}#{path}")
+      end
     end
 
     t0 = Time.now

data/lib/tml/application.rb

@@ -34,18 +34,27 @@ require 'faraday'
 
 class Tml::Application < Tml::Base
   attributes :host, :id, :key, :access_token,  :name, :description, :threshold, :default_locale, :default_level, :tools
-  has_many :features, :languages, :featured_locales, :sources, :components, :tokens, :css, :shortcuts, :translations
+  has_many :features, :languages, :languages_by_locale, :sources, :tokens, :css, :shortcuts, :translations, :extensions
 
+  # Returns application cache key
   def self.cache_key
     'application'
   end
 
+  # Returns translations cache key
   def self.translations_cache_key(locale)
     "#{locale}/translations"
   end
 
+  # Fetches application definition from the service
   def fetch
-    data = api_client.get('applications/current', {:definition => true}, {:cache_key => self.class.cache_key})
+    data = api_client.get('projects/current/definition',{
+      locale: Tml.session.current_locale,
+      source: Tml.session.current_source
+    }, {
+      cache_key: self.class.cache_key
+    })
+
     if data
       update_attributes(data)
     else
@@ -58,6 +67,7 @@ class Tml::Application < Tml::Base
     self
   end
 
+  # Updates application attributes
   def update_attributes(attrs)
     super
 
@@ -66,79 +76,119 @@ class Tml::Application < Tml::Base
       self.attributes[:languages] = hash_value(attrs, :languages).collect{ |l| Tml::Language.new(l.merge(:application => self)) }
     end
 
+    load_extensions(hash_value(attrs, :extensions))
+
     self
   end
 
+  # Loads application extensions, if any
+  def load_extensions(extensions)
+    return if extensions.nil?
+    source_locale = default_locale
+
+    cache = Tml.cache
+    cache = nil if not Tml.cache.enabled? or Tml.session.inline_mode?
+
+    if hash_value(extensions, :languages)
+      self.languages_by_locale ||= {}
+      hash_value(extensions, :languages).each do |locale, data|
+        source_locale = locale if locale != source_locale
+        cache.store(Tml::Language.cache_key(locale), data) if cache
+        self.languages_by_locale[locale] = Tml::Language.new(data.merge(
+          locale: locale,
+          application: self
+        ))
+      end
+    end
+
+    if hash_value(extensions, :sources)
+      self.sources ||= {}
+      hash_value(extensions, :sources).each do |source, data|
+        cache.store(Tml::Source.cache_key(source_locale, source), data) if cache
+        self.sources[source] ||= Tml::Source.new(
+          application:  self,
+          source:       source
+        )
+        self.sources[source].update_translations(source_locale, data['results'])
+      end
+    end
+  end
+
+  # Returns language by locale
   def language(locale = nil)
-    locale = nil if locale.strip == ''
+    locale = nil if locale and locale.strip == ''
 
     locale ||= default_locale || Tml.config.default_locale
-    @languages_by_locale ||= {}
-    @languages_by_locale[locale] ||= api_client.get(
-      "languages/#{locale}",
-      {:definition => true},
-      {
-        :class => Tml::Language,
-        :attributes => {:locale => locale, :application => self},
-        :cache_key => Tml::Language.cache_key(locale)
-      }
-    )
+    locale = locale.to_s
+
+    self.languages_by_locale ||= {}
+    self.languages_by_locale[locale] ||= api_client.get("languages/#{locale}/definition", {
+    }, {
+      class:      Tml::Language,
+      attributes: {locale: locale, application: self},
+      cache_key:  Tml::Language.cache_key(locale)
+    })
   rescue Tml::Exception => e
     Tml.logger.error(e)
     Tml.logger.error(e.backtrace)
-    @languages_by_locale[locale] = Tml.config.default_language
+    self.languages_by_locale[locale] = Tml.config.default_language
   end
 
+  # Normalizes and returns current language
+  # TODO: verify usage
   def current_language(locale)
-    locale = locale.gsub('_', '-')
+    locale = locale.gsub('_', '-') if locale
     lang = language(locale)
     lang ||= language(locale.split('-').first) if locale.index('-')
     lang ||= Tml.config.default_language
     lang
   end
 
-  # Mostly used for testing
+  # Adds a language to the application
   def add_language(new_language)
-    @languages_by_locale ||= {}
-    return @languages_by_locale[new_language.locale] if @languages_by_locale[new_language.locale]
+    self.languages_by_locale ||= {}
+    return self.languages_by_locale[new_language.locale] if self.languages_by_locale[new_language.locale]
     new_language.application = self
     self.languages << new_language
-    @languages_by_locale[new_language.locale] = new_language
+    self.languages_by_locale[new_language.locale] = new_language
     new_language
   end
 
+  # Returns a list of application supported locales
   def locales
     @locales ||= languages.collect{|lang| lang.locale}
   end
 
+  # Returns tools data
   def tools
     @attributes[:tools] || {}
   end
 
+  # Returns asset url
   def url_for(path)
     "#{tools['assets']}#{path}"
   end
 
-  def source(source, locale)
+  # Returns source by key
+  def source(key, locale)
     self.sources ||= {}
-    self.sources[source] ||= Tml::Source.new(
-      :application => self,
-      :source => source
+    self.sources[key] ||= Tml::Source.new(
+      :application  => self,
+      :source       => key
     ).fetch_translations(locale)
   end
 
-  def component(key, register = true)
-    key = key.key if key.is_a?(Tml::Component)
-
-    return self.components[key] if self.components[key]
-    return nil unless register
-
-    self.components[key] ||= api_client.post('components/register', {:component => key}, {:class => Tml::Component, :attributes => {:application => self}})
+  # Verifies current source path
+  def verify_source_path(source_key, source_path)
+    return if Tml.cache.enabled? and not Tml.session.inline_mode?
+    return if extensions.nil? or extensions['sources'].nil?
+    return unless extensions['sources'][source_key].nil?
+    @missing_keys_by_sources ||= {}
+    @missing_keys_by_sources[source_path] ||= {}
   end
 
   def register_missing_key(source_key, tkey)
     return if Tml.cache.enabled? and not Tml.session.inline_mode?
-
     @missing_keys_by_sources ||= {}
     @missing_keys_by_sources[source_key] ||= {}
     @missing_keys_by_sources[source_key][tkey.key] ||= tkey
@@ -148,7 +198,6 @@ class Tml::Application < Tml::Base
   def register_keys(keys)
     params = []
     keys.each do |source_key, keys|
-      next unless keys.values.any?
       source = Tml::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
@@ -167,21 +216,6 @@ class Tml::Application < Tml::Base
     @missing_keys_by_sources = nil
   end
 
-  def featured_languages
-    @featured_languages ||= begin
-      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('applications/current/translators', {}, {:class => Tml::Translator, :attributes => {:application => self}})
-  rescue
-    []
-  end
-
   def reset_translation_cache
     self.sources = {}
     self.translations = {}
@@ -195,7 +229,7 @@ class Tml::Application < Tml::Base
       results = Tml.cache.fetch(Tml::Application.translations_cache_key(locale)) do
         data = {}
         unless Tml.cache.read_only?
-          api_client.paginate('applications/current/translations', :per_page => 1000) do |translations|
+          api_client.paginate('projects/current/translations', :per_page => 1000) do |translations|
             data.merge!(translations)
           end
         end
@@ -261,11 +295,11 @@ class Tml::Application < Tml::Base
   end
 
   def api_client
-    @api_client ||= Tml::Api::Client.new(:application => self)
+    @api_client ||= Tml::Api::Client.new(application: self)
   end
 
   def postoffice
-    @postoffice ||= Tml::Api::PostOffice.new(:application => self)
+    @postoffice ||= Tml::Api::PostOffice.new(application: self)
   end
 
 end

data/lib/tml/cache.rb

@@ -34,10 +34,6 @@ module Tml
 
   CACHE_VERSION_KEY = 'current_version'
 
-  def self.memory
-    @memory ||= Tml::CacheAdapters::Memory.new
-  end
-
   def self.cache
     @cache ||= begin
       if Tml.config.cache_enabled?
@@ -152,5 +148,21 @@ module Tml
       # do nothing
     end
 
+    def strip_extensions(data)
+      if data.is_a?(Hash)
+        data = data.dup
+        data.delete('extensions')
+        return data
+      end
+
+      if data.is_a?(String) and data.match(/^\{/)
+        data = JSON.parse(data)
+        data.delete('extensions')
+        data = data.to_json
+      end
+
+      data
+    end
+
   end
 end

data/lib/tml/cache_adapters/memcache.rb

@@ -73,7 +73,7 @@ class Tml::CacheAdapters::Memcache < Tml::Cache
   def store(key, data, opts = {})
     info("Cache store: #{key}")
     ttl = opts[:ttl] || Tml.config.cache[:timeout] || 0
-    @cache.set(versioned_key(key, opts), data, ttl)
+    @cache.set(versioned_key(key, opts), strip_extensions(data), ttl)
     data
   rescue Exception => ex
     pp ex

data/lib/tml/cache_adapters/redis.rb

@@ -38,8 +38,8 @@ class Tml::CacheAdapters::Redis < Tml::Cache
   def initialize
     config = Tml.config.cache
 
-    if config.adapter_config
-      @cache = ::Redis.new(config.adapter_config)
+    if config[:adapter_config]
+      @cache = ::Redis.new(config[:adapter_config])
     else
       config[:host] ||= 'localhost'
       config[:port] ||= 6379
@@ -65,7 +65,7 @@ class Tml::CacheAdapters::Redis < Tml::Cache
   def fetch(key, opts = {})
     data = @cache.get(versioned_key(key, opts))
     if data
-      info("Cache hit: #{key} #{data}")
+      info("Cache hit: #{key}")
 
       begin
         return JSON.parse(data)
@@ -95,7 +95,7 @@ class Tml::CacheAdapters::Redis < Tml::Cache
     ttl = opts[:ttl] || Tml.config.cache[:timeout]
     versioned_key = versioned_key(key, opts)
 
-    @cache.set(versioned_key, data.to_json)
+    @cache.set(versioned_key, strip_extensions(data.to_json))
     @cache.expire(versioned_key, ttl) if ttl and ttl > 0
   rescue Exception => ex
     warn("Failed to store data: #{ex.message}")

data/lib/tml/config.rb

@@ -76,7 +76,7 @@ module Tml
   class Config
     # Configuration Attributes
     attr_accessor :enabled, :locale, :default_level, :format, :application, :context_rules, :logger, :cache, :default_tokens, :localization
-    attr_accessor :auto_init
+    attr_accessor :auto_init, :source_separator
 
     # Used by Rails and Sinatra extensions
     attr_accessor :current_locale_method, :current_user_method, :translator_options, :i18n_backend
@@ -91,6 +91,7 @@ module Tml
       @format = :html
       @subdomains = false
       @auto_init = true
+      @source_separator = '@:@'
 
       @locale = {
         default:    'en',

data/lib/tml/decorators/html.rb

@@ -35,12 +35,11 @@ class Tml::Decorators::Html < Tml::Decorators::Base
   def decorate(translated_label, translation_language, target_language, translation_key, options = {})
     #Tml.logger.info("Decorating #{translated_label} of #{translation_language.locale} to #{target_language.locale}")
 
-    # skip decoration if instructed so
-    return translated_label if options[:skip_decorations]
-
     # if translation key language is the same as target language - skip decorations
-    return translated_label if translation_key.language == target_language
-    return translated_label unless inline_mode?
+    if options[:skip_decorations] or not inline_mode? or
+       (translation_key.application.feature_enabled?(:lock_original_content) and translation_key.language == target_language)
+      return translated_label
+    end
 
     classes = %w(tml_translatable)
 
@@ -60,7 +59,8 @@ class Tml::Decorators::Html < Tml::Decorators::Base
       classes << 'tml_fallback'
     end
 
-    element = 'span'
+    element = 'tml:label'
+    element = 'span' if options[:use_span]
     element = 'div' if options[:use_div]
 
     html = "<#{element} class='#{classes.join(' ')}' data-translation_key='#{translation_key.key}' data-target_locale='#{target_language.locale}'>"
@@ -93,7 +93,8 @@ class Tml::Decorators::Html < Tml::Decorators::Base
       attrs << "#{key}=\"#{value.to_s.gsub('"', "\"")}\""
     end
 
-    element = 'span'
+    element = 'tml:label'
+    element = 'span' if options[:use_span]
     element = 'div' if options[:use_div]
 
     html = "<#{element} #{attrs.join(' ')}>"

data/lib/tml/ext/array.rb

@@ -49,7 +49,7 @@ class Array
   end
 
   # translates and joins all elements
-  def translated_and_join(separator = '', description = '', options = {})
+  def translate_and_join(separator = ', ', description = '', options = {})
     self.translate(description, options).join(separator).tml_translated
   end
 

data/lib/tml/generators/base.rb

@@ -81,7 +81,7 @@ class Tml::Generators::Base
   end
 
   def application
-    @application ||= api_client.get('applications/current', {:definition => true})
+    @application ||= api_client.get('projects/current/definition', {})
   end
 
   def languages

data/lib/tml/generators/file.rb

@@ -39,19 +39,20 @@ class Tml::Generators::File < Tml::Generators::Base
 
   def execute
     if cache_version == '0'
-      log("No releases have been generated yet. Please visit your Dashboard and publish translations.")
+      log('No releases have been generated yet. Please visit your Dashboard and publish translations.')
     else
       log("Current cache version: #{cache_version}")
 
       archive_name = "#{cache_version}.tar.gz"
       path = "#{cache_path}/#{archive_name}"
-      url = "#{api_client.cdn_host}/#{Tml.config.access_token}/#{archive_name}"
+      url = "#{api_client.cdn_host}/#{Tml.config.application[:key]}/#{archive_name}"
+
       log("Downloading cache file: #{url}")
       open(path, 'wb') do |file|
         file << open(url).read
       end
-      log('Extracting cache file...')
 
+      log('Extracting cache file...')
       version_path = "#{cache_path}/#{cache_version}"
       untar(ungzip(File.new(path)), version_path)
       log("Cache has been stored in #{version_path}")

data/lib/tml/language.rb

@@ -35,17 +35,26 @@ class Tml::Language < Tml::Base
   attributes  :locale, :name, :english_name, :native_name, :right_to_left, :flag_url
   has_many    :contexts, :cases
 
+  # Returns language cache key
   def self.cache_key(locale)
     File.join(locale, 'language')
   end
 
+  # Loads language definition from the service
   def fetch
-    update_attributes(application.api_client.get("language/#{locale}", {}, {:cache_key => self.class.cache_key(locale)}))
+    update_attributes(application.api_client.get(
+      "language/#{locale}/definition",
+      {},
+      {
+          cache_key: self.class.cache_key(locale)
+      }
+    ))
   rescue Tml::Exception => ex
     Tml.logger.error("Failed to load language: #{ex}")
     self
   end
 
+
   def update_attributes(attrs)
     super
 
@@ -114,9 +123,9 @@ class Tml::Language < Tml::Base
   # There are three ways to call the tr method
   #
   # tr(label, description = "", tokens = {}, options = {})
-  # or
+  #   or
   # tr(label, tokens = {}, options = {})
-  # or
+  #   or
   # tr(:label => label, :description => "", :tokens => {}, :options => {})
   ########################################################################################################
 
@@ -133,12 +142,12 @@ class Tml::Language < Tml::Base
       :translations => []
     })
 
-    #Tml.logger.info("Translating " + params[:label] + " from: " + translation_key.locale.inspect + " to " + locale.inspect)
+    # Tml.logger.info("Translating " + params[:label] + " from: " + translation_key.locale.inspect + " to " + locale.inspect)
 
     params[:tokens] ||= {}
     params[:tokens][:viewing_user] ||= Tml.session.current_user
 
-    if Tml.config.disabled? or self.locale == translation_key.locale or application.nil?
+    if Tml.config.disabled? or application.nil?
       return translation_key.substitute_tokens(
         params[:label],
         params[:tokens],
@@ -153,11 +162,17 @@ class Tml::Language < Tml::Base
       return translation_key.translate(self, params[:tokens], params[:options]).tml_translated
     end
 
-    if options[:dynamic] or Tml.session.block_options[:dynamic]
+    source_key = current_source(options)
+    current_source_path = source_path
 
+    # Dynamic sources are never registered under the parent source
+    if hash_value(Tml.session.block_options, :dynamic)
+      current_source_path = source_key
+    else
+      application.verify_source_path(source_key, current_source_path)
     end
 
-    source_key = current_source(options)
+    # Tml.logger.debug("#{params[:label]}, #{source_key}")
 
     source = application.source(source_key, locale)
     cached_translations = source.cached_translations(locale, translation_key.key)
@@ -167,11 +182,25 @@ class Tml::Language < Tml::Base
     else
       params[:options] ||= {}
       params[:options][:pending] = true
-      application.register_missing_key(source_key, translation_key)
+      application.register_missing_key(current_source_path, translation_key)
     end
 
     translation_key.translate(self, params[:tokens], params[:options]).tml_translated
   end
   alias :tr :translate
 
+  def source_path
+    sp = []
+
+    Tml.session.block_options_queue.each do |opts|
+      next unless hash_value(opts, :source)
+      sp << hash_value(opts, :source)
+    end
+
+    sp = sp.reverse
+    sp.unshift(Tml.session.current_source)
+
+    sp.join(Tml.config.source_separator)
+  end
+
 end

data/lib/tml/session.rb

@@ -37,12 +37,8 @@ module Tml
   end
 
   class Session
-    attr_accessor :application, :current_user, :current_locale, :current_language, :current_translator,
-                  :current_source, :current_component, :block_options, :cookie_params, :access_token, :tools_enabled
-
-    def cookie_name
-      "trex_#{Tml.config.access_token[0..19]}_translationexchange"
-    end
+    attr_accessor :application, :block_options
+    attr_accessor :current_user, :current_locale, :current_language, :current_translator, :current_source
 
     def init(opts = {})
       return unless Tml.config.enabled? and Tml.config.application
@@ -51,53 +47,35 @@ module Tml
 
       Tml.cache.reset_version
 
-      self.cookie_params = begin
-        if opts[:cookies] and opts[:cookies][cookie_name]
-          begin
-            params = HashWithIndifferentAccess.new(Tml::Utils.decode(opts[:cookies][cookie_name]))
-            params[:locale] = opts[:locale] if opts[:change_locale]
-            params
-          rescue Exception => ex
-            Tml.logger.error("Failed to parse tml cookie: #{ex.message}")
-            {}
-          end
-        else
-          {}
-        end
-      end
-
-      # Tml.logger.info(self.cookie_params.inspect)
-
-      self.tools_enabled = opts[:tools_enabled]
       self.current_user = opts[:user]
       self.current_source = opts[:source] || 'index'
-      self.current_component = opts[:component]
-      self.current_locale = self.cookie_params[:locale] || opts[:locale] || Tml.config.default_locale
-
-      if self.cookie_params['translator']
-        self.current_translator = Tml::Translator.new(self.cookie_params['translator'])
-      end
+      self.current_locale = opts[:locale]
+      self.current_translator = opts[:translator]
 
       self.application = Tml::Application.new(:host => host).fetch
 
       # if inline mode don't use any app cache
-      if inline_mode?
-        self.application = self.application.dup
-        self.application.reset_translation_cache
-      end
+      # if inline_mode?
+      #   self.application = self.application.dup
+      #   self.application.reset_translation_cache
+      # end
 
       if self.current_translator
         self.current_translator.application = self.application
       end
 
+      self.current_locale = preferred_locale(opts[:locale])
       self.current_language = self.application.current_language(self.current_locale)
-      self.current_locale = self.current_language.locale
 
       self
     end
 
-    def tools_enabled?
-      self.tools_enabled
+    def preferred_locale(locales)
+      locales = locales.is_a?(String) ? locales.split(',') : locales
+      locales.each do |locale|
+        return locale if application.locales.include?(locale)
+      end
+      application.default_locale
     end
 
     def reset
@@ -106,8 +84,6 @@ module Tml
       self.current_language= nil
       self.current_translator= nil
       self.current_source= nil
-      self.current_component= nil
-      self.tools_enabled= nil
       self.block_options= nil
     end
 
@@ -177,13 +153,5 @@ module Tml
       nil
     end
 
-    def current_component_from_block_options
-      arr = @block_options || []
-      arr.reverse.each do |opts|
-        return application.component_by_key(opts[:component]) unless opts[:component].blank?
-      end
-      Tml.config.current_component
-    end
-
   end
 end

data/lib/tml/source.rb

@@ -64,11 +64,28 @@ class Tml::Source < Tml::Base
     self.key ||= Tml::Source.generate_key(attrs[:source])
   end
 
+  def update_translations(locale, results)
+    self.translations ||= {}
+    self.translations[locale] = {}
+
+    results.each do |key, data|
+      translations_data = data.is_a?(Hash) ? data['translations'] : data
+      self.translations[locale][key] = translations_data.collect do |t|
+        Tml::Translation.new(
+          locale:   t['locale'] || locale,
+          label:    t['label'],
+          locked:   t['locked'],
+          context:  t['context']
+        )
+      end
+    end
+  end
+
   def fetch_translations(locale)
     self.translations ||= {}
     return self if self.translations[locale]
 
-    self.translations[locale] = {}
+    # Tml.logger.debug("Fetching #{source}")
 
     results = self.application.api_client.get(
       "sources/#{self.key}/translations",
@@ -78,17 +95,7 @@ class Tml::Source < Tml::Base
 
     return self unless results
 
-    results.each do |key, data|
-      translations_data = data.is_a?(Hash) ? data['translations'] : data
-      self.translations[locale][key] = translations_data.collect do |t|
-        Tml::Translation.new(
-          :locale => t['locale'] || locale,
-          :label => t['label'],
-          :locked => t['locked'],
-          :context => t['context']
-        )
-      end
-    end
+    update_translations(locale, results)
 
     self
   rescue Tml::Exception => ex

data/lib/tml/tokenizers/decoration.rb

@@ -182,7 +182,6 @@ module Tml
             return method.to_s.gsub('{$0}', value)
           end
 
-          Tml.logger.error("Invalid decoration token value for #{token} in #{text}")
           return value
         end
 
@@ -190,7 +189,6 @@ module Tml
           return default_decoration(token, value)
         end
 
-        Tml.logger.error("Missing decoration token value for #{token} in #{text}")
         value
       end
 

data/lib/tml/tokens/data.rb

@@ -55,7 +55,7 @@ module Tml
       end
 
       def parse_elements
-        name_without_parens = @full_name[1..-2]
+        name_without_parens = @full_name.gsub(/^%/, '')[1..-2]
         name_without_case_keys = name_without_parens.split('::').first.strip
 
         @short_name = name_without_parens.split(':').first.strip
@@ -333,7 +333,7 @@ module Tml
 
         unless Tml.session.block_options[:skip_html_escaping]
           if options[:safe] == false
-            value = ERB::Util.html_escape(value)
+            value = CGI.escapeHTML(value)
           end
         end
 

data/lib/tml/tokens/method.rb

@@ -54,7 +54,7 @@ class Tml::Tokens::Method < Tml::Tokens::Data
 
   def substitute(label, context, language, options = {})
     object = Tml::Utils.hash_value(context, object_name)
-    raise Tml::Exception.new("Missing value for a token: #{full_name}") unless object
+    return label unless object
     object_value = sanitize(object.send(object_method_name), object, language, options.merge(:safe => false))
     label.gsub(full_name, object_value)
   end

data/lib/tml/tokens/transform.rb

@@ -61,7 +61,7 @@ class Tml::Tokens::Transform < Tml::Tokens::Data
   end
 
   def parse_elements
-    name_without_parens = @full_name[1..-2]
+    name_without_parens = @full_name.gsub(/^%/, '')[1..-2]
     name_without_pipes = name_without_parens.split('|').first.strip
     name_without_case_keys = name_without_pipes.split('::').first.strip
 
@@ -69,7 +69,7 @@ class Tml::Tokens::Transform < Tml::Tokens::Data
     @case_keys = name_without_pipes.scan(/(::\w+)/).flatten.uniq.collect{|c| c.gsub('::', '')}
     @context_keys = name_without_case_keys.scan(/(:\w+)/).flatten.uniq.collect{|c| c.gsub(':', '')}
 
-    @pipe_separator = (full_name.index("||") ? "||" : "|")
+    @pipe_separator = (full_name.index('||') ? '||' : '|')
     @piped_params = name_without_parens.split(pipe_separator).last.split(",").collect{|param| param.strip}
   end
 

data/lib/tml/translation_key.rb

@@ -110,7 +110,7 @@ class Tml::TranslationKey < Tml::Base
   end
 
   def translate(language, token_values = {}, options = {})
-    if Tml.config.disabled? or language.locale == self.locale
+    if Tml.config.disabled?
       return substitute_tokens(label, token_values, language, options.merge(:fallback => false))
     end
 

data/lib/tml/utils.rb

@@ -62,19 +62,12 @@ module Tml
       (0..16).to_a.map{|a| rand(16).to_s(16)}.join
     end
 
-    def self.hash_value(hash, key)
-      hash[key.to_s] || hash[key.to_sym]
+    def self.cookie_name(app_key)
+      "trex_#{app_key}"
     end
 
-    def self.split_by_sentence(text)
-      sentence_regex = /[^.!?\s][^.!?]*(?:[.!?](?![\'"]?\s|$)[^.!?]*)*[.!?]?[\'"]?(?=\s|$)/
-
-      sentences = []
-      text.scan(sentence_regex).each do |s|
-        sentences << s
-      end
-
-      sentences
+    def self.hash_value(hash, key)
+      hash[key.to_s] || hash[key.to_sym]
     end
 
     def self.load_json(file_path, env = nil)
@@ -91,36 +84,47 @@ module Tml
       yaml['defaults'].rmerge(yaml[env] || {})
     end
 
-    def self.decode(data)
+    def self.decode(data, secret = nil)
       payload = URI::decode(data)
       payload = Base64.decode64(payload)
-      JSON.parse(payload)
+      data = JSON.parse(payload)
+
+      # TODO: Verify signature
+
+      data
     rescue Exception => ex
       {}
     end
 
-    def self.encode(params)
+    def self.encode(params, secret = nil)
+
+      # TODO: Add signature
+
       payload = Base64.encode64(params.to_json)
       URI::encode(payload)
     rescue Exception => ex
       ''
     end
 
-    def self.split_sentences(paragraph)
+    def self.split_sentences(text)
       sentence_regex = /[^.!?\s][^.!?]*(?:[.!?](?![\'"]?\s|$)[^.!?]*)*[.!?]?[\'"]?(?=\s|$)/
-      paragraph.match(sentence_regex)
+
+      sentences = []
+      text.scan(sentence_regex).each do |s|
+        sentences << s
+      end
+
+      sentences
     end
 
-    ######################################################################
-    # Author: Iain Hecker
-    # reference: http://github.com/iain/http_accept_language
-    ######################################################################
-    def self.browser_accepted_locales(request)
-      request.env['HTTP_ACCEPT_LANGUAGE'].split(/\s*,\s*/).collect do |l|
+    def self.browser_accepted_locales(header)
+      header.split(/\s*,\s*/).collect do |l|
         l += ';q=1.0' unless l =~ /;q=\d+\.\d+$/
         l.split(';q=')
       end.sort do |x,y|
-        raise Tml::Exception.new('Not correctly formatted') unless x.first =~ /^[a-z\-]+$/i
+        unless x.first =~ /^[a-z\-]+$/i
+          raise Tml::Exception.new('Not correctly formatted')
+        end
         y.last.to_f <=> x.last.to_f
       end.collect do |l|
         l.first.downcase.gsub(/-[a-z]+$/i) { |x| x.upcase }

data/lib/tml/version.rb

@@ -30,5 +30,5 @@
 #++
 
 module Tml
-  VERSION = '4.4.7'
+  VERSION = '5.0.1'
 end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: tml
 version: !ruby/object:Gem::Version
-  version: 4.4.7
+  version: 5.0.1
 platform: ruby
 authors:
 - Michael Berkovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-23 00:00:00.000000000 Z
+date: 2015-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 description: Tml core classes that can be used by any Ruby framework
@@ -102,17 +102,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Tml Core Classes