r18n-core 3.1.1 → 5.0.1

data/{locales → lib/r18n-core/locales}/zh.rb

@@ -7,21 +7,24 @@ module R18n
       set(
         title: '中文',
 
+        sublocales: %w[zh-CN zh-TW],
+
         wday_names: %w[星期日 星期一 星期二 星期三 星期四 星期五 星期六],
         wday_abbrs: %w[周日 周一 周二 周三 周四 周五 周六],
 
-        month_names: %w[一月 二月 三月 四月 五月 六月 七月 八月 九月 十月 十一月
-                        十二月],
+        month_names: %w[
+          一月 二月 三月 四月 五月 六月 七月 八月 九月 十月 十一月 十二月
+        ],
 
         date_format: '%Y年%m月%d日',
         full_format: '%m月%d日',
         year_format: '%Y年_',
 
         number_decimal: '.',
-        number_group:   ' '
+        number_group: ' '
       )
 
-      def pluralize(_n)
+      def pluralize(_number)
         'n'
       end
     end

data/lib/r18n-core/translated.rb

@@ -22,9 +22,9 @@ module R18n
   # R18n plugin with out-of-box i18n support.
   #
   # Module can add proxy-methods to find translation in object methods. For
-  # example, if you class have +title_en+ and +title_ru+ methods, you can add
-  # proxy-method +title+, which will use +title_ru+ for Russian users and
-  # +title_en+ for English:
+  # example, if you class have `title_en` and `title_ru` methods, you can add
+  # proxy-method `title`, which will use `title_ru` for Russian users and
+  # `title_en` for English:
   #
   #   class Product
   #     include DataMapper::Resource
@@ -58,21 +58,21 @@ module R18n
   # Proxy-method support all funtion from I18n: global and type filters,
   # pluralization, variables. It also return TranslatedString or Untranslated.
   #
-  # By default it use <tt>R18n.get</tt> to get I18n object (so, you must set it
-  # before use model), but you can overwrite object +r18n+ method to change
+  # By default it use `R18n.get` to get I18n object (so, you must set it
+  # before use model), but you can overwrite object `r18n` method to change
   # default logic.
   #
   # See R18n::Translated::Base for class method documentation.
   #
   # == Options
   # You can set option for proxy-method as Hash with keys;
-  # * +type+ – YAML type for filters. For example, "markdown" or "escape_html".
-  # * +methods+ – manual method map as Hash of locale codes to method names.
-  # * +no_params+ – set it to true if you proxy-method must send it parameters
+  # * `type` – YAML type for filters. For example, "markdown" or "escape_html".
+  # * `methods` – manual method map as Hash of locale codes to method names.
+  # * `no_params` – set it to true if you proxy-method must send it parameters
   #   only to filters.
-  # * +no_write+ – set it to true if you don’t want to create proxy-setters.
+  # * `no_write` – set it to true if you don't want to create proxy-setters.
   #
-  # Method +translation+ will be more useful for options:
+  # Method `translation` will be more useful for options:
   #
   #   translation :title, methods: { ru: :russian, en: :english}
   module Translated
@@ -81,54 +81,54 @@ module R18n
         base.send :extend, Base
         base.instance_variable_set '@unlocalized_getters', {}
         base.instance_variable_set '@unlocalized_setters', {}
-        base.instance_variable_set '@translation_types', {}
       end
     end
 
     # Access to I18n object. By default return global I18n object from
-    # <tt>R18n.get</tt>.
+    # `R18n.get`.
     def r18n
       R18n.get
     end
 
     # Module with class methods, which be added after R18n::Translated include.
     module Base
-      # Hash of translation method names to it type for filters.
-      attr_reader :translation_types
+      # `Hash` of translation method names to it type for filters.
+      def translation_types
+        @translation_types ||= {}
+      end
 
-      # Add several proxy +methods+. See R18n::Translated for description.
-      # It’s more compact, that +translation+.
+      # Add several proxy methods. See `R18n::Translated` for description.
+      # It's more compact, that `translation`.
       #
       #   translations :title, :keywords, [:desciption, { type: 'markdown' }]
