tml 4.3.12 → 4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eedcd1e0845ace035f6e6b15b8a91e6376f78a8f
-  data.tar.gz: 9f20b2e4fb6022af375b506f0d829289916533c9
+  metadata.gz: 219ec288ae06a6e1f41055d5a43911f912a9a60b
+  data.tar.gz: af5bb4eb638a821d605611fe3dfdb0eb3bfd1ef1
 SHA512:
-  metadata.gz: b1e8412ce5d6beeadbbaf8ed073352cca9d55f437280c4c13b5e17a8d8a93d7c92da25ee6336bc8295f29ce25a09b5157917a6b9d5143efefd811b397aba17ba
-  data.tar.gz: 06642e956d2dddbeff5cbc2a9d5e2bc8e4118e96e7667a20f3295da84ebfc612c0ca56e8645ca9c1009e2af65d91061068a2a9c9e91d7e4c4e08938d519bbdc3
+  metadata.gz: 284ba13aed6ef6aff3a8b016edf77d8e9e844e587fd80e4d8029e8fe2904552f7c5d75b91e31ea7173ab0bdcae24f8ffc6f3e19396d632322f566e120b5e3b85
+  data.tar.gz: a53fe934ba88ef001c8ab23c8f8ac14344397f5240d0ffb330bf5ac8d6967a02943c97505bea742ca0ea3d7b6a8bd023863eb29a40639b8e44d41e4f9d2c2656

data/lib/tml/api/client.rb

@@ -33,15 +33,13 @@
 require 'faraday'
 
 class Tml::Api::Client < Tml::Base
+  CDN_HOST = 'https://cdn.translationexchange.com'
   API_HOST = 'https://api.translationexchange.com'
   API_PATH = '/v1'
 
   attributes :application
 
-  def access_token
-    Tml.config.application[:token] || Tml.config.application[:access_token]
-  end
-
+  # get results from api
   def results(path, params = {}, opts = {})
     get(path, params, opts)['results']
   end
@@ -78,14 +76,61 @@ class Tml::Api::Client < Tml::Base
     end
   end
 
-  def api(path, params = {}, opts = {})
-    if Tml.session.inline_mode?
-      return process_response(execute_request(path, params, opts), opts)
+  def verify_cache_version
+    return if Tml.cache.version and Tml.cache.version != 'undefined'
+
+    current_version = Tml.cache.fetch_version
+    if current_version == 'undefined'
+      Tml.cache.store_version(execute_request('applications/current/version', {}, {:raw => true}))
+    else
+      Tml.cache.version = current_version
+    end
+    Tml.logger.info("Version: #{Tml.cache.version}")
+  end
+
+  def cdn_connection
+    @cdn_connection ||= Faraday.new(:url => CDN_HOST) do |faraday|
+      faraday.request(:url_encoded)               # form-encode POST params
+      faraday.adapter(Faraday.default_adapter)    # make requests with Net::HTTP
+    end
+  end
+
+  def get_from_cdn(key, params = {}, opts = {})
+    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
+      begin
+        response = cdn_connection.get(cdn_path, params)
+      rescue Exception => ex
+        Tml.logger.error("Failed to execute request: #{ex.message[0..255]}")
+        return nil
+      end
     end
+    return if response.status >= 500 and response.status < 600
+    return if response.body.nil? or response.body == '' or response.body.match(/xml/)
 
-    if opts[:method] == :get and opts[:cache_key]
+    begin
+      data = JSON.parse(response.body)
+    rescue Exception => ex
+      return nil
+    end
+
+    data
+  end
+
+  def api(path, params = {}, opts = {})
+    # inline mode should always bypass API calls
+    # get request uses local cache, then CDN, the API
+    if opts[:method] == :get and opts[:cache_key] and Tml.cache.enabled? and not Tml.session.inline_mode?
+      verify_cache_version
       data = Tml.cache.fetch(opts[:cache_key]) do
-        Tml.cache.read_only? ? nil : execute_request(path, params, opts)
+        if Tml.cache.read_only?
+          nil
+        else
+          get_from_cdn(opts[:cache_key]) || execute_request(path, params, opts)
+        end
       end
       process_response(data, opts)
     else
@@ -125,7 +170,7 @@ class Tml::Api::Client < Tml::Base
 
     # oauth path is separate from versioned APIs
     path = prepare_api_path(path)
-    params = params.merge(:access_token => access_token) unless path.index('oauth')
+    params = params.merge(:access_token => Tml.config.access_token) unless path.index('oauth')
 
     if opts[:method] == :post
       params = params.merge(:api_key => application.key)
@@ -155,6 +200,7 @@ class Tml::Api::Client < Tml::Base
     end
 
     return if response.body.nil? or response.body == ''
