i18n 0.4.0 → 1.14.4

data/lib/i18n.rb

@@ -1,22 +1,57 @@
-# encoding: utf-8
-
-# Authors::   Sven Fuchs (http://www.artweb-design.de),
-#             Joshua Harvey (http://www.workingwithrails.com/person/759-joshua-harvey),
-#             Stephan Soller (http://www.arkanis-development.de/),
-#             Saimon Moore (http://saimonmoore.net),
-#             Matt Aimonetti (http://railsontherun.com/)
-# Copyright:: Copyright (c) 2008 The Ruby i18n Team
-# License::   MIT
+# frozen_string_literal: true
+
+require 'concurrent/map'
+require 'concurrent/hash'
+
+require 'i18n/version'
+require 'i18n/utils'
 require 'i18n/exceptions'
-require 'i18n/core_ext/string/interpolate'
+require 'i18n/interpolate/ruby'
 
 module I18n
   autoload :Backend, 'i18n/backend'
   autoload :Config,  'i18n/config'
   autoload :Gettext, 'i18n/gettext'
   autoload :Locale,  'i18n/locale'
+  autoload :Tests,   'i18n/tests'
+  autoload :Middleware,   'i18n/middleware'
+
+  RESERVED_KEYS = %i[
+    cascade
+    deep_interpolation
+    default
+    exception_handler
+    fallback
+    fallback_in_progress
+    fallback_original_locale
+    format
+    object
+    raise
+    resolve
+    scope
+    separator
+    throw
+  ]
+  EMPTY_HASH = {}.freeze
+
+  def self.new_double_nested_cache # :nodoc:
+    Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+  end
+
+  # Marks a key as reserved. Reserved keys are used internally,
+  # and can't also be used for interpolation. If you are using any
+  # extra keys as I18n options, you should call I18n.reserve_key
+  # before any I18n.translate (etc) calls are made.
+  def self.reserve_key(key)
+    RESERVED_KEYS << key.to_sym
+    @reserved_keys_pattern = nil
+  end
 