-      def translations(*methods)
-        methods.each do |method|
-          translation(*method)
-        end
+      def translations(*names)
+        names.each { |name| translation(*name) }
       end
 
-      # Add proxy-method +name+. See R18n::Translated for description.
-      # It’s more useful to set options.
+      # Add proxy-method `name`. See `R18n::Translated` for description.
+      # It's more useful to set options.
       #
-      #   translation :desciption, type: 'markdown'
+      #   translation :description, type: 'markdown'
       def translation(name, options = {})
         if options[:methods]
-          @unlocalized_getters[name] = R18n::Utils
-            .hash_map(options[:methods]) { |l, i| [l.to_s, i.to_s] }
+          @unlocalized_getters[name] =
+            options[:methods].map { |l, i| [l.to_s, i.to_s] }.to_h
           unless options[:no_write]
-            @unlocalized_setters[name] = R18n::Utils
-              .hash_map(options[:methods]) { |l, i| [l.to_s, i.to_s + '='] }
+            @unlocalized_setters[name] =
+              options[:methods].map { |l, i| [l.to_s, "#{i}="] }.to_h
           end
         end
 
-        @translation_types[name] = options[:type]
+        translation_types[name] = options[:type]
 
         define_method name do |*params|
           unlocalized = self.class.unlocalized_getters(name)
           result = nil
 
           r18n.locales.each do |locale|
-            code = locale.code
+            code = locale.downcased_code
             next unless unlocalized.key? code
+
             result = send(
               unlocalized[code], *(params unless options[:no_params])
             )
@@ -160,22 +160,23 @@ module R18n
           r18n.locales.each do |locale|
             code = locale.code
             next unless unlocalized.key? code
+
             return send unlocalized[code], *params
           end
         end
       end
 
-      # Return array of methods to find +unlocalized_getters+ or
-      # +unlocalized_setters+.
+      # Return array of methods to find `unlocalized_getters` or
+      # `unlocalized_setters`.
       def unlocalized_methods
         instance_methods
       end
 
-      # Return Hash of locale code to getter method for proxy +method+. If you
-      # didn’t set map in +translation+ option +methods+, it will be detect
+      # Return `Hash` of locale code to getter method for proxy `method`. If you
+      # didn't set map in `translation` option `methods`, it will be detect
       # automatically.
       def unlocalized_getters(method)
-        matcher = Regexp.new('^' + Regexp.escape(method.to_s) + '_(\w+)$')
+        matcher = Regexp.new("^#{Regexp.escape(method.to_s)}_(\\w+)$")
         unless @unlocalized_getters.key? method
           @unlocalized_getters[method] = {}
           unlocalized_methods.select { |i| i =~ matcher }.each do |i|
@@ -185,11 +186,11 @@ module R18n
         @unlocalized_getters[method]
       end
 
-      # Return Hash of locale code to setter method for proxy +method+. If you
-      # didn’t set map in +translation+ option +methods+, it will be detect
+      # Return `Hash` of locale code to setter method for proxy `method`. If you
+      # didn't set map in `translation` option `methods`, it will be detect
       # automatically.
       def unlocalized_setters(method)
-        matcher = Regexp.new('^' + Regexp.escape(method.to_s) + '_(\w+)=$')
+        matcher = Regexp.new("^#{Regexp.escape(method.to_s)}_(\\w+)=$")
         unless @unlocalized_setters.key? method
           @unlocalized_setters[method] = {}
           unlocalized_methods.select { |i| i =~ matcher }.each do |i|

data/lib/r18n-core/translated_string.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'untranslated'
+
 # Translation string for i18n support.
 #
 # Copyright (C) 2008 Andrey “A.I.” Sitnik <andrey@sitnik.ru>
@@ -26,8 +28,8 @@ module R18n
     # Path for this translation.
     attr_reader :path
 
-    # Returns a new string object containing a copy of +str+, which translated
-    # for +path+ to +locale+
+    # Returns a new string object containing a copy of `str`, which translated
+    # for `path` to `locale`
     def initialize(value, locale, path, filters = nil)
       super(value.to_s)
       @filters = filters
