Methods
A
D
I
L
P
R
S
T
Included Modules
Constants
RESERVED_KEYS = [:scope, :default, :separator, :resolve]
 
RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
 
DEPRECATED_INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
 
INTERPOLATION_SYNTAX_PATTERN = /%\{([^\}]+)\}/
 
Instance Public methods
available_locales()

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

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 80
def available_locales
  raise NotImplementedError
end
load_translations(*filenames)

Accepts a list of paths to translation files. Loads translations from plain Ruby (*.rb) or YAML files (*.yml). See load_rb and load_yml for details.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 18
def load_translations(*filenames)
  filenames = I18n.load_path.flatten if filenames.empty?
  filenames.each { |filename| load_file(filename) }
end
localize(locale, object, format = :default, options = {})

Acts the same as strftime, but uses a localized version of the format string. Takes a key from the date/time formats translations as a format argument ( e.g., :shortin :'date.formats').

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 55
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'
    format = I18n.t(:"#{type}.formats.#{key}", options.merge(:raise => true, :object => object, :locale => locale))
  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
reload!()
# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 84
def reload!
  @skip_syntax_deprecation = false
end
store_translations(locale, data, options = {})

This method receives a locale, a data hash and options for storing translations. Should be implemented

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 25
def store_translations(locale, data, options = {})
  raise NotImplementedError
end
translate(locale, key, options = {})
# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 29
def translate(locale, key, options = {})
  raise InvalidLocale.new(locale) unless locale
  return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
  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
  raise(I18n::MissingTranslationData.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
Instance Protected methods
default(locale, object, subject, options = {})

Evaluates defaults. If given subject is an Array, it walks the array and returns the first translation that can be resolved. Otherwise it tries to resolve the translation directly.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 99
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
interpolate(locale, string, values = {})

Interpolates values into a given string.

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

Note that you have to double escape the \</tt> when you want to escape the <tt>{{...}}key in a string (once for the string and once for the interpolation).

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 151
def interpolate(locale, string, values = {})
  return string unless string.is_a?(::String) && !values.empty?
  original_values = values.dup
  preserve_encoding(string) do
    string = string.gsub(DEPRECATED_INTERPOLATION_SYNTAX_PATTERN) do
      escaped, key = $1, $2.to_sym
      if escaped
        "{{#{key}}}"
      else
        warn_syntax_deprecation!
        "%{#{key}}"
      end
    end
    keys = string.scan(INTERPOLATION_SYNTAX_PATTERN).flatten
    return string if keys.empty?
    values.each do |key, value|
      if keys.include?(key.to_s)
        value = value.call(values) if interpolate_lambda?(value, string, key)
        value = value.to_s unless value.is_a?(::String)
        values[key] = value
      else
        values.delete(key)
      end
    end
    string % values
  end
rescue KeyError => e
  if string =~ RESERVED_KEYS_PATTERN
    raise ReservedInterpolationKey.new($1.to_sym, string)
  else
    raise MissingInterpolationArgument.new(original_values, string)
  end
end
interpolate_lambda?(object, string, key)

returns true when the given value responds to :call and the key is an interpolation placeholder in the given string

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 202
def interpolate_lambda?(object, string, key)
  object.respond_to?(:call) && string =~ /%\{#{key}\}|%\<#{key}>.*?\d*\.?\d*[bBdiouxXeEfgGcps]\}/
end
load_file(filename)

Loads a single translations file by delegating to load_rb or load_yml depending on the file extension and directly merges the data to the existing translations. Raises I18n::UnknownFileType for all other file extensions.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 210
def load_file(filename)
  type = File.extname(filename).tr('.', '').downcase
  raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}")
  data = send(:"load_#{type}", filename) # TODO raise a meaningful exception if this does not yield a Hash
  data.each { |locale, d| store_translations(locale, d) }
end
load_rb(filename)

Loads a plain Ruby translations file. eval'ing the file must yield a Hash containing translation data with locales as toplevel keys.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 219
def load_rb(filename)
  eval(IO.read(filename), binding, filename)
end
load_yml(filename)

Loads a YAML translations file. The data must have locales as toplevel keys.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 225
def load_yml(filename)
  YAML::load(IO.read(filename))
end
lookup(locale, key, scope = [], options = {})

The method which actually looks up for the translation in the store.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 91
def lookup(locale, key, scope = [], options = {})
  raise NotImplementedError
end
pluralize(locale, entry, count)

Picks a translation from an array according to English pluralization rules. It will pick the first translation if count is not equal to 1 and the second translation if it is equal to 1. Other backends can implement more flexible or complex pluralization rules.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 134
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
preserve_encoding(string)
# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 189
def preserve_encoding(string)
  if string.respond_to?(:encoding)
    encoding = string.encoding
    result = yield
    result.force_encoding(encoding) if result.respond_to?(:force_encoding)
    result
  else
    yield
  end
end
resolve(locale, object, subject, options = nil)

Resolves a translation. If the given subject is a Symbol, it will be translated with the given options. If it is a Proc then it will be evaluated. All other subjects will be returned directly.

# File activesupport/lib/active_support/vendor/i18n-0.4.1/i18n/backend/base.rb, line 115
def resolve(locale, object, subject, options = nil)
  return subject if options[:resolve] == false
  case subject
  when Symbol
    I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
  when Proc
    date_or_time = options.delete(:object) || object
    resolve(locale, object, subject.call(date_or_time, options), options = {})
  else
    subject
  end
rescue MissingTranslationData
  nil
end