r18n-core 3.1.1 → 5.0.1

data/lib/r18n-core/helpers.rb

@@ -32,12 +32,12 @@ module R18n
     end
     alias i18n r18n
 
-    # Translate message. Alias for <tt>r18n.t</tt>.
+    # Translate message. Alias for `r18n.t`.
     def t(*params)
       R18n.get.t(*params)
     end
 
-    # Localize object. Alias for <tt>r18n.l</tt>.
+    # Localize object. Alias for `r18n.l`.
     def l(*params)
       R18n.get.l(*params)
     end

data/lib/r18n-core/i18n.rb

@@ -24,14 +24,14 @@ module R18n
   # Locale classes and create pretty way to use it.
   #
   # To get translation you can use same with Translation way – use method with
-  # translation’s name or <tt>[name]</tt> method. Translations will be also
-  # loaded for default locale, +sublocales+ from first in +locales+ and general
-  # languages for dialects (it will load +fr+ for +fr_CA+ too).
+  # translation's name or `[name]` method. Translations will be also
+  # loaded for default locale, `sublocales` from first in `locales` and general
+  # languages for dialects (it will load `fr` for `fr_CA` too).
   #
   # Translations will loaded by loader object, which must have 2 methods:
-  # * <tt>available</tt> – return array of locales of available translations;
-  # * <tt>load(locale)</tt> – return Hash of translation.
-  # If you will use default loader (+R18n.default_loader+) you can pass to I18n
+  # * `available` – return array of locales of available translations;
+  # * `load(locale)` – return Hash of translation.
+  # If you will use default loader (`R18n.default_loader`) you can pass to I18n
   # only constructor argument for loader:
   #
   #   R18n::I18n.new('en', R18n::Loader::YAML.new('dir/with/translations'))
@@ -41,16 +41,16 @@ module R18n
   #   R18n::I18n.new('en', 'dir/with/translations')
   #
   # In translation file you can use strings, numbers, floats (any YAML types)
-  # and pluralizable values (<tt>!!pl</tt>). You can use params in string
-  # values, which you can replace in program. Just write <tt>%1</tt>,
-  # <tt>%2</tt>, etc and set it values as method arguments, when you will be get
+  # and pluralizable values (`!!pl`). You can use params in string
+  # values, which you can replace in program. Just write `%1`,
+  # `%2`, etc and set it values as method arguments, when you will be get
   # value.
   #
   # You can use filters for some YAML type or for all strings. See R18n::Filters
   # for details.
   #
-  # R18n contain translations for common words (such as “OK”, “Cancel”, etc)
-  # for most supported locales. See <tt>base/</tt> dir.
+  # R18n contain translations for common words (such as "OK", "Cancel", etc)
+  # for most supported locales. See `base/` dir.
   #
   # == Usage
   # translations/ru.yml
@@ -83,43 +83,37 @@ module R18n
   #   i18n.ok     #=> "OK"
   #   i18n.cancel #=> "Cancel"
   class I18n
-    @@default = 'en'
+    @default = 'en'
 
-    # Set default locale code to use when any user locales willn't be founded.
-    # It should has all translations and locale file.
-    def self.default=(locale)
-      @@default = locale
-    end
+    class << self
+      attr_accessor :default
 
-    # Get default locale code
-    def self.default
-      @@default
-    end
+      # Parse HTTP_ACCEPT_LANGUAGE and return array of user locales
+      def parse_http(str)
+        return [] if str.nil?
 
-    # Parse HTTP_ACCEPT_LANGUAGE and return array of user locales
-    def self.parse_http(str)
-      return [] if str.nil?
-      locales = str.split(',')
-      locales.map! do |locale|
-        locale = locale.split ';q='
-        if locale.size == 1
-          [locale[0], 1.0]
-        else
-          [locale[0], locale[1].to_f]
+        locales = str.split(',')
+        locales.map! do |locale|
+          locale = locale.split ';q='
+          if locale.size == 1
+            [locale[0], 1.0]
+          else
+            [locale[0], locale[1].to_f]
+          end
         end
+        locales.sort! { |a, b| b[1] <=> a[1] }
+        locales.map! { |i| i[0] }
       end
