1  # encoding: utf-8
   2 
   3  module I18n
   4    module Backend
   5      # A simple backend that reads translations from YAML files and stores them in
   6      # an in-memory hash. Relies on the Base backend.
   7      #
   8      # The implementation is provided by a Implementation module allowing to easily
   9      # extend Simple backend's behavior by including modules. E.g.:
  10      #
  11      # module I18n::Backend::Pluralization
  12      #   def pluralize(*args)
  13      #     # extended pluralization logic
  14      #     super
  15      #   end
  16      # end
  17      #
  18      # I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
  19      class Simple
  20        module Implementation
  21          include Base
  22 
  23          def initialized?
  24            @initialized ||= false
  25          end
  26 
  27          # Stores translations for the given locale in memory.
  28          # This uses a deep merge for the translations hash, so existing
  29          # translations will be overwritten by new ones only at the deepest
  30          # level of the hash.
  31          def store_translations(locale, data, options = {})
  32            locale = locale.to_sym
  33            translations[locale] ||= {}
  34            data = data.deep_symbolize_keys
  35            translations[locale].deep_merge!(data)
  36          end
  37 
  38          # Get available locales from the translations hash
  39          def available_locales
  40            init_translations unless initialized?
  41            translations.inject([]) do |locales, (locale, data)|
  42              locales << locale unless (data.keys - [:i18n]).empty?
  43              locales
  44            end
  45          end
  46 
  47          # Clean up translations hash and set initialized to false on reload!
  48          def reload!
  49            @initialized = false
  50            @translations = nil
  51            super
  52          end
  53 
  54        protected
  55 
  56          def init_translations
  57            load_translations
  58            @initialized = true
  59          end
  60 
  61          def translations
  62            @translations ||= {}
  63          end
  64 
  65          # Looks up a translation from the translations hash. Returns nil if
  66          # eiher key is nil, or locale, scope or key do not exist as a key in the
  67          # nested translations hash. Splits keys or scopes containing dots
  68          # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
  69          # <tt>%w(currency format)</tt>.
  70          def lookup(locale, key, scope = [], options = {})
  71            init_translations unless initialized?
  72            keys = I18n.normalize_keys(locale, key, scope, options[:separator])
  73 
  74            keys.inject(translations) do |result, key|
  75              key = key.to_sym
  76              return nil unless result.is_a?(Hash) && result.has_key?(key)
  77              result = result[key]
  78              result = resolve(locale, key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
  79              result
  80            end
  81          end
  82        end
  83 
  84        include Implementation
  85      end
  86    end
  87  end