lit 1.0 → 1.1.2

data/lib/lit/adapters/hash_storage.rb

@@ -2,11 +2,45 @@ module Lit
   class HashStorage < Hash
     def incr(key)
       self[key] ||= 0
-      self[key] += 1
+      if self[key].is_a?(Integer)
+        self[key] += 1
+      else
+        subtree_keys(key).each { |k| self[k] += 1 }
+      end
     end
 
     def prefix
       nil
     end
+
+    def [](key)
+      super || subtree_of_key(key)
+    end
+
+    private
+
+    def subtree_of_key(key)
+      keys_of_subtree = subtree_keys(key)
+      return nil if keys_of_subtree.empty?
+
+      cache_localizations = form_cache_localizations(keys_of_subtree)
+
+      full_subtree = Lit::LocalizationKeysToHashService.call(cache_localizations)
+      requested_part = full_subtree.dig(*key.split('.'))
+      return nil if requested_part.blank?
+      return requested_part if requested_part.is_a?(String)
+
+      requested_part.deep_transform_keys(&:to_sym)
+    end
+
+    def subtree_keys(key)
+      keys.select { |k| k.match?(/\A#{key}*/) }
+    end
+
+    def form_cache_localizations(keys_of_subtree)
+      self_copy = self.select { |k, _| k.in?(keys_of_subtree) }
+      values_of_subtree = keys_of_subtree.map { |k| self_copy[k] }
+      Hash[keys_of_subtree.zip(values_of_subtree)]
+    end
   end
 end

data/lib/lit/adapters/redis_storage.rb

@@ -1,4 +1,6 @@
 require 'redis'
+require 'lit/services/localization_keys_to_hash_service'
+
 module Lit
   extend self
   def redis
@@ -16,13 +18,25 @@ module Lit
       Lit.redis
     end
 
+    # This handles a change in the redis-rb gem that changes exists => exists?
+    def exists?(key)
+      # Use recommended binary-returning method create [with this redis-rb commit](https://github.com/redis/redis-rb/commit/bf42fc9e0db4a1719d9b1ecc65aeb20425d44427).
+      return Lit.redis.exists?(key) if Lit.redis.respond_to?(:exists?)
+
+      # Fall back with older gem
+      Lit.redis.exists(key)
+    end
+
     def [](key)
-      if Lit.redis.exists(_prefixed_key_for_array(key))
+      if exists?(_prefixed_key_for_array(key))
         Lit.redis.lrange(_prefixed_key(key), 0, -1)
-      elsif Lit.redis.exists(_prefixed_key_for_nil(key))
+      elsif exists?(_prefixed_key_for_nil(key))
         nil
       else
-        Lit.redis.get(_prefixed_key(key))
+        val = Lit.redis.get(_prefixed_key(key))
+        return val if val.present?
+
+        subtree_of_key(key)
       end
     end
 
@@ -56,7 +70,7 @@ module Lit
     end
 
     def has_key?(key)
-      Lit.redis.exists(_prefixed_key(key))
+      exists?(_prefixed_key(key))
     end
     alias key? has_key?
 
@@ -77,11 +91,13 @@ module Lit
     private
 
     def _prefix
-      prefix = 'lit:'
+      return @prefix_cached if @prefix_cached.present?
+
+      @prefix_cached = 'lit:'
       if Lit.storage_options.is_a?(Hash) && Lit.storage_options.key?(:prefix)
-        prefix += "#{Lit.storage_options[:prefix]}:"
+        @prefix_cached += "#{Lit.storage_options[:prefix]}:"
       end
-      prefix
+      @prefix_cached
     end
 
     def _prefixed_key(key = '')
@@ -95,5 +111,24 @@ module Lit
     def _prefixed_key_for_nil(key = '')
       _prefix + 'nil_flags:' + key.to_s
     end
+
+    def subtree_of_key(key)
+      keys_of_subtree = Lit.redis.keys("#{_prefixed_key(key)}*")
+      return nil if keys_of_subtree.empty?
+
+      values_of_subtree = Lit.redis.mget(keys_of_subtree)
+      cache_localizations = form_cache_localizations(keys_of_subtree, values_of_subtree)
+
+      full_subtree = Lit::LocalizationKeysToHashService.call(cache_localizations)
+      requested_part = full_subtree.dig(*key.split('.'))
+      return nil if requested_part.blank?
+      return requested_part if requested_part.is_a?(String)
+
+      requested_part.deep_transform_keys(&:to_sym)
+    end
+
+    def form_cache_localizations(keys, values)
+      Hash[keys.map { |k| k.sub(_prefix, '') }.zip(values)]
+    end
   end
 end

data/lib/lit/cache.rb

@@ -18,22 +18,39 @@ end
 
 module Lit
   class Cache
+    @@last_update = nil
+    @@localization_cache = {}
+
     def initialize
       @hits_counter = Lit.get_key_value_engine
       @request_info_store = Lit.get_key_value_engine
-      @hits_counter_working = true
+      @hits_counter_working = Lit.hits_counter_enabled
       @keys = nil
+
+      # current instance cache
       @localization_object_cache = {}
       @localization_key_object_cache = {}
+      clear_localization_cache
     end
 
     def [](key)
-      key_without_locale = split_key(key).last
-      update_hits_count(key)
-      store_request_info(key_without_locale)
-      localization = localizations[key]
-      update_request_keys(key_without_locale, localization)
-      localization
+      value = nil
+      check_and_clean_if_required
+      unless localization_cache.key?(key)
+        value = localizations[key]
+        localization_cache[key] = value
+      else
+        value = localization_cache[key]
+      end
+      update_hits_count(key) if @hits_counter_working
+
+      if Lit.store_request_info ||
+         Lit.store_request_keys
+        key_without_locale = split_key(key).last
+        store_request_info(key_without_locale)
+        update_request_keys(key_without_locale, value)
+      end
+      value
     end
 
     def []=(key, value)
@@ -45,7 +62,8 @@ module Lit
     end
 
     def has_key?(key)
-      localizations.has_key?(key)
+      # check for instance cache first
+      localization_cache.has_key?(key) || localizations.has_key?(key)
     end
 
     def sync
@@ -67,12 +85,15 @@ module Lit
       locale = find_locale(locale_key)
       localization = find_localization(locale, key_without_locale, value: value, force_array: force_array, update_value: true)
       return localization.translation if startup_process && localization.is_changed?
+
       localizations[key] = localization.translation if localization
+      localization_cache[key] = localizations[key]
     end
 
     def update_cache(key, value)
       key = key.to_s
       localizations[key] = value
+      localization_cache[key] = value
     end
 
     def delete_locale(key)
@@ -83,6 +104,7 @@ module Lit
       delete_localization(locale, key_without_locale)
       @localization_key_object_cache = {}
       @localization_object_cache = {}
+      clear_localization_cache
     end
 
     def load_all_translations
@@ -103,6 +125,7 @@ module Lit
       @localization_object_cache.delete(key)
       localization = find_localization(locale, key_without_locale, default_fallback: true)
       localizations[key] = localization.translation if localization
+      clear_localization_cache
     end
 
     def delete_key(key)
@@ -115,10 +138,16 @@ module Lit
       I18n.backend.reload!
     end
 
-    def reset
+    def reset_local_cache
       @locale_cache = {}
       @localization_key_object_cache = {}
       @localization_object_cache = {}
+      @localization_cache = {}
+      clear_localization_cache
+    end
+
+    def reset
+      reset_local_cache
       localizations.clear
       localization_keys.clear
       load_all_translations
@@ -128,7 +157,7 @@ module Lit
     def find_locale(locale_key)
       locale_key = locale_key.to_s
       @locale_cache ||= {}
-      unless @locale_cache.key?(locale_key)
+      unless @locale_cache.key?(locale_key) && @locale_cache[locale_key].id
         locale = Lit::Locale.where(locale: locale_key).first_or_create!
         @locale_cache[locale_key] = locale
       end
@@ -151,6 +180,29 @@ module Lit
       @hits_counter_working = true
     end
 
+    def localization_cache
+      # Thread.current[:lit_thread_cache] ||= {}
+      @@localization_cache ||= {}
+    end
+
+    def clear_localization_cache
+      # Thread.current[:lit_thread_cache] = {}
+      @@localization_cache = {}
+    end
+
+    def check_and_clean_if_required
+      # we want this method to run only once during a request or background job
+      return if Thread.current[:localization_cache_valid]
+
+      # get most recently updated translation and compare with what we store in class var
+      last_up = Lit::Localization.order(updated_at: :desc).limit(1).pluck(:updated_at).first.to_i
+      if last_up != @@last_update
+        clear_localization_cache
+        @@last_update = last_up
+      end
+      Thread.current[:localization_cache_valid] = true
+    end
+
     private
 
     def localizations
@@ -305,6 +357,7 @@ module Lit
 
     def update_hits_count(key)
       return unless @hits_counter_working
+
       key_without_locale = split_key(key).last
       @hits_counter.incr('hits_counter.' + key)
       @hits_counter.incr('global_hits_counter.' + key_without_locale)
@@ -313,6 +366,7 @@ module Lit
     def store_request_info(key_without_locale)
       return unless Lit.store_request_info
       return unless Thread.current[:lit_current_request_path].present?
+
       info = get_request_info(key_without_locale)
       parts = info.split(' ').push(Thread.current[:lit_current_request_path]).uniq
       parts.shift if parts.count > 10
@@ -320,7 +374,9 @@ module Lit
     end
 
     def update_request_keys(key_without_locale, localization)
+      return unless Lit.store_request_keys
       return if Thread.current[:lit_request_keys].nil?
+
       Thread.current[:lit_request_keys] ||= {}
       Thread.current[:lit_request_keys][key_without_locale] = localization
     end

data/lib/lit/cloud_translation/providers/google.rb

@@ -96,6 +96,8 @@ module Lit::CloudTranslation::Providers
         text_or_array.gsub(/%{(.+?)}/, '<code>__LIT__\1__LIT__</code>')
       when Array
         text_or_array.map { |s| sanitize_text(s) }
+      when nil
+        ''
       else
         raise TypeError
       end

data/lib/lit/cloud_translation/providers/yandex.rb

@@ -63,6 +63,8 @@ module Lit::CloudTranslation::Providers
         text_or_array.gsub(/%{(.+?)}/, '%{_LIT_\1_LIT_}')
       when Array
         text_or_array.map { |s| sanitize_text(s) }
+      when nil
+        ''
       else
         raise TypeError
       end

data/lib/lit/engine.rb

@@ -3,17 +3,18 @@ module Lit
     require 'jquery-rails'
 
     config.autoload_paths += %W[#{Lit::Engine.root}/app/controllers/lit/concerns]
+    paths.add 'lib', eager_load: true # Zeitwerk compatibility
 
     isolate_namespace Lit
 
     initializer 'lit.assets.precompile' do |app|
       app.config.assets.precompile += %w[lit/application.css lit/application.js]
       app.config.assets.precompile += %w[lit/lit_frontend.css lit/lit_frontend.js]
-      # add language flags to list of precompiled assets
-      if app.config.i18n.available_locales
-        app.config.i18n.available_locales.each do |l|
-          app.config.assets.precompile << "lit/famfamfam_flags/#{l.to_s[0,2]}.png"
-        end
+    end
+
+    initializer 'lit.reloader' do |app|
+      config.to_prepare do
+        Lit.loader.cache.reset_local_cache if Lit.loader
       end
     end
 
@@ -24,5 +25,11 @@ module Lit
         end
       end
     end
+
+    initializer :append_before_action do
+      ActionController::Base.send :before_action do
+        Thread.current[:lit_thread_cache] = {}
+      end
+    end
   end
 end

data/lib/lit/export.rb

@@ -1,4 +1,5 @@
 require 'csv'
+require 'lit/services/localization_keys_to_hash_service'
 
 module Lit
   class Export
@@ -17,7 +18,7 @@ module Lit
 
       case format
       when :yaml
-        exported_keys = nested_string_keys_to_hash(db_localizations)
+        exported_keys = Lit::LocalizationKeysToHashService.call(db_localizations)
         exported_keys.to_yaml
       when :csv
         relevant_locales = locale_keys.presence || I18n.available_locales.map(&:to_s)
@@ -55,23 +56,6 @@ module Lit
       end
     end
 
-    private_class_method def self.nested_string_keys_to_hash(db_localizations)
-      # http://subtech.g.hatena.ne.jp/cho45/20061122
-      deep_proc = proc do |_k, s, o|
-        if s.is_a?(Hash) && o.is_a?(Hash)
-          next s.merge(o, &deep_proc)
-        end
-        next o
-      end
-      nested_keys = {}
-      db_localizations.sort.each do |k, v|
-        key_parts = k.to_s.split('.')
-        converted = key_parts.reverse.reduce(v) { |a, n| { n => a } }
-        nested_keys.merge!(converted, &deep_proc)
-      end
-      nested_keys
-    end
-
     # This is like Array#transpose but ignores size differences between inner arrays.
     private_class_method def self.transpose(matrix)
       maxlen = matrix.max { |x| x.length }.length

data/lib/lit/i18n_backend.rb

@@ -69,10 +69,20 @@ module Lit
 
       parts = I18n.normalize_keys(locale, key, scope, options[:separator])
       key_with_locale = parts.join('.')
+
+      # we might want to return content later, but we first need to check if it's in cache.
+      # it's important to rememver, that accessing non-existen key modifies cache by creating one
+      had_key = @cache.has_key?(key_with_locale)
+
       # check in cache or in simple backend
       content = @cache[key_with_locale] || super
+
+      # return if content is in cache - it CAN be `nil`
+      return content if had_key && !options[:default]
+
       return content if parts.size <= 1
-      if content.nil? && should_cache?(key_with_locale, options)
+
+      if content.nil? && should_cache?(key_with_locale, options, had_key)
         new_content = @cache.init_key_with_value(key_with_locale, content)
         content = new_content if content.nil? # Content can change when Lit.humanize is true for example
         # so there is no content in cache - it might not be if ie. we're doing
@@ -106,7 +116,7 @@ module Lit
           # it anyway if we return nil, but then it will wrap it also in
           # translation_missing span.
           # Humanizing key should be last resort
-          if content.nil? && Lit.humanize_key && key.match(Lit.humanize_key_ignored).nil?
+          if content.nil? && Lit.humanize_key && Lit.humanize_key_ignored.match(key).nil?
             content = key.to_s.split('.').last.humanize
             if content.present?
               @cache[key_with_locale] = content
@@ -129,7 +139,7 @@ module Lit
         # end
       elsif data.respond_to?(:to_str) || data.is_a?(Array)
         key = ([locale] + scope).join('.')
-        return if startup_process && @cache.keys.member?(key) && Lit.ignore_yaml_on_startup
+        return if startup_process && Lit.ignore_yaml_on_startup && (Thread.current[:lit_cache_keys] || @cache.keys).member?(key)
         @cache.update_locale(key, data, data.is_a?(Array), startup_process)
       elsif data.nil?
         return if startup_process
@@ -139,11 +149,13 @@ module Lit
     end
 
     def load_translations_to_cache
+      Thread.current[:lit_cache_keys] = @cache.keys
       ActiveRecord::Base.transaction do
         (@translations || {}).each do |locale, data|
           store_item(locale, data, [], true) if valid_locale?(locale)
         end
       end
+      Thread.current[:lit_cache_keys] = nil
     end
 
     def init_translations
@@ -155,7 +167,7 @@ module Lit
       # load translations from database to cache
       @cache.load_all_translations
       # load translations from @translations to cache
-      load_translations_to_cache
+      load_translations_to_cache unless Lit.ignore_yaml_on_startup
       @initialized = true
     end
 
@@ -179,9 +191,10 @@ module Lit
       Lit.ignored_keys.any?{ |k| key_without_locale.start_with?(k) }
     end
 
-    def should_cache?(key_with_locale, options)
-      if @cache.has_key?(key_with_locale)
-        return false unless options[:default]
+    # checks if should cache. `had_key` is passed, as once cache has been accesed, it's already modified and key exists
+    def should_cache?(key_with_locale, options, had_key)
+      if had_key
+        return false unless options[:default] && !options[:default].is_a?(Array)
       end
 
       _, key_without_locale = ::Lit::Cache.split_key(key_with_locale)