-      locales.sort! { |a, b| b[1] <=> a[1] }
-      locales.map! { |i| i[0] }
-    end
 
-    # Load default loader for elements in +places+ with only constructor
-    # argument.
-    def self.convert_places(places)
-      Array(places).map! do |loader|
-        if loader.respond_to?(:available) && loader.respond_to?(:load)
-          loader
-        else
-          R18n.default_loader.new(loader)
+      # Load default loader for elements in `places` with only constructor
+      # argument.
+      def convert_places(places)
+        Array(places).map! do |loader|
+          if loader.respond_to?(:available) && loader.respond_to?(:load)
+            loader
+          else
+            R18n.default_loader.new(loader)
+          end
         end
       end
     end
@@ -133,28 +127,29 @@ module R18n
     # First locale with locale file
     attr_reader :locale
 
-    # Create i18n for +locales+ with translations from +translation_places+ and
+    # Create i18n for `locales` with translations from `translation_places` and
     # locales data. Translations will be also loaded for default locale,
-    # +sublocales+ from first in +locales+ and general languages for dialects
-    # (it will load +fr+ for +fr_CA+ too).
+    # `sublocales` from first in `locales` and general languages for dialects
+    # (it will load `fr` for `fr_CA` too).
     #
-    # +Locales+ must be a locale code (RFC 3066) or array, ordered by priority.
-    # +Translation_places+ must be a string with path or array.
+    # `locales` must be a locale code (RFC 3066) or array, ordered by priority.
+    # `translation_places` must be a string with path or array.
     def initialize(locales, translation_places = nil, opts = {})
       locales = Array(locales)
 
-      if !locales.empty? && Locale.exists?(locales.first)
-        locales += Locale.load(locales.first).sublocales
-      end
-      locales << @@default
       locales.each_with_index do |locale, i|
-        if locale =~ /[^_-]+[_-]/
-          locales.insert(i + 1, locale.match(/([^_-]+)[_-]/)[1])
-        end
+        locales.insert(i + 1, locale.match(/([^_-]+)[_-]/)[1]) if locale.match?(/[^_-]+[_-]/)
+        locales.insert(i + 1, *(Locale.load(locale).sublocales - locales)) if Locale.exists?(locale)
       end
+      locales << self.class.default
       locales.map! { |i| i.to_s.downcase }.uniq!
       @locales_codes = locales
-      @locales = locales.map { |i| Locale.load(i) }
+      @locales = locales.each_with_object([]) do |locale, result|
+        locale = Locale.load(locale)
+        next unless locale
+
+        result << locale
+      end
 
       if translation_places
         @original_places = translation_places
@@ -190,16 +185,14 @@ module R18n
       @available_codes ||= @translation_places
         .inject([]) { |all, i| all + i.available }
         .uniq.map { |i| i.code.downcase }
-      (@locales_codes & @available_codes).join(',') + '@' +
-        @filters.hash.to_s + '_' +
-        R18n.default_loader.hash.to_s + '_' +
-        @translation_places.hash.to_s + '_' +
+      "#{(@locales_codes & @available_codes).join(',')}@" \
+        "#{@filters.hash}_#{R18n.default_loader.hash}_#{@translation_places.hash}_" +
         R18n.extension_places.hash.to_s
     end
 
     # Reload translations.
     def reload!
-      @available = @available_codes = nil
+      @available_locales = @available_codes = nil
       @translation_places = self.class.convert_places(@original_places)
 
       available_in_places = @translation_places.map { |i| [i, i.available] }
@@ -207,8 +200,6 @@ module R18n
         R18n.extension_places.map { |i| [i, i.available] }
 
       unless defined? @locale
-        # It's array!
-        # rubocop:disable Perfomance/HashEachMethods
         available_in_places.each do |_place, available|
           @locales.each do |locale|
             if available.include? locale
@@ -218,7 +209,6 @@ module R18n
           end
           break if defined? @locale
         end
-        # rubocop:enable Perfomance/HashEachMethods
       end
       @locale ||= @locales.first
       unless @locale.supported?
@@ -244,8 +234,10 @@ module R18n
         next unless loaded
 
         available_in_extensions.each do |extension, available|