+    return response.body if opts[:raw]
 
     begin
       data = JSON.parse(response.body)
@@ -206,7 +252,7 @@ class Tml::Api::Client < Tml::Base
     #end
 
     if opts[:method] == :post
-      Tml.logger.debug("post: [#{path}] #{params.inspect}")
+      Tml.logger.debug("post: [#{path}]")
     else
       Tml.logger.debug("get: #{path}?#{to_query(params)}")
     end

data/lib/tml/application.rb

@@ -137,7 +137,7 @@ class Tml::Application < Tml::Base
   end
 
   def register_missing_key(source_key, tkey)
-    return if Tml.cache.read_only? and not Tml.session.inline_mode?
+    return if Tml.cache.enabled? and not Tml.session.inline_mode?
 
     @missing_keys_by_sources ||= {}
     @missing_keys_by_sources[source_key] ||= {}

data/lib/tml/cache.rb

@@ -32,7 +32,7 @@
 
 module Tml
 
-  CACHE_VERSION_KEY = '__tml_version__'
+  CACHE_VERSION_KEY = 'current_version'
 
   def self.memory
     @memory ||= Tml::CacheAdapters::Memory.new
@@ -52,92 +52,105 @@ module Tml
 
   class Cache
 
+    # Returns current cache version
     def version
-      Tml.config.cache[:version] ||= 1
-
-      @version ||= begin
-        v = fetch(CACHE_VERSION_KEY) do
-          {'version' => Tml.config.cache[:version]}
-        end
-        v['version']
-      end
-
-      @version ||= Tml.config.cache[:version]
-
-      if Tml.config.cache[:version] > @version
-        update_version(Tml.config.cache[:version])
-        @version = Tml.config.cache[:version]
-      end
-
       @version
     end
 
-    def update_version(new_version)
-      store(CACHE_VERSION_KEY, {'version' => new_version}, :ttl => 0)
+    # sets the current version
+    def version=(new_version)
+      @version = new_version
     end
 
-    def upgrade_version
-      update_version((version || Tml.config.cache[:version] || 0).to_i + 1)
+    # resets current version
+    def reset_version
       @version = nil
     end
 
-    def reset_version
-      @version = nil
+    # upgrade current version
+    def upgrade_version
+      store(CACHE_VERSION_KEY, {'version' => 'undefined'})
+      reset_version
     end
 
-    def enabled?
-      Tml.config.cache[:enabled]
+    # fetches the version from the cache
+    def fetch_version
+      @version ||= begin
+        v = fetch(CACHE_VERSION_KEY) do
+          {'version' => Tml.config.cache[:version] || 'undefined'}
+        end
+        v.is_a?(Hash) ? v['version'] : v
+      end
     end
 
-    def cached_by_source?
-      true
+    # stores the current version back in cache
+    def store_version(new_version)
+      @version = new_version
+      store(CACHE_VERSION_KEY, {'version' => new_version})
     end
 
-    def read_only?
-      false
+    # checks if Tml is enabled
+    def enabled?
+      Tml.config.cache_enabled?
     end
 
-    def segmented?
-      true
+    # by default all cache is read/write
+    # cache like files based should be set to read only
+    def read_only?
+      false
     end
 
+    # name of the cache adapter
     def cache_name
       self.class.name.split('::').last
     end
 
+    # logs information messages
     def info(msg)
       Tml.logger.info("#{cache_name} - #{msg}")
     end
 
+    # logs a warning
     def warn(msg)
       Tml.logger.warn("#{cache_name} - #{msg}")
     end
 
+    # namespace of each cache key
+    def namespace
+      return '#' if Tml.config.disabled?
+      Tml.config.cache[:namespace] || Tml.config.access_token[0..5]
+    end
+
+    # versioned name of cache key
     def versioned_key(key, opts = {})
-      return key if CACHE_VERSION_KEY == key
-      "tml_rc_v#{version}_#{key}"
+      "tml_#{namespace}#{CACHE_VERSION_KEY == key ? '' : "_v#{version}"}_#{key}"
     end
 
+    # fetches key from cache
     def fetch(key, opts = {})
       return nil unless block_given?
       yield
     end
 
+    # stores key in cache
     def store(key, data, opts = {})
       # do nothing
     end
 
+    # deletes key from cache
     def delete(key, opts = {})
       # do nothing
     end
 
+    # checks if the key exists
     def exist?(key, opts = {})
       false
     end
 
+    # clears cache
     def clear(opts = {})
       # do nothing
     end
 
   end
-end
+end

data/lib/tml/cache_adapters/file.rb

@@ -48,11 +48,6 @@ class Tml::CacheAdapters::File < Tml::Cache
     'file'
   end
 