-  class << self
+  def self.reserved_keys_pattern # :nodoc:
+    @reserved_keys_pattern ||= /%\{(#{RESERVED_KEYS.join("|")})\}/
+  end
+
+  module Base
     # Gets I18n configuration object.
     def config
       Thread.current[:i18n_config] ||= I18n::Config.new
@@ -29,7 +64,7 @@ module I18n
 
     # Write methods which delegates to the configuration object
     %w(locale backend default_locale available_locales default_separator
-      exception_handler load_path).each do |method|
+      exception_handler load_path enforce_available_locales).each do |method|
       module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
         def #{method}
           config.#{method}
@@ -45,9 +80,17 @@ module I18n
     # Rails development environment. Backends can implement whatever strategy
     # is useful.
     def reload!
+      config.clear_available_locales_set
       config.backend.reload!
     end
 
+    # Tells the backend to load translations now. Used in situations like the
+    # Rails production environment. Backends can implement whatever strategy
+    # is useful.
+    def eager_load!
+      config.backend.eager_load!
+    end
+
     # Translates, pluralizes and interpolates a given key using a given locale,
     # scope, and default, as well as interpolation values.
     #
@@ -87,7 +130,7 @@ module I18n
     # *PLURALIZATION*
     #
     # Translation data can contain pluralized translations. Pluralized translations
-    # are arrays of singluar/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
+    # are arrays of singular/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
     #
     # Note that <tt>I18n::Backend::Simple</tt> only supports an algorithm for English
     # pluralization rules. Other algorithms can be supported by custom backends.
@@ -135,32 +178,67 @@ module I18n
     # called and passed the key and options.
     #
     # E.g. assuming the key <tt>:salutation</tt> resolves to:
-    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{options[:name]}" : "Mrs. %{options[:name]}" }
+    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. #{options[:name]}" : "Mrs. #{options[:name]}" }
     #
     # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
     #
+    # Note that the string returned by lambda will go through string interpolation too,
+    # so the following lambda would give the same result:
+    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{name}" : "Mrs. %{name}" }
+    #
     # It is recommended to use/implement lambdas in an "idempotent" way. E.g. when
     # a cache layer is put in front of I18n.translate it will generate a cache key
-    # from the argument values passed to #translate. Therefor your lambdas should
+    # from the argument values passed to #translate. Therefore your lambdas should
     # always return the same translations/values per unique combination of argument
     # values.
-    def translate(*args)
-      options = args.pop if args.last.is_a?(Hash)
-      key     = args.shift
-      locale  = options && options.delete(:locale) || config.locale
-      raises  = options && options.delete(:raise)
-      config.backend.translate(locale, key, options || {})
-    rescue I18n::ArgumentError => exception
-      raise exception if raises
-      handle_exception(exception, locale, key, options)
+    #
+    # *Ruby 2.7+ keyword arguments warning*
+    #
+    # This method uses keyword arguments.
+    # There is a breaking change in ruby that produces warning with ruby 2.7 and won't work as expected with ruby 3.0
+    # The "hash" parameter must be passed as keyword argument.
+    #
+    # Good:
+    #  I18n.t(:salutation, :gender => 'w', :name => 'Smith')
+    #  I18n.t(:salutation, **{ :gender => 'w', :name => 'Smith' })
+    #  I18n.t(:salutation, **any_hash)
+    #
+    # Bad:
+    #  I18n.t(:salutation, { :gender => 'w', :name => 'Smith' })
+    #  I18n.t(:salutation, any_hash)
+    #
+    def translate(key = nil, throw: false, raise: false, locale: nil, **options) # TODO deprecate :raise
+      locale ||= config.locale
+      raise Disabled.new('t') if locale == false
+      enforce_available_locales!(locale)
+
+      backend = config.backend
+
+      if key.is_a?(Array)
+        key.map do |k|
+          translate_key(k, throw, raise, locale, backend, options)
+        end
+      else
+        translate_key(key, throw, raise, locale, backend, options)
+      end
     end
     alias :t :translate
 
-    def translate!(key, options = {})
-      translate(key, options.merge( :raise => true ))
+    # Wrapper for <tt>translate</tt> that adds <tt>:raise => true</tt>. With
+    # this option, if no translation is found, it will raise <tt>I18n::MissingTranslationData</tt>
+    def translate!(key, **options)
+      translate(key, **options, raise: true)
     end
     alias :t! :translate!
 
+    # Returns true if a translation exists for a given key, otherwise returns false.
+    def exists?(key, _locale = nil, locale: _locale, **options)
+      locale ||= config.locale
+      raise Disabled.new('exists?') if locale == false
+      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
+      config.backend.exists?(locale, key, options)
+    end
+
     # Transliterates UTF-8 characters to ASCII. By default this method will
     # transliterate only Latin strings to an ASCII approximation:
     #
@@ -190,14 +268,14 @@ module I18n
     #
     # Setting a Hash using Ruby:
     #
-    #     store_translations(:de, :i18n => {
-    #       :transliterate => {
-    #         :rule => {
-    #           "ü" => "ue",
-    #           "ö" => "oe"
-    #         }
-    #       }
-    #     )
+    #     store_translations(:de, i18n: {
+    #                          transliterate: {
+    #                            rule: {
+    #                              'ü' => 'ue',
+    #                              'ö' => 'oe'
+    #                            }
+    #                          }
+    #                        })
     #
     # Setting a Proc:
     #
@@ -212,66 +290,89 @@ module I18n
     #     I18n.transliterate("Jürgen") # => "Juergen"
     #     I18n.transliterate("Jürgen", :locale => :en) # => "Jurgen"
     #     I18n.transliterate("Jürgen", :locale => :de) # => "Juergen"
-    def transliterate(*args)
-      options      = args.pop if args.last.is_a?(Hash)
-      key          = args.shift
-      locale       = options && options.delete(:locale) || config.locale
-      raises       = options && options.delete(:raise)
-      replacement  = options && options.delete(:replacement)
+    def transliterate(key, throw: false, raise: false, locale: nil, replacement: nil, **options)
+      locale ||= config.locale
+      raise Disabled.new('transliterate') if locale == false
+      enforce_available_locales!(locale)
+
       config.backend.transliterate(locale, key, replacement)
     rescue I18n::ArgumentError => exception
-      raise exception if raises
-      handle_exception(exception, locale, key, options)
+      handle_exception((throw && :throw || raise && :raise), exception, locale, key, options)
     end
 
     # Localizes certain objects, such as dates and numbers to local formatting.
-    def localize(object, options = {})
-      locale = options.delete(:locale) || config.locale
-      format = options.delete(:format) || :default
+    def localize(object, locale: nil, format: nil, **options)
+      locale ||= config.locale
+      raise Disabled.new('l') if locale == false
+      enforce_available_locales!(locale)
+
+      format ||= :default
       config.backend.localize(locale, object, format, options)
     end
     alias :l :localize
 
     # Executes block with given I18n.locale set.
     def with_locale(tmp_locale = nil)
-      if tmp_locale
+      if tmp_locale == nil
+        yield
+      else
         current_locale = self.locale
-        self.locale    = tmp_locale
+        self.locale = tmp_locale
+        begin
+          yield
+        ensure
+          self.locale = current_locale
+        end
       end
-      yield
-    ensure
-      self.locale = current_locale if tmp_locale
     end
 
-
     # Merges the given locale, key and scope into a single array of keys.
     # Splits keys that contain dots into multiple keys. Makes sure all
     # keys are Symbols.
     def normalize_keys(locale, key, scope, separator = nil)
       separator ||= I18n.default_separator
 
-      keys = []
-      keys.concat normalize_key(locale, separator)
-      keys.concat normalize_key(scope, separator)
-      keys.concat normalize_key(key, separator)
-      keys
+      [
+        *normalize_key(locale, separator),
+        *normalize_key(scope, separator),
+        *normalize_key(key, separator)
+      ]
+    end
+
+    # Returns true when the passed locale, which can be either a String or a
+    # Symbol, is in the list of available locales. Returns false otherwise.
+    def locale_available?(locale)
+      I18n.config.available_locales_set.include?(locale)
+    end
+
+    # Raises an InvalidLocale exception when the passed locale is not available.
+    def enforce_available_locales!(locale)
+      if locale != false && config.enforce_available_locales
+        raise I18n::InvalidLocale.new(locale) if !locale_available?(locale)
+      end
+    end
+
+    def available_locales_initialized?
+      config.available_locales_initialized?
     end
 
-  # making these private until Ruby 1.9.2 can send to protected methods again
-  # see http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=24280
   private
 
-    # Handles exceptions raised in the backend. All exceptions except for
-    # MissingTranslationData exceptions are re-raised. When a MissingTranslationData
-    # was caught and the option :raise is not set the handler returns an error
-    # message string containing the key/scope.
-    def default_exception_handler(exception, locale, key, options)
-      return exception.message if MissingTranslationData === exception
-      raise exception
+    def translate_key(key, throw, raise, locale, backend, options)
+      result = catch(:exception) do
+        backend.translate(locale, key, options)
+      end
+
+      if result.is_a?(MissingTranslation)
+        handle_exception((throw && :throw || raise && :raise), result, locale, key, options)
+      else
+        result
+      end
     end
 
     # Any exceptions thrown in translate will be sent to the @@exception_handler
-    # which can be a Symbol, a Proc or any other Object.
+    # which can be a Symbol, a Proc or any other Object unless they're forced to
+    # be raised or thrown (MissingTranslation).
     #
     # If exception_handler is a Symbol then it will simply be sent to I18n as
     # a method call. A Proc will simply be called. In any other case the
@@ -279,44 +380,56 @@ module I18n
     #
     # Examples:
     #
-    #   I18n.exception_handler = :default_exception_handler             # this is the default
-    #   I18n.default_exception_handler(exception, locale, key, options) # will be called like this
+    #   I18n.exception_handler = :custom_exception_handler              # this is the default
+    #   I18n.custom_exception_handler(exception, locale, key, options)  # will be called like this
     #
     #   I18n.exception_handler = lambda { |*args| ... }                 # a lambda
     #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
     #
-    #  I18n.exception_handler = I18nExceptionHandler.new                # an object
-    #  I18n.exception_handler.call(exception, locale, key, options)     # will be called like this
-    def handle_exception(exception, locale, key, options)
-      case config.exception_handler
-      when Symbol
-        send(config.exception_handler, exception, locale, key, options)
+    #   I18n.exception_handler = I18nExceptionHandler.new               # an object
+    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
+    def handle_exception(handling, exception, locale, key, options)
+      case handling
+      when :raise
+        raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
+      when :throw
+        throw :exception, exception
       else
-        config.exception_handler.call(exception, locale, key, options)
+        case handler = options[:exception_handler] || config.exception_handler
+        when Symbol
+          send(handler, exception, locale, key, options)
+        else
+          handler.call(exception, locale, key, options)
+        end
       end
     end
 
-    # Deprecated. Will raise a warning in future versions and then finally be
-    # removed. Use I18n.normalize_keys instead.
-    def normalize_translation_keys(locale, key, scope, separator = nil)
-      normalize_keys(locale, key, scope, separator)
-    end
+    @@normalized_key_cache = I18n.new_double_nested_cache
 
     def normalize_key(key, separator)
-      normalized_key_cache[separator][key] ||=
+      @@normalized_key_cache[separator][key] ||=
         case key
         when Array
-          key.map { |k| normalize_key(k, separator) }.flatten
+          key.flat_map { |k| normalize_key(k, separator) }
         else
           keys = key.to_s.split(separator)
           keys.delete('')
-          keys.map!{ |k| k.to_sym }
+          keys.map! do |k|
+            case k
+            when /\A[-+]?([1-9]\d*|0)\z/ # integer
+              k.to_i
+            when 'true'
+              true
+            when 'false'
+              false
+            else
+              k.to_sym
+            end
+          end
           keys
         end
     end
-
-    def normalized_key_cache
-      @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
-    end
   end
+
+  extend Base
 end

metadata

@@ -1,105 +1,113 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: i18n
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 0
-  version: 0.4.0
+version: !ruby/object:Gem::Version
+  version: 1.14.4
 platform: ruby
-authors: 
+authors:
 - Sven Fuchs
 - Joshua Harvey
 - Matt Aimonetti
 - Stephan Soller
 - Saimon Moore
-autorequire: 
+- Ryan Bigg
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2010-05-27 00:00:00 +02:00
-default_executable: 
-dependencies: []
-
+date: 2024-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: New wave Internationalization support for Ruby.
 email: rails-i18n@googlegroups.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- MIT-LICENSE
+- README.md
 - lib/i18n.rb
 - lib/i18n/backend.rb
-- lib/i18n/backend/active_record.rb
-- lib/i18n/backend/active_record/missing.rb
-- lib/i18n/backend/active_record/store_procs.rb
-- lib/i18n/backend/active_record/translation.rb
 - lib/i18n/backend/base.rb
 - lib/i18n/backend/cache.rb
+- lib/i18n/backend/cache_file.rb
 - lib/i18n/backend/cascade.rb
 - lib/i18n/backend/chain.rb
-- lib/i18n/backend/cldr.rb
 - lib/i18n/backend/fallbacks.rb
 - lib/i18n/backend/flatten.rb
 - lib/i18n/backend/gettext.rb
 - lib/i18n/backend/interpolation_compiler.rb
 - lib/i18n/backend/key_value.rb
+- lib/i18n/backend/lazy_loadable.rb
 - lib/i18n/backend/memoize.rb
 - lib/i18n/backend/metadata.rb
 - lib/i18n/backend/pluralization.rb
 - lib/i18n/backend/simple.rb
 - lib/i18n/backend/transliterator.rb
 - lib/i18n/config.rb
-- lib/i18n/core_ext/hash.rb
-- lib/i18n/core_ext/string/interpolate.rb
 - lib/i18n/exceptions.rb
 - lib/i18n/gettext.rb
 - lib/i18n/gettext/helpers.rb
 - lib/i18n/gettext/po_parser.rb
+- lib/i18n/interpolate/ruby.rb
 - lib/i18n/locale.rb
 - lib/i18n/locale/fallbacks.rb
 - lib/i18n/locale/tag.rb
 - lib/i18n/locale/tag/parents.rb
 - lib/i18n/locale/tag/rfc4646.rb
 - lib/i18n/locale/tag/simple.rb
+- lib/i18n/middleware.rb
+- lib/i18n/tests.rb
+- lib/i18n/tests/basics.rb
+- lib/i18n/tests/defaults.rb
+- lib/i18n/tests/interpolation.rb
+- lib/i18n/tests/link.rb
+- lib/i18n/tests/localization.rb
+- lib/i18n/tests/localization/date.rb
+- lib/i18n/tests/localization/date_time.rb
+- lib/i18n/tests/localization/procs.rb
+- lib/i18n/tests/localization/time.rb
+- lib/i18n/tests/lookup.rb
+- lib/i18n/tests/pluralization.rb
+- lib/i18n/tests/procs.rb
+- lib/i18n/utils.rb
 - lib/i18n/version.rb
-- README.textile
-- MIT-LICENSE
-- CHANGELOG.textile
-has_rdoc: true
-homepage: http://github.com/svenfuchs/i18n
-licenses: []
-
-post_install_message: 
+homepage: https://github.com/ruby-i18n/i18n
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/ruby-i18n/i18n/issues
+  changelog_uri: https://github.com/ruby-i18n/i18n/releases
+  documentation_uri: https://guides.rubyonrails.org/i18n.html
+  source_code_uri: https://github.com/ruby-i18n/i18n
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 3
-      - 6
-      version: 1.3.6
+    - !ruby/object:Gem::Version
+      version: 1.3.5
 requirements: []
-
-rubyforge_project: "[none]"
-rubygems_version: 1.3.6
-signing_key: 
-specification_version: 3
+rubygems_version: 3.5.1
+signing_key:
+specification_version: 4
 summary: New wave Internationalization support for Ruby
 test_files: []
-