-          if available.include? locale
-            @translation.merge! extension.load(locale), locale
+          @translation.merge! extension.load(locale), locale if available.include? locale
+
+          if available.include? locale.parent
+            @translation.merge! extension.load(locale.parent), locale.parent
           end
         end
       end
@@ -253,26 +245,26 @@ module R18n
       R18n.cache[translation_cache_key] = [@locale, @translation]
     end
 
-    # Return Array of locales with available translations.
+    # Return `Array` of locales with available translations.
     def available_locales
-      @available ||= R18n.available_locales(@translation_places)
+      @available_locales ||= R18n.available_locales(@translation_places)
     end
 
-    # Convert +object+ to String, according to the rules of the current locale.
-    # It support Integer, Float, Time, Date and DateTime.
+    # Convert `object` to `String`, according to the rules of the current
+    # locale. It support `Integer`, `Float`, `Time`, `Date` and `DateTime`.
     #
-    # For time classes you can set +format+ in standard +strftime+ form,
-    # <tt>:full</tt> (“01 Jule, 2009”), <tt>:human</tt> (“yesterday”),
-    # <tt>:standard</tt> (“07/01/09”) or <tt>:month</tt> for standalone month
-    # name. Default format is <tt>:standard</tt>.
+    # For time classes you can set `format` in standard `strftime` form,
+    # `:full` ("01 Jule, 2009"), `:human` ("yesterday"),
+    # `:standard` ("07/01/09") or `:month` for standalone month
+    # name. Default format is `:standard`.
     #
     #   i18n.l -12000.5         #=> "−12,000.5"
     #   i18n.l Time.now         #=> "07/01/09 12:59"
     #   i18n.l Time.now.to_date #=> "07/01/09"
     #   i18n.l Time.now, :human #=> "now"
     #   i18n.l Time.now, :full  #=> "Jule 1st, 2009 12:59"
-    def localize(object, format = nil, *params)
-      locale.localize(object, format, self, *params)
+    def localize(object, format = nil, **kwargs)
+      locale.localize(object, format, i18n: self, **kwargs)
     end
     alias l localize
 
@@ -281,10 +273,10 @@ module R18n
       @translation
     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)
       @translation[name, *params]
     end

data/lib/r18n-core/locale.rb

@@ -23,14 +23,14 @@ require 'bigdecimal'
 module R18n
   # Information about locale (language, country and other special variant
   # preferences). Locale was named by RFC 3066. For example, locale for French
-  # speaking people in Canada will be +fr-CA+.
+  # speaking people in Canada will be `fr-CA`.
   #
-  # Locale classes are placed in <tt>R18n::Locales</tt> module and storage
-  # install <tt>locales/</tt> dir.
+  # Locale classes are placed in `R18n::Locales` module and storage
+  # install `locales/` dir.
   #
-  # Each locale has +sublocales+ – often known languages for people from this
+  # Each locale has `sublocales` – often known languages for people from this
   # locale. For example, many Belorussians know Russian and English. If there
-  # is’t translation for Belorussian, it will be searched in Russian and next in
+  # is't translation for Belorussian, it will be searched in Russian and next in
   # English translations.
   #
   # == Usage
@@ -44,78 +44,97 @@ module R18n
   #
   # == Available data
   #
-  # * +code+ – locale RFC 3066 code;
-  # * +title+ – locale name on it language;
-  # * +ltr?+ – true on left-to-right writing direction, false for Arabic and
+  # * `code` – locale RFC 3066 code;
+  # * `title` – locale name on it language;
+  # * `ltr?` – true on left-to-right writing direction, false for Arabic and
   #   Hebrew);
-  # * +sublocales+ – often known languages for people from this locale;
-  # * +week_start+ – does week start from +:monday+ or +:sunday+.
+  # * `sublocales` – often known languages for people from this locale;
+  # * `week_start` – does week start from `:monday` or `:sunday`.
   #
   # You can see more available data about locale in samples in
-  # <tt>locales/</tt> dir.
+  # `locales/` dir.
   class Locale
-    LOCALES_DIR = File.join(__dir__, '..', '..', 'locales')
+    @loaded = {}
 
