i18n 1.8.3

data/lib/i18n/interpolate/ruby.rb

@@ -0,0 +1,39 @@
+# heavily based on Masao Mutoh's gettext String interpolation extension
+# http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
+
+module I18n
+  DEFAULT_INTERPOLATION_PATTERNS = [
+    /%%/,
+    /%\{([\w|]+)\}/,                            # matches placeholders like "%{foo} or %{foo|word}"
+    /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
+  ].freeze
+  INTERPOLATION_PATTERN = Regexp.union(DEFAULT_INTERPOLATION_PATTERNS)
+  deprecate_constant :INTERPOLATION_PATTERN if method_defined? :INTERPOLATION_PATTERN
+
+  class << self
+    # Return String or raises MissingInterpolationArgument exception.
+    # Missing argument's logic is handled by I18n.config.missing_interpolation_argument_handler.
+    def interpolate(string, values)
+      raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ RESERVED_KEYS_PATTERN
+      raise ArgumentError.new('Interpolation values must be a Hash.') unless values.kind_of?(Hash)
+      interpolate_hash(string, values)
+    end
+
+    def interpolate_hash(string, values)
+      string.gsub(Regexp.union(config.interpolation_patterns)) do |match|
+        if match == '%%'
+          '%'
+        else
+          key = ($1 || $2 || match.tr("%{}", "")).to_sym
+          value = if values.key?(key)
+                    values[key]
+                  else
+                    config.missing_interpolation_argument_handler.call(key, values, string)
+                  end
+          value = value.call(values) if value.respond_to?(:call)
+          $3 ? sprintf("%#{$3}", value) : value
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module I18n
+  module Locale
+  autoload :Fallbacks, 'i18n/locale/fallbacks'
+  autoload :Tag,       'i18n/locale/tag'
+  end
+end

data/lib/i18n/locale/fallbacks.rb

@@ -0,0 +1,99 @@
+# Locale Fallbacks
+#
+# Extends the I18n module to hold a fallbacks instance which is set to an
+# instance of I18n::Locale::Fallbacks by default but can be swapped with a
+# different implementation.
+#
+# Locale fallbacks will compute a number of fallback locales for a given locale.
+# For example:
+#
+# <pre><code>
+# I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :en] </code></pre>
+#
+# Locale fallbacks always fall back to
+#
+#   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
+#   * the current default locales and all of their parents second
+#
+# The default locales are set to [I18n.default_locale] by default but can be
+# set to something else.
+#
+# One can additionally add any number of additional fallback locales manually.
+# These will be added before the default locales to the fallback chain. For
+# example:
+#
+#   # using the default locale as default fallback locale
+#
+#   I18n.default_locale = :"en-US"
+#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"de-AT" => :"de-DE")
+#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
+#
+#   # using a custom locale as default fallback locale
+#
+#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
+#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
+#   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
+#
+#   # mapping fallbacks to an existing instance
+#
+#   # people speaking Catalan also speak Spanish as spoken in Spain
+#   fallbacks = I18n.fallbacks
+#   fallbacks.map(:ca => :"es-ES")
+#   fallbacks[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
+#
+#   # people speaking Arabian as spoken in Palestine also speak Hebrew as spoken in Israel
+#   fallbacks.map(:"ar-PS" => :"he-IL")
+#   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
+#   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
+#
+#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
+#   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
+#   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
+
+module I18n
+  module Locale
+    class Fallbacks < Hash
+      def initialize(*mappings)
+        @map = {}
+        map(mappings.pop) if mappings.last.is_a?(Hash)
+        self.defaults = mappings.empty? ? [] : mappings
+      end
+
+      def defaults=(defaults)
+        @defaults = defaults.flat_map { |default| compute(default, false) }
+      end
+      attr_reader :defaults
+
+      def [](locale)
+        raise InvalidLocale.new(locale) if locale.nil?
+        raise Disabled.new('fallback#[]') if locale == false
+        locale = locale.to_sym
+        super || store(locale, compute(locale))
+      end
+
+      def map(mappings)
+        mappings.each do |from, to|
+          from, to = from.to_sym, Array(to)
+          to.each do |_to|
+            @map[from] ||= []
+            @map[from] << _to.to_sym
+          end
+        end
+      end
+
+      protected
+
+      def compute(tags, include_defaults = true, exclude = [])
+        result = Array(tags).flat_map do |tag|
+          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym } - exclude
+          tags.each { |_tag| tags += compute(@map[_tag], false, exclude + tags) if @map[_tag] }
+          tags
+        end
+        result.push(*defaults) if include_defaults
+        result.uniq!
+        result.compact!
+        result
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module I18n
+  module Locale
+    module Tag
+      autoload :Parents, 'i18n/locale/tag/parents'
+      autoload :Rfc4646, 'i18n/locale/tag/rfc4646'
+      autoload :Simple,  'i18n/locale/tag/simple'
+
+      class << self
+        # Returns the current locale tag implementation. Defaults to +I18n::Locale::Tag::Simple+.
+        def implementation
+          @@implementation ||= Simple
+        end
+
+        # Sets the current locale tag implementation. Use this to set a different locale tag implementation.
+        def implementation=(implementation)
+          @@implementation = implementation
+        end
+
+        # Factory method for locale tags. Delegates to the current locale tag implementation.
+        def tag(tag)
+          implementation.tag(tag)
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/parents.rb

