module I18n::Backend::Simple::Implementation

Constants

MUTEX: Mutex to ensure that concurrent translations loading will be thread-safe

Public Instance Methods

Get available locales from the translations hash

# File lib/i18n/backend/simple.rb, line 49
def available_locales
  init_translations unless initialized?
  translations.inject([]) do |locales, (locale, data)|
    locales << locale unless data.size <= 1 && (data.empty? || data.has_key?(:i18n))
    locales
  end
end

eager_load! ()

Calls superclass method I18n::Backend::Base#eager_load!

# File lib/i18n/backend/simple.rb, line 64
def eager_load!
  init_translations unless initialized?
  super
end

initialized? ()

# File lib/i18n/backend/simple.rb, line 28
def initialized?
  @initialized ||= false
end

reload! ()

Clean up translations hash and set initialized to false on reload!

Calls superclass method I18n::Backend::Base#reload!

# File lib/i18n/backend/simple.rb, line 58
def reload!
  @initialized = false
  @translations = nil
  super
end

store_translations (locale, data, options = EMPTY_HASH)

Stores translations for the given locale in memory. This uses a deep merge for the translations hash, so existing translations will be overwritten by new ones only at the deepest level of the hash.

# File lib/i18n/backend/simple.rb, line 36
def store_translations(locale, data, options = EMPTY_HASH)
  if I18n.enforce_available_locales &&
    I18n.available_locales_initialized? &&
    !I18n.locale_available?(locale)
    return data
  end
  locale = locale.to_sym
  translations[locale] ||= Concurrent::Hash.new
  data = Utils.deep_symbolize_keys(data) unless options.fetch(:skip_symbolize_keys, false)
  Utils.deep_merge!(translations[locale], data)
end

translations (do_init: false)

# File lib/i18n/backend/simple.rb, line 69
def translations(do_init: false)
  # To avoid returning empty translations,
  # call `init_translations`
  init_translations if do_init && !initialized?

  @translations ||= Concurrent::Hash.new do |h, k|
    MUTEX.synchronize do
      h[k] = Concurrent::Hash.new
    end
  end
end

Protected Instance Methods

init_translations ()

# File lib/i18n/backend/simple.rb, line 83
def init_translations
  load_translations
  @initialized = true
end

lookup (locale, key, scope = [], options = EMPTY_HASH)

Looks up a translation from the translations hash. Returns nil if either key is nil, or locale, scope or key do not exist as a key in the nested translations hash. Splits keys or scopes containing dots into multiple keys, i.e. currency.format is regarded the same as %w(currency format).

# File lib/i18n/backend/simple.rb, line 93
def lookup(locale, key, scope = [], options = EMPTY_HASH)
  init_translations unless initialized?
  keys = I18n.normalize_keys(locale, key, scope, options[:separator])

  keys.inject(translations) do |result, _key|
    return nil unless result.is_a?(Hash)
    unless result.has_key?(_key)
      _key = _key.to_s.to_sym
      return nil unless result.has_key?(_key)
    end
    result = result[_key]
    result = resolve_entry(locale, _key, result, Utils.except(options.merge(:scope => nil), :count)) if result.is_a?(Symbol)
    result
  end
end