-    @@loaded = {}
+    class << self
+      # Is `locale` constant defined?
+      def exists?(locale)
+        locale = sanitize_code locale
+        name = capitalize(locale)
+        return false unless name
 
-    # Codes of all available locales.
-    def self.available
-      Dir.glob(File.join(LOCALES_DIR, '*.rb')).map do |i|
-        File.basename(i, '.rb')
+        R18n::Locales.const_defined?(name)
       end
-    end
 
-    # Is +locale+ has info file.
-    def self.exists?(locale)
-      File.exist?(File.join(LOCALES_DIR, "#{locale}.rb"))
-    end
+      def sanitize_code(code)
+        code.to_s.gsub(/[^-_a-zA-Z]/, '').tr('_', '-').downcase
+      end
 
-    # Load locale by RFC 3066 +code+.
-    def self.load(code)
-      original = code.to_s.gsub(/[^-_a-zA-Z]/, '')
-      code = original.tr('_', '-').downcase
-
-      @@loaded[code] ||= begin
-        if exists? code
-          require File.join(LOCALES_DIR, "#{code}.rb")
-          name = code.gsub(/\w+/, &:capitalize).delete('-')
-          R18n::Locales.const_get(name).new
-        else
-          UnsupportedLocale.new(original)
+      def capitalize(code)
+        lang, region = code.gsub(/\..+/, '').split('-')
+        return unless lang
+
+        lang.capitalize!
+        return lang unless region
+
+        region.size > 2 ? region.capitalize! : region.upcase!
+        "#{lang}#{region}"
+      end
+
+      # Load locale by RFC 3066 `code`.
+      def load(code)
+        code = sanitize_code code
+        name = capitalize(code)
+        return unless name
+
+        @loaded[code] ||= begin
+          if exists?(code)
+            R18n::Locales.const_get(name).new
+          else
+            UnsupportedLocale.new(code)
+          end
         end
       end
-    end
 
-    # Set locale +properties+. Locale class will have methods for each propetry
-    # name, which return propetry value:
-    #
-    #   class R18n::Locales::En < R18n::Locale
-    #     set title: 'English',
-    #         code:  'en'
-    #   end
-    #
-    #   locale = R18n::Locales::En.new
-    #   locale.title #=> "English"
-    #   locale.code  #=> "en"
-    def self.set(properties)
-      properties.each_pair do |key, value|
-        define_method(key) { value }
+      # Set locale `properties`. Locale class will have methods
+      # for each property name, which return property value:
+      #
+      #   class R18n::Locales::En < R18n::Locale
+      #     set title: 'English',
+      #         code:  'en'
+      #   end
+      #
+      #   locale = R18n::Locales::En.new
+      #   locale.title #=> "English"
+      #   locale.code  #=> "en"
+      def set(properties)
+        properties.each_pair do |key, value|
+          undef_method key if method_defined? key
+          define_method(key) { value }
+        end
       end
     end
 
-    # Locale RFC 3066 code.
-    def code
-      name = self.class.name.split('::').last
-      lang, culture = name.match(/([A-Z][a-z]+)([A-Z]\w+)?/).captures
-      lang.downcase + (culture ? '-' + culture.upcase : '')
+    attr_reader :code, :language, :region, :downcased_code, :parent
+
+    def initialize
+      language, region =
+        self.class.name.split('::').last.split(/([A-Z][a-z]+)/)[1, 2]
+      @language = language.downcase.freeze
+      @region = region.upcase.freeze if region
+      @code = "#{@language}#{"-#{region}" if region}"
+      @downcased_code = @code.downcase.tr('-', '_').freeze
+
+      @parent = self.class.superclass.new
     end
 
-    set sublocales:  %w[en],
-        week_start:  :monday,
-        time_am:     'AM',
-        time_pm:     'PM',
-        time_format: '_ %H:%M',
-        full_format: '%e %B',
+    set sublocales: [],
+        week_start: :monday,
+        time_am: 'AM',
+        time_pm: 'PM',
+        time_format: '_ %R',
+        time_with_seconds_format: '_ %T',
+        full_format: '%-d %B',
         year_format: '_ %Y'
 
     def month_standalone