-  def segmented?
-    return true if Tml.config.cache[:segmented].nil?
-    Tml.config.cache[:segmented]
-  end
-
   def fetch(key, opts = {})
     if self.class.cache[key]
       info("Memory hit: #{key}")

data/lib/tml/cache_adapters/memcache.rb

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

data/lib/tml/cache_adapters/redis.rb

@@ -61,7 +61,7 @@ class Tml::CacheAdapters::Redis < Tml::Cache
   def fetch(key, opts = {})
     data = @cache.get(versioned_key(key, opts))
     if data
-      info("Cache hit: #{key}")
+      info("Cache hit: #{key} #{data}")
 
       begin
         return JSON.parse(data)

data/lib/tml/config.rb

@@ -78,7 +78,7 @@ module Tml
     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, :translator_options
+    attr_accessor :current_locale_method, :current_user_method, :translator_options, :i18n_backend
 
     # Used for IRB only
     attr_accessor :submit_missing_keys_realtime
@@ -166,11 +166,7 @@ module Tml
       }
 
       @cache = {
-        :enabled  => false,
-        :host     => 'localhost:11211',
-        :adapter  => 'memcache',
-        :version  => 1,
-        :timeout  => 3600
+        :enabled  => false
       }
 
       @default_tokens = {
@@ -343,6 +339,10 @@ module Tml
       @default_application ||= Tml::Application.new(:host => Tml::Api::Client::API_HOST)
     end
 
+    def access_token
+      @application[:token] || @application[:access_token] || ''
+    end
+
     #########################################################
     ## Decorations
     #########################################################

data/lib/tml/decorators/html.rb

@@ -50,7 +50,11 @@ class Tml::Decorators::Html < Tml::Decorators::Base
       # return translated_label unless Tml.session.current_translator.feature_enabled?(:show_locked_keys)
       classes << 'tml_locked'
     elsif translation_language == translation_key.language
-      classes << 'tml_not_translated'
+      if options[:pending]
+        classes << 'tml_pending'
+      else
+        classes << 'tml_not_translated'
+      end
     elsif translation_language == target_language
       classes << 'tml_translated'
     else

data/lib/tml/language.rb

@@ -155,16 +155,14 @@ class Tml::Language < Tml::Base
 
     source_key = current_source(options)
 
-    if Tml.cache.segmented? or Tml.session.inline_mode?
-      source = application.source(source_key, locale)
-      cached_translations = source.cached_translations(locale, translation_key.key)
-    else
-      cached_translations = application.fetch_translations(locale)[translation_key.key]
-    end
+    source = application.source(source_key, locale)
+    cached_translations = source.cached_translations(locale, translation_key.key)
 
     if cached_translations
       translation_key.set_translations(locale, cached_translations)
     else
+      params[:options] ||= {}
+      params[:options][:pending] = true
       application.register_missing_key(source_key, translation_key)
     end
 

data/lib/tml/logger.rb

@@ -58,50 +58,44 @@ module Tml
   class Logger < ::Logger
     attr_accessor :external_logger
 
-    def info(message)
-      if external_logger
-        return external_logger.info(format_message(Logger::Severity::INFO, Time.new, nil, message))
-      end
+    def log_to_console(msg)
+      return unless Tml.config.logger[:console]
+      puts msg
+    end
 
+    def info(message)
+      log_to_console(message)
+      return external_logger.info(format_message(Logger::Severity::INFO, Time.new, nil, message)) if external_logger
       super
     end
 
     def debug(message)
-      if external_logger
-        return external_logger.debug(format_message(Logger::Severity::DEBUG, Time.new, nil, message))
-      end
-
+      log_to_console(message)
+      return external_logger.debug(format_message(Logger::Severity::DEBUG, Time.new, nil, message)) if external_logger
       super
     end
 
     def warn(message)
-      if external_logger
-        return external_logger.warn(format_message(Logger::Severity::WARN, Time.new, nil, message))
-      end
-
+      log_to_console(message)
+      return external_logger.warn(format_message(Logger::Severity::WARN, Time.new, nil, message)) if external_logger
       super
     end
 
     def error(message)
-      if external_logger
-        return external_logger.error(format_message(Logger::Severity::ERROR, Time.new, nil, message))
-      end
-
+      log_to_console(message)
+      return external_logger.error(format_message(Logger::Severity::ERROR, Time.new, nil, message)) if external_logger
       super
     end
 
     def fatal(message)
-      if external_logger
-        return external_logger.fatal(format_message(Logger::Severity::FATAL, Time.new, nil, message))
-      end
-
+      log_to_console(message)
+      return external_logger.fatal(format_message(Logger::Severity::FATAL, Time.new, nil, message)) if external_logger
       super
     end
 
     def format_message(severity, timestamp, progname, msg)
-      return "" unless Tml.config.logger[:enabled]
-      # TODO: check for severity/level
-      "[#{timestamp.strftime("%D %T")}]: tml: #{' ' * stack.size}#{msg}\n"
+      return '' unless Tml.config.logger[:enabled]
+      "[#{timestamp.strftime('%D %T')}]: tml: #{' ' * stack.size}#{msg}\n"
     end
 
     def add(severity, message = nil, progname = nil, &block)

data/lib/tml/session.rb

@@ -41,7 +41,7 @@ module Tml
                   :current_source, :current_component, :block_options, :cookie_params, :access_token, :tools_enabled
 
     def cookie_name
-      "trex_#{self.application.key}"
+      "trex_#{Tml.config.access_token[0..19]}_translationexchange"
     end
 
     def init(opts = {})
@@ -51,10 +51,6 @@ module Tml
 
       Tml.cache.reset_version
 
-      self.application = Tml::Application.new(:host => host).fetch
-
-      # Tml.logger.info(self.cookie_params.inspect)
-
       self.cookie_params = begin
         if opts[:cookies] and opts[:cookies][cookie_name]
           begin
@@ -70,6 +66,8 @@ module Tml
         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'
@@ -80,6 +78,8 @@ module Tml
         self.current_translator = Tml::Translator.new(self.cookie_params['translator'])
       end
 
+      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

data/lib/tml/source.rb

@@ -76,6 +76,8 @@ class Tml::Source < Tml::Base
       {:cache_key => Tml::Source.cache_key(locale, self.source)}
     )
 