@@ -45,14 +47,9 @@ module R18n
       true
     end
 
-    # Return true if `html_safe` method is defined, otherwise false.
-    def html_safe?
-      respond_to? :html_safe
-    end
-
     # Override to_s to make string html safe if `html_safe` method is defined.
     def to_s
-      if respond_to? :html_safe
+      if respond_to?(:html_safe)
         super.html_safe
       else
         String.new(super)
@@ -82,9 +79,23 @@ module R18n
       Untranslated.new(translated, key, @locale, @filters)
     end
 
+    NON_KEYS_METHODS = [
+      *Untranslated::NON_KEYS_METHODS,
+      :html_safe,
+      :to_text
+    ].freeze
+
     # Return untranslated, when user try to go deeper in translation.
     def method_missing(name, *_params)
+      return super if NON_KEYS_METHODS.include?(name)
+
       get_untranslated(name.to_s)
     end
+
+    def respond_to_missing?(name, *args)
+      return super if NON_KEYS_METHODS.include?(name)
+
+      true
+    end
   end
 end

data/lib/r18n-core/translation.rb

@@ -23,16 +23,16 @@ module R18n
 
   # Translation is container of translated messages.
   #
-  # You can load several locales and if translation willn’t be found in first,
+  # You can load several locales and if translation willn't be found in first,
   # r18n will be search it in next. Use R18n::I18n.new to load translations.
   #
   # To get translation value use method with same name. If translation name
-  # is equal with Object methods (+new+, +to_s+, +methods+) use
-  # <tt>[name, params…]</tt>. If you want to get pluralizable value, just set
+  # is equal with Object methods (`new`, `to_s`, `methods`) use
+  # `[name, params…]`. If you want to get pluralizable value, just set
   # value for pluralization in first argument of method. See samples below.
   #
-  # Translated strings will have +locale+ methods, which return Locale or
-  # UnsupportedLocale, if locale file isn’t exists.
+  # Translated strings will have `locale` methods, which return Locale or
+  # UnsupportedLocale, if locale file isn't exists.
   #
   # == Examples
   # translations/ru.yml
@@ -51,7 +51,7 @@ module R18n
   #   comments: !!pl
   #     0: no comments
   #     1: one comment
-  #     n: %1 comments
+  #     n: '%1 comments'
   #
   # example.rb
   #
@@ -68,7 +68,7 @@ module R18n
   #   i18n.comments(10)           #=> "10 comments"
   class Translation
     # This is internal a constructor. To load translation use
-    # <tt>R18n::I18n.new(locales, translations_dir)</tt>.
+    # `R18n::I18n.new(locales, translations_dir)`.
     def initialize(locale, path = '', options = {})
       @data    = {}
       @locale  = locale
@@ -78,8 +78,8 @@ module R18n
       merge! options[:translations], options[:locale] if options[:translations]
     end
 
-    # Add another hash with +translations+ for some +locale+. Current data is
-    # more priority, that new one in +translations+.
+    # Add another hash with `translations` for some `locale`. Current data is
+    # more priority, that new one in `translations`.
     def merge!(translations, locale)
       (translations || {}).each_pair do |name, value|
         if !@data.key?(name)
@@ -123,28 +123,27 @@ module R18n
 
     # Return current translation keys.
     #
-    # Deprecated. Use <tt>to_hash.keys</tt>.
+    # Deprecated. Use `to_hash.keys`.
     def translation_keys
       to_hash.keys
     end
 
     # Return hash of current translation node.
     def to_hash
-      Utils.hash_map(@data) do |key, value|
-        value = value.to_hash if value.is_a? Translation
-        [key, value]
+      @data.transform_values do |value|
+        value.is_a?(Translation) ? value.to_hash : value
       end
     end
 
-    # Return +default+.
+    # Return `default`.
     def |(other)
       other
     end
 
-    # Return translation with special +name+.
+    # Return translation with special `name`.
     #