@@ -150,14 +169,14 @@ module R18n
       "Locale #{code} (#{title})"
     end
 
-    # Convert +object+ to String. It support Integer, Float, Time, Date
-    # and DateTime.
+    # Convert `object` to `String`. It support `Integer`, `Float`, `Time`,
+    # `Date` and `DateTime`.
     #
-    # For time classes you can set +format+ in standard +strftime+ form,
-    # <tt>:full</tt> (“01 Jule, 2009”), <tt>:human</tt> (“yesterday”),
-    # <tt>:standard</tt> (“07/01/09”) or <tt>:month</tt> for standalone month
-    # name. Default format is <tt>:standard</tt>.
-    def localize(obj, format = nil, *params)
+    # For time classes you can set `format` in standard `strftime` form,
+    # `:full` ("01 Jule, 2009"), `:human` ("yesterday"),
+    # `:standard` ("07/01/09") or `:month` for standalone month
+    # name. Default format is `:standard`.
+    def localize(obj, format = nil, *args, **kwargs)
       case obj
       when Integer
         format_integer(obj)
@@ -166,7 +185,7 @@ module R18n
       when Time, DateTime, Date
         return strftime(obj, format) if format.is_a? String
         return month_standalone[obj.month - 1] if format == :month
-        return obj.to_s if format == :human && !params.first.is_a?(I18n)
+        return obj.to_s if format == :human && !kwargs.key?(:i18n)
 
         type = obj.is_a?(Date) && !obj.is_a?(DateTime) ? 'date' : 'time'
         format ||= :standard
@@ -176,17 +195,22 @@ module R18n
           raise ArgumentError, "Unknown time formatter #{format}"
         end
 
-        send format_method_name, obj, *params
+        send format_method_name, obj, *args, **kwargs
       else
-        obj.to_s
+        format_method_name =
+          "format_#{Utils.underscore(obj.class.name).tr('/', '_')}_#{format}"
+
+        return obj.to_s unless respond_to? format_method_name
+
+        send format_method_name, obj, *args, **kwargs
       end
     end
 
-    # Returns the integer in String form, according to the rules of the locale.
-    # It will also put real typographic minus.
+    # Returns the integer in `String` form, according to the rules
+    # of the locale. It will also put real typographic minus.
     def format_integer(integer)
       str = integer.to_s
-      str[0] = '−' if integer < 0 # Real typographic minus
+      str[0] = '−' if integer.negative? # Real typographic minus
       group = number_group
 
       str.gsub(/(\d)(?=(\d\d\d)+(?!\d))/) do |match|
@@ -194,16 +218,16 @@ module R18n
       end
     end
 
-    # Returns the float in String form, according to the rules of the locale.
+    # Returns the float in `String` form, according to the rules of the locale.
     # It will also put real typographic minus.
     def format_float(float)
       decimal = number_decimal
       format_integer(float.to_i) + decimal + float.to_s.split('.').last
     end
 
-    # Same that <tt>Time.strftime</tt>, but translate months and week days
-    # names. In +time+ you can use Time, DateTime or Date object. In +format+
-    # you can use standard +strftime+ format.
+    # Same that `Time.strftime`, but translate months and week days
+    # names. In `time` you can use `Time`, `DateTime` or `Date` object.
+    # In `format` you can use standard `strftime` format.
     def strftime(time, format)
       translated = ''
       format.scan(/%[EO]?.|./o) do |c|
@@ -226,48 +250,50 @@ module R18n
       time.strftime(translated)
     end
 
-    # Format +time+ and set +date+
-    def format_time(date, time)
-      strftime(time, time_format).sub('_', date.to_s)
+    # Format `time` and set `date`
+    def format_time(date, time, with_seconds: false, **_kwargs)
+      strftime(
+        time, with_seconds ? time_with_seconds_format : time_format
+      ).sub('_', date.to_s)
     end
 
