class Lit::Cache

Public Class Methods

new() click to toggle source
# File lib/lit/cache.rb, line 21
def initialize
  @hits_counter = Lit.get_key_value_engine
  @request_info_store = Lit.get_key_value_engine
  @hits_counter_working = true
  @keys = nil
end

Private Class Methods

flatten_hash(hash_to_flatten, parent = []) click to toggle source
# File lib/lit/cache.rb, line 347
def self.flatten_hash(hash_to_flatten, parent = [])
  hash_to_flatten.flat_map do |key, value|
    case value
    when Hash then flatten_hash(value, parent + [key])
    else [(parent + [key]).join('.'), value]
    end
  end
end
split_key(key) click to toggle source
# File lib/lit/cache.rb, line 343
def self.split_key(key)
  key.split('.', 2)
end

Public Instance Methods

[](key) click to toggle source
# File lib/lit/cache.rb, line 28
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
end
[]=(key, value) click to toggle source
# File lib/lit/cache.rb, line 37
def []=(key, value)
  update_locale(key, value)
end
clear()
Alias for: reset
delete_key(key) click to toggle source
# File lib/lit/cache.rb, line 103
def delete_key(key)
  key = key.to_s
  localizations.delete(key)
  key_without_locale = split_key(key).last
  localization_keys.delete(key_without_locale)
  I18n.backend.reload!
end
delete_locale(key) click to toggle source
# File lib/lit/cache.rb, line 76
def delete_locale(key)
  key = key.to_s
  keys.delete(key)
  locale_key, key_without_locale = split_key(key)
  locale = find_locale(locale_key)
  delete_localization(locale, key_without_locale)
end
export() click to toggle source

this comes directly from copycopter.

# File lib/lit/cache.rb, line 130
def export
  reset
  localizations_scope = Lit::Localization
  unless ENV['LOCALES'].blank?
    locale_keys = ENV['LOCALES'].to_s.split(',') || []
    locale_ids = Lit::Locale.where(locale: locale_keys).pluck(:id)
    localizations_scope = localizations_scope.where(locale_id: locale_ids) unless locale_ids.empty?
  end
  db_localizations = {}
  localizations_scope.find_each do |l|
    db_localizations[l.full_key] = l.get_value
  end
  exported_keys = nested_string_keys_to_hash(db_localizations)
  exported_keys.to_yaml
end
find_locale(locale_key) click to toggle source
# File lib/lit/cache.rb, line 119
def find_locale(locale_key)
  locale_key = locale_key.to_s
  @locale_cache ||= {}
  unless @locale_cache.key?(locale_key)
    locale = Lit::Locale.where(locale: locale_key).first_or_create!
    @locale_cache[locale_key] = locale
  end
  @locale_cache[locale_key]
end
get_global_hits_counter(key) click to toggle source
# File lib/lit/cache.rb, line 163
def get_global_hits_counter(key)
  @hits_counter['global_hits_counter.' + key]
end
get_hits_counter(key) click to toggle source
# File lib/lit/cache.rb, line 167
def get_hits_counter(key)
  @hits_counter['hits_counter.' + key]
