module I18n::Backend::Base

def available_locales

ignoring the reserved translation meta data key :i18n.
Returns an array of locales for which translations are available
def available_locales
  raise NotImplementedError
end

def default(locale, object, subject, options = {})

the translation directly.
first translation that can be resolved. Otherwise it tries to resolve
If given subject is an Array, it walks the array and returns the
Evaluates defaults.
def default(locale, object, subject, options = {})
  options = options.dup.reject { |key, value| key == :default }
  case subject
  when Array
    subject.each do |item|
      result = resolve(locale, object, item, options) and return result
    end and nil
  else
    resolve(locale, object, subject, options)
  end
end

def interpolate(locale, string, values = {})

# => "file test.txt opened by %{user}"
interpolate "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'

Interpolates values into a given string.
def interpolate(locale, string, values = {})
  if string.is_a?(::String) && !values.empty?
    I18n.interpolate(string, values)
  else
    string
  end
end

def load_file(filename)

for all other file extensions.
data to the existing translations. Raises I18n::UnknownFileType
#load_yml depending on the file extension and directly merges the
Loads a single translations file by delegating to #load_rb or
def load_file(filename)
  type = File.extname(filename).tr('.', '').downcase
  raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
  data = send(:"load_#{type}", filename)
  unless data.is_a?(Hash)
    raise InvalidLocaleData.new(filename, 'expects it to return a hash, but does not')
  end
  data.each { |locale, d| store_translations(locale, d || {}) }
end

def load_rb(filename)

a Hash containing translation data with locales as toplevel keys.
Loads a plain Ruby translations file. eval'ing the file must yield
def load_rb(filename)
  eval(IO.read(filename), binding, filename)
end

def load_translations(*filenames)

for details.
plain Ruby (*.rb) or YAML files (*.yml). See #load_rb and #load_yml
Accepts a list of paths to translation files. Loads translations from
def load_translations(*filenames)
  filenames = I18n.load_path if filenames.empty?
  filenames.flatten.each { |filename| load_file(filename) }
end

def load_yml(filename)

toplevel keys.
Loads a YAML translations file. The data must have locales as
def load_yml(filename)
  begin
    YAML.load_file(filename)
  rescue TypeError, ScriptError, StandardError => e
    raise InvalidLocaleData.new(filename, e.inspect)
  end
end

def localize(locale, object, format = :default, options = {})

a format argument (e.g., :short in :'date.formats').
format string. Takes a key from the date/time formats translations as
Acts the same as +strftime+, but uses a localized version of the
def localize(locale, object, format = :default, options = {})
  raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
  if Symbol === format
    key  = format
    type = object.respond_to?(:sec) ? 'time' : 'date'
    options = options.merge(:raise => true, :object => object, :locale => locale)
    format  = I18n.t(:"#{type}.formats.#{key}", options)
  end
  # format = resolve(locale, object, format, options)
  format = format.to_s.gsub(/%[aAbBp]/) do |match|
    case match
    when '%a' then I18n.t(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
    when '%A' then I18n.t(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
    when '%b' then I18n.t(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
    when '%B' then I18n.t(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
    when '%p' then I18n.t(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format) if object.respond_to? :hour
    end
  end
  object.strftime(format)
end

def lookup(locale, key, scope = [], options = {})

The method which actually looks up for the translation in the store.
def lookup(locale, key, scope = [], options = {})
  raise NotImplementedError
end

def pluralize(locale, entry, count)

Other backends can implement more flexible or complex pluralization rules.
not stand with regards to the CLDR pluralization rules.
equal to 0 and there is a :zero subkey present. This behaviour is
- It will pick the :zero subkey in the special case where count is
- It will pick the :other subkey otherwise.
- It will pick the :one subkey if count is equal to 1.
pluralization rules :
Picks a translation from a pluralized mnemonic subkey according to English
def pluralize(locale, entry, count)
  return entry unless entry.is_a?(Hash) && count
  key = :zero if count == 0 && entry.has_key?(:zero)
  key ||= count == 1 ? :one : :other
  raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
  entry[key]
end

def reload!

def reload!
  @skip_syntax_deprecation = false
end

def resolve(locale, object, subject, options = {})

subjects will be returned directly.
given options. If it is a Proc then it will be evaluated. All other
If the given subject is a Symbol, it will be translated with the
Resolves a translation.
def resolve(locale, object, subject, options = {})
  return subject if options[:resolve] == false
  result = catch(:exception) do
    case subject
    when Symbol
      I18n.translate(subject, options.merge(:locale => locale, :throw => true))
    when Proc
      date_or_time = options.delete(:object) || object
      resolve(locale, object, subject.call(date_or_time, options))
    else
      subject
    end
  end
  result unless result.is_a?(MissingTranslation)
end

def store_translations(locale, data, options = {})

Should be implemented
This method receives a locale, a data hash and options for storing translations.
def store_translations(locale, data, options = {})
  raise NotImplementedError
end

def translate(locale, key, options = {})

def translate(locale, key, options = {})
  raise InvalidLocale.new(locale) unless locale
  entry = key && lookup(locale, key, options[:scope], options)
  if options.empty?
    entry = resolve(locale, key, entry, options)
  else
    count, default = options.values_at(:count, :default)
    values = options.except(*RESERVED_KEYS)
    entry = entry.nil? && default ?
      default(locale, key, default, options) : resolve(locale, key, entry, options)
  end
  throw(:exception, I18n::MissingTranslation.new(locale, key, options)) if entry.nil?
  entry = entry.dup if entry.is_a?(String)
  entry = pluralize(locale, entry, count) if count
  entry = interpolate(locale, entry, values) if values
  entry
end