+    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|

data/lib/tml/version.rb

@@ -30,5 +30,5 @@
 #++
 
 module Tml
-  VERSION = '4.3.12'
+  VERSION = '4.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tml
 version: !ruby/object:Gem::Version
-  version: 4.3.12
+  version: 4.4.1
 platform: ruby
 authors:
 - Michael Berkovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -54,7 +54,6 @@ files:
 - lib/tml/application.rb
 - lib/tml/base.rb
 - lib/tml/cache.rb
-- lib/tml/cache_adapters/cdn.rb
 - lib/tml/cache_adapters/file.rb
 - lib/tml/cache_adapters/memcache.rb
 - lib/tml/cache_adapters/redis.rb

data/lib/tml/cache_adapters/cdn.rb

@@ -1,101 +0,0 @@
-# encoding: UTF-8
-#--
-# Copyright (c) 2015 Translation Exchange, Inc
-#
-#  _______                  _       _   _             ______          _
-# |__   __|                | |     | | (_)           |  ____|        | |
-#    | |_ __ __ _ _ __  ___| | __ _| |_ _  ___  _ __ | |__  __  _____| |__   __ _ _ __   __ _  ___
-#    | | '__/ _` | '_ \/ __| |/ _` | __| |/ _ \| '_ \|  __| \ \/ / __| '_ \ / _` | '_ \ / _` |/ _ \
-#    | | | | (_| | | | \__ \ | (_| | |_| | (_) | | | | |____ >  < (__| | | | (_| | | | | (_| |  __/
-#    |_|_|  \__,_|_| |_|___/_|\__,_|\__|_|\___/|_| |_|______/_/\_\___|_| |_|\__,_|_| |_|\__, |\___|
-#                                                                                        __/ |
-#                                                                                       |___/
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-
-class Tml::CacheAdapters::Cdn < Tml::Cache
-
-  def self.cache
-    @cache ||= {}
-  end
-
-  def self.cache_path
-    "#{Tml.config.cache[:base_url]}/#{Tml.config.cache[:version]}"
-  end
-
-  def self.cdn_path(key)
-    File.join(cache_path, "#{key}.json")
-  end
-
-  def cache_name
-    'cdn'
-  end
-
-  def segmented?
-    return true if Tml.config.cache[:segmented].nil?
-    Tml.config.cache[:segmented]
-  end
-
-  def fetch(key, opts = {})
-    if self.class.cache[key]
-      info("Memory hit: #{key}")
-      return self.class.cache[key]
-    end
-
-    path = self.class.cdn_path(key)
-
-
-    # load data from cdn
-
-
-    if File.exists?(path)
-      info("Cache hit: #{key}")
-      self.class.cache[key] = JSON.parse(File.read(path))
-      return self.class.cache[key]
-    end
-
-    info("Cache miss: #{key}")
-
-    return nil unless block_given?
-
-    yield
-  end
-
-  def store(key, data, opts = {})
-    warn('This is a readonly cache')
-  end
-
-  def delete(key, opts = {})
-    warn('This is a readonly cache')
-  end
-
-  def exist?(key, opts = {})
-    File.exists?(self.class.file_path(key))
-  end
-
-  def clear(opts = {})
-    warn('This is a readonly cache')
-  end
-
-  def read_only?
-    true
-  end
-
-end