@@ -0,0 +1,24 @@
+module I18n
+  module Locale
+    module Tag
+      module Parents
+        def parent
+          @parent ||=
+            begin
+              segs = to_a
+              segs.compact!
+              segs.length > 1 ? self.class.tag(*segs[0..(segs.length - 2)].join('-')) : nil
+            end
+        end
+
+        def self_and_parents
+          @self_and_parents ||= [self].concat parents
+        end
+
+        def parents
+          @parents ||= parent ? [parent].concat(parent.parents) : []
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/rfc4646.rb

@@ -0,0 +1,74 @@
+# RFC 4646/47 compliant Locale tag implementation that parses locale tags to
+# subtags such as language, script, region, variant etc.
+#
+# For more information see by http://en.wikipedia.org/wiki/IETF_language_tag
+#
+# Rfc4646::Parser does not implement grandfathered tags.
+
+module I18n
+  module Locale
+    module Tag
+      RFC4646_SUBTAGS = [ :language, :script, :region, :variant, :extension, :privateuse, :grandfathered ]
+      RFC4646_FORMATS = { :language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase }
+
+      class Rfc4646 < Struct.new(*RFC4646_SUBTAGS)
+        class << self
+          # Parses the given tag and returns a Tag instance if it is valid.
+          # Returns false if the given tag is not valid according to RFC 4646.
+          def tag(tag)
+            matches = parser.match(tag)
+            new(*matches) if matches
+          end
+
+          def parser
+            @@parser ||= Rfc4646::Parser
+          end
+
+          def parser=(parser)
+            @@parser = parser
+          end
+        end
+
+        include Parents
+
+        RFC4646_FORMATS.each do |name, format|
+          define_method(name) { self[name].send(format) unless self[name].nil? }
+        end
+
+        def to_sym
+          to_s.to_sym
+        end
+
+        def to_s
+          @tag ||= to_a.compact.join("-")
+        end
+
+        def to_a
+          members.collect { |attr| self.send(attr) }
+        end
+
+        module Parser
+          PATTERN = %r{\A(?:
+            ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
+            (?:-([a-z]{4}))?                                        # script
+            (?:-([a-z]{2}|\d{3}))?                                  # region
+            (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
+            (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
+            (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
+            (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
+            /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
+            )\z}xi
+
+          class << self
+            def match(tag)
+              c = PATTERN.match(tag.to_s).captures
+              c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
+            rescue
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/simple.rb

@@ -0,0 +1,39 @@
+# Simple Locale tag implementation that computes subtags by simply splitting
+# the locale tag at '-' occurences.
+module I18n
+  module Locale
+    module Tag
+      class Simple
+        class << self
+          def tag(tag)
+            new(tag)
+          end
+        end
+
+        include Parents
+
+        attr_reader :tag
+
+        def initialize(*tag)
+          @tag = tag.join('-').to_sym
+        end
+
+        def subtags
+          @subtags = tag.to_s.split('-').map!(&:to_s)
+        end
+
+        def to_sym
+          tag
+        end
+
+        def to_s
+          tag.to_s
+        end
+
+        def to_a
+          subtags
+        end
+      end
+    end
+  end
+end

data/lib/i18n/middleware.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module I18n
+  class Middleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Thread.current[:i18n_config] = I18n::Config.new
+    end
+
+  end
+end

data/lib/i18n/tests.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module I18n
+  module Tests
+    autoload :Basics,        'i18n/tests/basics'
+    autoload :Defaults,      'i18n/tests/defaults'
+    autoload :Interpolation, 'i18n/tests/interpolation'
+    autoload :Link,          'i18n/tests/link'
+    autoload :Localization,  'i18n/tests/localization'
+    autoload :Lookup,        'i18n/tests/lookup'
+    autoload :Pluralization, 'i18n/tests/pluralization'
+    autoload :Procs,         'i18n/tests/procs'
+  end
+end

data/lib/i18n/tests/basics.rb

@@ -0,0 +1,60 @@
+module I18n
+  module Tests
+    module Basics
+      def teardown
+        I18n.available_locales = nil
+      end
+
+      test "available_locales returns the locales stored to the backend by default" do
+        I18n.backend.store_translations('de', :foo => 'bar')
+        I18n.backend.store_translations('en', :foo => 'foo')
+
+        assert I18n.available_locales.include?(:de)
+        assert I18n.available_locales.include?(:en)
+      end
+
+      test "available_locales can be set to something else independently from the actual locale data" do
+        I18n.backend.store_translations('de', :foo => 'bar')
+        I18n.backend.store_translations('en', :foo => 'foo')
+
+        I18n.available_locales = :foo
+        assert_equal [:foo], I18n.available_locales
+
+        I18n.available_locales = [:foo, 'bar']
+        assert_equal [:foo, :bar], I18n.available_locales
+
+        I18n.available_locales = nil
+        assert I18n.available_locales.include?(:de)
+        assert I18n.available_locales.include?(:en)
+      end
+
+      test "available_locales memoizes when set explicitely" do
+        I18n.backend.expects(:available_locales).never
+        I18n.available_locales = [:foo]
+        I18n.backend.store_translations('de', :bar => 'baz')
+        I18n.reload!
+        assert_equal [:foo], I18n.available_locales
+      end
+
+      test "available_locales delegates to the backend when not set explicitely" do
+        original_available_locales_value = I18n.backend.available_locales
+        I18n.backend.expects(:available_locales).returns(original_available_locales_value).twice
+        assert_equal I18n.backend.available_locales, I18n.available_locales
+      end
+
+      test "exists? is implemented by the backend" do
+        I18n.backend.store_translations(:foo, :bar => 'baz')
+        assert I18n.exists?(:bar, :foo)
+      end
+
+      test "storing a nil value as a translation removes it from the available locale data" do
+        I18n.backend.store_translations(:en, :to_be_deleted => 'bar')
+        assert_equal 'bar', I18n.t(:to_be_deleted, :default => 'baz')
+
+        I18n.cache_store.clear if I18n.respond_to?(:cache_store) && I18n.cache_store
+        I18n.backend.store_translations(:en, :to_be_deleted => nil)
+        assert_equal 'baz', I18n.t(:to_be_deleted, :default => 'baz')
+      end
+    end
+  end
+end

data/lib/i18n/tests/defaults.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module I18n
+  module Tests
+    module Defaults
+      def setup
+        super
+        I18n.backend.store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+      end
+
+      test "defaults: given nil as a key it returns the given default" do
+        assert_equal 'default', I18n.t(nil, :default => 'default')
+      end
+
+      test "defaults: given a symbol as a default it translates the symbol" do
+        assert_equal 'bar', I18n.t(nil, :default => :'foo.bar')
+      end
+
+      test "defaults: given a symbol as a default and a scope it stays inside the scope when looking up the symbol" do
+        assert_equal 'bar', I18n.t(:missing, :default => :bar, :scope => :foo)
+      end
+
+      test "defaults: given an array as a default it returns the first match" do
+        assert_equal 'bar', I18n.t(:does_not_exist, :default => [:does_not_exist_2, :'foo.bar'])
+      end
+
+      test "defaults: given an array as a default with false it returns false" do
+        assert_equal false, I18n.t(:does_not_exist, :default => [false])
+      end
+
+      test "defaults: given false it returns false" do
+        assert_equal false, I18n.t(:does_not_exist, :default => false)
+      end
+
+      test "defaults: given nil it returns nil" do
+        assert_nil I18n.t(:does_not_exist, :default => nil)
+      end
+
+      test "defaults: given an array of missing keys it raises a MissingTranslationData exception" do
+        assert_raise I18n::MissingTranslationData do
+          I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
+        end
+      end
+
+      test "defaults: using a custom scope separator" do
+        # data must have been stored using the custom separator when using the ActiveRecord backend
+        I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
+        assert_equal 'bar', I18n.t(nil, :default => :'foo|bar', :separator => '|')
+      end
+    end
+  end
+end