end
get_request_info(key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 338
def get_request_info(key_without_locale)
  @request_info_store['request_info.' + key_without_locale].to_s
end
has_key?(key) click to toggle source
# File lib/lit/cache.rb, line 45
def has_key?(key)
  localizations.has_key?(key)
end
init_key_with_value(key, value) click to toggle source
# File lib/lit/cache.rb, line 41
def init_key_with_value(key, value)
  update_locale(key, value, true)
end
keys() click to toggle source
# File lib/lit/cache.rb, line 53
def keys
  return @keys if @keys.present?
  @keys = localizations.keys
  return @keys if localizations.prefix.nil?
  @keys = @keys.map do |k|
    k.gsub(/^#{localizations.prefix}/, '')
  end
end
load_all_translations() click to toggle source
# File lib/lit/cache.rb, line 84
def load_all_translations
  first = Localization.order(id: :asc).first
  last = Localization.order(id: :desc).first
  if !first || (!localizations.has_key?(first.full_key) ||
    !localizations.has_key?(last.full_key))
    Localization.includes([:locale, :localization_key]).find_each do |l|
      localizations[l.full_key] = l.get_value
    end
  end
end
nested_string_keys_to_hash(db_localizations) click to toggle source
# File lib/lit/cache.rb, line 146
def 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
refresh_key(key) click to toggle source
# File lib/lit/cache.rb, line 95
def refresh_key(key)
  key = key.to_s
  locale_key, key_without_locale = split_key(key)
  locale = find_locale(locale_key)
  localization = find_localization(locale, key_without_locale, default_fallback: true)
  localizations[key] = localization.get_value if localization
end
request_keys() click to toggle source
# File lib/lit/cache.rb, line 333
def request_keys
  Thread.current[:lit_request_keys] || {}
end
reset() click to toggle source
# File lib/lit/cache.rb, line 111
def reset
  @locale_cache = {}
  localizations.clear
  localization_keys.clear
  load_all_translations
end
Also aliased as: clear
restore_hits_counter() click to toggle source
# File lib/lit/cache.rb, line 175
def restore_hits_counter
  @hits_counter_working = true
end
stop_hits_counter() click to toggle source
# File lib/lit/cache.rb, line 171
def stop_hits_counter
  @hits_counter_working = false
end
sync() click to toggle source
# File lib/lit/cache.rb, line 49
def sync
  localizations.clear
end
update_cache(key, value) click to toggle source
# File lib/lit/cache.rb, line 71
def update_cache(key, value)
  key = key.to_s
  localizations[key] = value
end
update_locale(key, value, force_array = false, startup_process = false) click to toggle source
# File lib/lit/cache.rb, line 62
def update_locale(key, value, force_array = false, startup_process = false)
  key = key.to_s
  locale_key, key_without_locale = split_key(key)
  locale = find_locale(locale_key)
  localization = find_localization(locale, key_without_locale, value: value, force_array: force_array, update_value: true)
  return localization.get_value if startup_process && localization.is_changed?
  localizations[key] = localization.get_value if localization
end

Private Instance Methods

delete_localization(locale, key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 243
def delete_localization(locale, key_without_locale)
  localization = find_localization_for_delete(locale, key_without_locale)
  return unless localization
  localizations.delete("#{locale.locale}.#{key_without_locale}")
  localization_keys.delete(key_without_locale)
  localization.destroy # or localization.default_value = nil; localization.save!
end
fallback_localization(locale, key_without_locale) click to toggle source

fallback to translation in different locale

# File lib/lit/cache.rb, line 215
def fallback_localization(locale, key_without_locale)
  value = nil
  return nil unless fallbacks = ::Rails.application.config.i18n.fallbacks
  keys = fallbacks == true ? @locale_cache.keys : fallbacks
  keys.map(&:to_s).each do |lc|
    if lc != locale.locale && value.nil?
      nk = "#{lc}.#{key_without_locale}"
      v = localizations[nk]
      value = v if v.present? && value.nil?
    end
  end
  value
end
fallback_to_default(localization_key, localization) click to toggle source

tries to get `default_value` from localization_key - checks other localizations

# File lib/lit/cache.rb, line 231
def fallback_to_default(localization_key, localization)
  localization_key.localizations.where.not(default_value: nil). \
    where.not(id: localization.id).first&.default_value
end
find_localization(locale, key_without_locale, value: nil, force_array: false, update_value: false, default_fallback: false) click to toggle source
# File lib/lit/cache.rb, line 189
def find_localization(locale, key_without_locale, value: nil, force_array: false, update_value: false, default_fallback: false)
  return nil if value.is_a?(Hash)
  ActiveRecord::Base.transaction do
    localization_key = find_localization_key(key_without_locale)
    localization = Lit::Localization.where(locale_id: locale.id). \
                      where(localization_key_id: localization_key.id).first_or_initialize
    if update_value || localization.new_record?
      if value.is_a?(Array)
        value = parse_array_value(value) unless force_array
      elsif !value.nil?
        value = parse_value(value, locale)
      else
        if ::Rails.application.config.i18n.fallbacks
          value = fallback_localization(locale, key_without_locale)
        elsif default_fallback
          value = fallback_to_default(localization_key, localization)
        end
      end
      localization.update_default_value(value)
    end
    return localization
  end
  nil
end
find_localization_for_delete(locale, key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 236
def find_localization_for_delete(locale, key_without_locale)
  localization_key = find_localization_key_for_delete(key_without_locale)
  return nil unless localization_key
  Lit::Localization.find_by(locale_id: locale.id,
                            localization_key_id: localization_key.id)
end
find_localization_key(key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 288
def find_localization_key(key_without_locale)
  unless localization_keys.key?(key_without_locale)
    find_or_create_localization_key(key_without_locale)
  else
    Lit::LocalizationKey.find_by(id: localization_keys[key_without_locale]) || find_or_create_localization_key(key_without_locale)
  end
end
find_localization_key_for_delete(key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 296
def find_localization_key_for_delete(key_without_locale)
  lk = Lit::LocalizationKey.find_by(id: localization_keys[key_without_locale]) if localization_keys.has_key?(key_without_locale)
  lk || Lit::LocalizationKey.where(localization_key: key_without_locale).first
end
find_or_create_localization_key(key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 305
def find_or_create_localization_key(key_without_locale)
  localization_key = Lit::LocalizationKey.where(localization_key: key_without_locale).first_or_create!
  localization_keys[key_without_locale] = localization_key.id
  localization_key
end
localization_keys() click to toggle source
# File lib/lit/cache.rb, line 185
def localization_keys
  @localization_keys ||= Lit.get_key_value_engine
end
localizations() click to toggle source
# File lib/lit/cache.rb, line 181
def localizations
  @localizations ||= Lit.get_key_value_engine
end
parse_array_value(value) click to toggle source
# File lib/lit/cache.rb, line 278
def parse_array_value(value)
  new_value = nil
  value_clone = value.dup
  while (v = value_clone.shift) && v.present?
    pv = parse_value(v, locale)
    new_value = pv unless pv.nil?
  end
  new_value
end
parse_value(v, locale) click to toggle source

checks parameter type and returns value basing on it symbols are beeing looked up in db string are returned directly procs are beeing called (once) hashes are converted do string (for now)

# File lib/lit/cache.rb, line 256
def parse_value(v, locale)
  new_value = nil
  case v
    when Symbol then
      lk = Lit::LocalizationKey.where(localization_key: v.to_s).first
      if lk
        loca = Lit::Localization.where(locale_id: locale.id).
                    where(localization_key_id: lk.id).first
        new_value = loca.get_value if loca && loca.get_value.present?
      end
    when String then
      new_value = v
    when Hash then
      new_value = nil
    when Proc then
      new_value = nil # was v.call - requires more love
    else
      new_value = v.to_s
  end
  new_value
end
split_key(key) click to toggle source
# File lib/lit/cache.rb, line 301
def split_key(key)
  Lit::Cache.split_key(key)
end
store_request_info(key_without_locale) click to toggle source
# File lib/lit/cache.rb, line 318
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
  @request_info_store['request_info.' + key_without_locale] = parts.join ' '
end
update_hits_count(key) click to toggle source
# File lib/lit/cache.rb, line 311
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)
end
update_request_keys(key_without_locale, localization) click to toggle source
# File lib/lit/cache.rb, line 327
def update_request_keys(key_without_locale, localization)
  return if Thread.current[:lit_request_keys].nil?
  Thread.current[:lit_request_keys] ||= {}
  Thread.current[:lit_request_keys][key_without_locale] = localization
end