-    # Translation can contain variable part. Just set is as <tt>%1</tt>,
-    # <tt>%2</tt>, etc in translations file and set values in next +params+.
+    # Translation can contain variable part. Just set is as `%1`,
+    # `%2`, etc in translations file and set values in next `params`.
     def [](name, *params)
       unless [String, Integer, TrueClass, FalseClass]
           .any? { |klass| name.is_a?(klass) }
@@ -166,10 +165,16 @@ module R18n
     end
     alias method_missing []
 
-    # Return translation located at +names+.
+    # Return translation located at `keys`.
     # @see Hash#dig
     def dig(*keys)
-      keys.reduce(self) { |result, key| result[key] }
+      keys.reduce(self, :[])
+    end
+
+    # I think we don't need in the Ruby core method,
+    # but it can be handy as a key
+    def itself
+      self[__method__]
     end
   end
 end

data/lib/r18n-core/unsupported_locale.rb

@@ -24,10 +24,13 @@ module R18n
     # Locale, to get data and pluralization for unsupported locale.
     attr_accessor :base
 
-    # Create object for unsupported locale with +code+ and load other locale
-    # data from +base+ locale.
+    attr_reader :code, :downcased_code
+
+    # Create object for unsupported locale with `code` and load other locale
+    # data from `base` locale.
     def initialize(code, _base = nil)
       @code = code
+      @downcased_code = @code.downcase.tr('-', '_').freeze
       @base = Locale.load(I18n.default) if @code != I18n.default
     end
 
@@ -41,9 +44,6 @@ module R18n
       "Unsupported locale #{@code}"
     end
 
-    # Locale RFC 3066 code.
-    attr_reader :code
-
     # Locale code as title.
     def title
       @code
@@ -56,7 +56,15 @@ module R18n
 
     #  Proxy to default locale object.
     def method_missing(name, *params)
-      @base.send(name, *params)
+      return super unless @base.respond_to? name
+
+      @base.public_send(name, *params)
+    end
+
+    def respond_to_missing?(name, *args)
+      return super unless @base
+
+      @base.send __method__, name, *args
     end
   end
 end

data/lib/r18n-core/untranslated.rb

@@ -18,7 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module R18n
-  # Return if translation isn’t exists. Unlike nil, it didn’t raise error when
+  # Return if translation isn't exists. Unlike nil, it didn't raise error when
   # you try to access for subtranslations.
   #
   # You can set format to print untranslated string by filters. For example:
@@ -37,7 +37,7 @@ module R18n
   #
   #   R18n::Filters.add(R18n::Untranslated, :hide_untranslated) { '' }
   class Untranslated
-    # Path, that isn’t in translation.
+    # Path, that isn't in translation.
     attr_reader :untranslated_path
 
     # Path, that exists in translation.
@@ -73,18 +73,33 @@ module R18n
       new arr[1], arr[2], R18n.locale(arr[0]), GlobalFilterList.instance
     end
 
+    NON_KEYS_METHODS = %i[
+      to_ary
+      to_hash
+      marshal_dump
+      marshal_load
+    ].freeze
+
     def method_missing(name, *_params)
       # It is need to fix some hack in specs
-      if name == :to_ary
-        raise NoMethodError, "undefined method `to_ary' for #{self}"
-      end
+      return super if NON_KEYS_METHODS.include?(name)
 
       self[name]
     end
 
+    def respond_to_missing?(name, *args)
+      return super if NON_KEYS_METHODS.include?(name)
+
+      true
+    end
+
     def [](*params)
-      Untranslated.new(translated_path, "#{@untranslated_path}.#{params.first}",
-                       @locale, @filters)
+      Untranslated.new(
+        translated_path,
+        "#{@untranslated_path}.#{params.first}",
+        @locale,
+        @filters
+      )
     end
 
     def |(other)
@@ -106,6 +121,7 @@ module R18n
       return false unless locale            == other.locale
       return false unless translated_path   == other.translated_path
       return false unless untranslated_path == other.untranslated_path
+
       true
     end
   end