-    # Format +time+ in human usable form. For example “5 minutes ago” or
-    # “yesterday”. In +now+ you can set base time, which be used to get relative
-    # time. For special cases you can replace it in locale’s class.
-    def format_time_human(time, i18n, now = Time.now, *_params)
+    # Format `time` in human usable form. For example "5 minutes ago" or
+    # "yesterday". In `now` you can set base time, which be used to get relative
+    # time. For special cases you can replace it in locale's class.
+    def format_time_human(time, i18n:, now: time.class.now, **_kwargs)
       diff = time - now
       minutes = time.is_a?(DateTime) ? diff * 24 * 60.0 : diff / 60.0
       diff = minutes.abs
       if (diff > 24 * 60) || (time.mday != now.mday && diff > 12 * 24)
-        format_time(format_date_human(time.to_date, i18n, now.to_date), time)
+        format_time(format_date_human(time.to_date, now: now.to_date, i18n: i18n), time)
       elsif minutes > -1 && minutes < 1
         i18n.human_time.now
       elsif minutes >= 60
         i18n.human_time.after_hours((diff / 60.0).floor)
       elsif minutes <= -60
         i18n.human_time.hours_ago((diff / 60.0).floor)
-      elsif minutes > 0
+      elsif minutes.positive?
         i18n.human_time.after_minutes(minutes.round)
       else
         i18n.human_time.minutes_ago(minutes.round.abs)
       end
     end
 
-    # Format +time+ in compact form. For example, “12/31/09 12:59”.
-    def format_time_standard(time, *_params)
-      format_time(format_date_standard(time), time)
+    # Format `time` in compact form. For example, "12/31/09 12:59".
+    def format_time_standard(time, *args, **kwargs)
+      format_time(format_date_standard(time), time, *args, **kwargs)
     end
 
-    # Format +time+ in most official form. For example, “December 31st, 2009
-    # 12:59”. For special cases you can replace it in locale’s class.
-    def format_time_full(time, *_params)
-      format_time(format_date_full(time), time)
+    # Format `time` in most official form. For example, "December 31st, 2009
+    # 12:59". For special cases you can replace it in locale's class.
+    def format_time_full(time, **kwargs)
+      format_time(format_date_full(time, **kwargs), time, **kwargs)
     end
 
-    # Format +date+ in human usable form. For example “5 days ago” or
-    # “yesterday”. In +now+ you can set base time, which be used to get relative
-    # time. For special cases you can replace it in locale’s class.
-    def format_date_human(date, i18n, now = Date.today, *_params)
+    # Format `date` in human usable form. For example "5 days ago" or "yesterday".
+    # In `:now` you can set base time, which be used to get relative time.
+    # For special cases you can replace it in locale's class.
+    def format_date_human(date, *_args, i18n:, now: Date.today, **_kwargs)
       days = (date - now).to_i
       case days
       when -6..-2
@@ -281,28 +307,28 @@ module R18n
       when 2..6
         i18n.human_time.after_days(days)
       else
-        format_date_full(date, date.year != now.year)
+        format_date_full(date, year: date.year != now.year)
       end
     end
 
-    # Format +date+ in compact form. For example, “12/31/09”.
+    # Format `date` in compact form. For example, "12/31/09".
     def format_date_standard(date, *_params)
       strftime(date, date_format)
     end
 
-    # Format +date+ in most official form. For example, “December 31st, 2009”.
-    # For special cases you can replace it in locale’s class. If +year+ is false
+    # Format `date` in most official form. For example, "December 31st, 2009".
+    # For special cases you can replace it in locale's class. If `year` is false
     # date will be without year.
-    def format_date_full(date, year = true, *_params)
+    def format_date_full(date, year: true, **_kwargs)
       format = full_format
       format = year_format.sub('_', format) if year
       strftime(date, format)
     end
 
-    # Return pluralization type for +n+ items. This is simple form. For special
-    # cases you can replace it in locale’s class.
-    def pluralize(n)
-      case n
+    # Return pluralization type for `number` of items. This is simple form.
+    # For special cases you can replace it in locale's class.
+    def pluralize(number)
+      case number
       when 0
         0
       when 1
@@ -314,5 +340,9 @@ module R18n
   end
 
   # Namespace for Locale sub-classes
-  module Locales; end
+  module Locales
+    Dir.glob(File.join(__dir__, 'locales', '*.rb')) do |file|
+      autoload Locale.capitalize(File.basename(file, '.*')), file
+    end
+  end
 end