i18n-inflector 2.5.1 → 2.6.1

data/lib/i18n-inflector/api_strict.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains I18n::Inflector::API_Strict class,
 # which handles public API for managing inflection data
@@ -57,6 +57,8 @@ module I18n
       def initialize(idb=nil, options=nil)
         @idb      = idb.nil?      ? {} : idb
         @options  = options.nil?  ? I18n::Inflector::InflectionOptions.new : options
+        @lazy_locales = LazyHashEnumerator.new(@idb)
+        @inflected_locales_cache = Hash.new
       end
 
       # Creates an empty strict inflections database for the specified locale.
@@ -69,6 +71,7 @@ module I18n
       #   inflection data
       def new_database(locale)
         locale = prep_locale(locale)
+        @inflected_locales_cache.clear
         @idb[locale] = I18n::Inflector::InflectionData_Strict.new(locale)
       end
 
@@ -85,6 +88,7 @@ module I18n
         return nil if db.nil?
         locale = prep_locale(db.locale)
         delete_database(locale)
+        @inflected_locales_cache.clear
         @idb[locale] = db
       end
 
@@ -99,6 +103,7 @@ module I18n
       def delete_database(locale)
         locale = prep_locale(locale)
         return nil if @idb[locale].nil?
+        @inflected_locales_cache.clear
         @idb[locale] = nil
       end
 
@@ -120,6 +125,29 @@ module I18n
       alias_method :locale?,            :inflected_locale?
       alias_method :locale_supported?,  :inflected_locale?
 
+      # Iterates through locales which have configured strict inflection support.
+      # 
+      # @api public
+      # @return [LazyArrayEnumerator] the lazy enumerator
+      # @yield [locale] optional block in which each kind will be yielded
+      # @yieldparam [Symbol] locale the inflected locale identifier
+      # @yieldreturn [LazyArrayEnumerator] the lazy enumerator
+      # @overload each_inflected_locale
+      #   Iterates through locales which have configured inflection support.
+      #   @return [LazyArrayEnumerator] the lazy enumerator
+      # @overload each_inflected_locale(kind)
+      #   Iterates through locales which have configured inflection support for the given +kind+.
+      #   @param [Symbol] kind the identifier of a kind
+      #   @return [LazyArrayEnumerator] the lazy enumerator
+      def each_inflected_locale(kind=nil, &block)
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        i = @lazy_locales.reject  { |lang,data| data.empty?           }
+        i = i.select              { |lang,data| data.has_kind?(kind)  } unless kind.nil?
+        i.each_key(&block)
+      end
+      alias_method :each_locale,            :each_inflected_locale
+      alias_method :each_supported_locale,  :each_inflected_locale
+
       # Gets locales which have configured strict inflection support.
       # 
       # @api public
@@ -132,19 +160,33 @@ module I18n
       #   @param [Symbol] kind the identifier of a kind
       #   @return [Array<Symbol>] the array containing locales that support inflection
       def inflected_locales(kind=nil)
-        return [] if (!kind.nil? && kind.to_s.empty?)
-        inflected_locales = LazyHashEnumerator.new(@idb || {})
-        inflected_locales = inflected_locales.
-                            reject{ |lang,data| data.nil? || data.empty? }
-        return inflected_locales.keys if kind.nil?
-        kind = kind.to_sym
-        inflected_locales.
-          reject{|land,data| !data.has_kind?(kind)}.
-          keys
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        r = ( @inflected_locales_cache[kind] ||= each_inflected_locale(kind).to_a )
+        r.nil? ? r : r.dup
       end
       alias_method :locales,            :inflected_locales
       alias_method :supported_locales,  :inflected_locales
 
+      # Iterates through known strict inflection kinds.
+      # 
+      # @api public
+      # @return [LazyArrayEnumerator] the lazy enumerator
+      # @yield [kind] optional block in which each kind will be yielded
+      # @yieldparam [Symbol] kind the inflection kind
+      # @yieldreturn [LazyArrayEnumerator] the lazy enumerator
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @overload kinds
+      #   Iterates through known inflection kinds for the current locale.
+      #   @return [LazyArrayEnumerator] the lazy enumerator
+      # @overload kinds(locale)
+      #   Iterates through known inflection kinds for the given +locale+.
+      #   @param [Symbol] locale the locale for which kinds should be listed
+      #   @return [LazyArrayEnumerator] the lazy enumerator
+      def each_kind(locale=nil, &block)
+        data_safe(locale).each_kind(&block)
+      end
+      alias_method :each_inflection_kind, :each_kind
+
       # Gets known strict inflection kinds.
       # 
       # @api public
@@ -156,9 +198,9 @@ module I18n
       # @overload kinds(locale)
       #   Gets known inflection kinds for the given +locale+.
       #   @param [Symbol] locale the locale for which kinds should be listed
-      #   @return [Array<Symbol>] the array containing known inflection kinds
+      #   @return [Array<Symbol>] the array containing known inflection kinds      
       def kinds(locale=nil)
-        data_safe(locale).get_kinds
+        each_kind(locale).to_a
       end
       alias_method :inflection_kinds, :kinds
 
@@ -325,6 +367,35 @@ module I18n
         data_safe(locale).get_kind(token.to_sym, kind.to_sym)
       end
 
+      # Iterates through available inflection tokens belonging to a strict kind and their descriptions.
+      # 
+      # @api public
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @note You cannot deduce where aliases are pointing to, since the information
+      #   about a target is replaced by the description. To get targets use the
+      #   {#raw_tokens} method. To simply list aliases and their targets use
+      #   the {#aliases} method.
+      # @overload each_token(kind)
+      #   Iterates through available inflection tokens and their descriptions for some +kind+ and
+      #   the current locale.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @overload each_token(kind, locale)
+      #   Iterates through available inflection tokens and their descriptions of the given
+      #   +kind+ and +locale+.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @param [Symbol] locale the locale to use
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      def each_token(kind=nil, locale=nil, &block)
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        data_safe(locale).each_token(kind, &block)
+      end
+
       # Gets available inflection tokens belonging to a strict kind and their descriptions.
       # 
       # @api public
@@ -348,10 +419,36 @@ module I18n
       #   @return [Hash] the hash containing available inflection tokens (including
       #     aliases) as keys and their descriptions as values
       def tokens(kind=nil, locale=nil)
-        return {} if (kind.nil? || kind.to_s.empty?)
-        data_safe(locale).get_tokens(kind.to_sym)
+        each_token(kind, locale).to_h
       end
 
+      # Iterates through available inflection tokens belonging to a strict kind and their values.
+      # 
+      # @api public
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      # @yield [token, value] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [Symbol, String] value a description string for a token or a target (if alias)
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @note You may deduce whether the returned values are aliases or true tokens
+      #   by testing if a value is a kind of Symbol or a String.
+      # @overload each_token_raw(kind)
+      #   Iterates through available inflection tokens and their values of the given +kind+ and
+      #   the current locale.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      # @overload each_token_raw(kind, locale)
+      #   Iterates through available inflection tokens (and their values) of the given +kind+ and +locale+.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @param [Symbol] locale the locale to use
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      def each_token_raw(kind=nil, locale=nil, &block)
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        data_safe(locale).each_raw_token(kind, &block)
+      end
+      alias_method :each_raw_token, :each_token_raw
+
       # Gets available inflection tokens belonging to a strict kind and their values.
       # 
       # @api public
@@ -374,11 +471,36 @@ module I18n
       #     and their descriptions as values. In case of aliases the returned
       #     values are Symbols
       def tokens_raw(kind=nil, locale=nil)
-        return {} if (kind.nil? || kind.to_s.empty?)
-        data_safe(locale).get_raw_tokens(kind.to_sym)
+        each_token_raw(kind, locale).to_h
       end
       alias_method :raw_tokens, :tokens_raw
 
+      # Iterates through inflection tokens belonging to a strict kind and their values.
+      # 
+      # @api public
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @note It returns only true tokens, not aliases.
+      # @overload each_token_true(kind)
+      #   Iterates through true inflection tokens (and their values) of the given +kind+ and
+      #   the current locale.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @overload each_token_true(kind, locale)
+      #   Iterates through true inflection tokens (and their values) of the given +kind+ and +locale+.
+      #   @param [Symbol,String] kind the kind of inflection tokens to be returned
+      #   @param [Symbol] locale the locale to use
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      def each_token_true(kind=nil, locale=nil, &block)
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        data_safe(locale).each_true_token(kind, &block)
+      end
+      alias_method :each_true_token, :each_token_true
+
       # Gets true inflection tokens belonging to a strict kind and their values.
       # 
       # @api public
@@ -398,11 +520,33 @@ module I18n
       #   @return [Hash] the hash containing available inflection tokens as keys
       #     and their descriptions as values
       def tokens_true(kind=nil, locale=nil)
-        return {} if (kind.nil? || kind.to_s.empty?)
-        data_safe(locale).get_true_tokens(kind.to_sym)
+        each_token_true(kind, locale).to_h
       end
       alias_method :true_tokens, :tokens_true
 
+      # Iterates through inflection aliases belonging to a strict kind and their pointers.
+      # 
+      # @api public
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => target</tt>)
+      # @yield [alias, target] optional block in which each alias will be yielded
+      # @yieldparam [Symbol] alias an alias
+      # @yieldparam [Symbol] target a name of the target token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @overload each_alias(kind)
+      #   Iterates through inflection aliases (and their pointers) of the given +kind+ and the current locale.
+      #   @param [Symbol,String] kind the kind of aliases to get
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => target</tt>)
+      # @overload each_alias(kind, locale)
+      #   Iterates through inflection aliases (and their pointers) of the given +kind+ and +locale+.
+      #   @param [Symbol,String] kind the kind of aliases to get
+      #   @param [Symbol] locale the locale to use
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => target</tt>)
+      def each_alias(kind=nil, locale=nil, &block)
+        kind = kind.to_s.empty? ? nil : kind.to_sym
+        data_safe(locale).each_alias(kind, &block)
+      end
+
       # Gets inflection aliases belonging to a strict kind and their pointers.
       # 
       # @api public
@@ -418,8 +562,7 @@ module I18n
       #   @param [Symbol] locale the locale to use
       #   @return [Hash] the Hash containing available inflection aliases
       def aliases(kind=nil, locale=nil)
-        return {} if (kind.nil? || kind.to_s.empty?)
-        data_safe(locale).get_aliases(kind.to_sym)
+        each_alias(kind, locale).to_h
       end
 
       # Gets the description of the given inflection token belonging to a strict kind.
@@ -509,7 +652,7 @@ module I18n
       # @return [Symbol] the given locale or the global locale
       def prep_locale(locale=nil)
         locale ||= I18n.locale
-        raise I18n::InvalidLocale.new(locale) if (locale.nil? || locale.to_s.empty?)
+        raise I18n::InvalidLocale.new(locale) if locale.to_s.empty?
         locale.to_sym
       end
 

data/lib/i18n-inflector/backend.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains I18n::Backend::Inflector module,
 # which extends I18n::Backend::Simple by adding the ability
@@ -14,7 +14,7 @@ module I18n
   # @abstract This namespace is shared with I18n subsystem.
   module Backend
 
-    # This module contains methods that are adding
+    # This module contains methods that add
     # tokenized inflection support to internal I18n classes.
     # It is intened to be included in the Simple backend
     # module so that it will patch translate method in order
@@ -114,7 +114,7 @@ module I18n
             subdata = (subdata[:inflections] || subdata['inflections'])
             unless subdata.nil?
               db, db_strict = load_inflection_tokens(locale, r[:i18n][:inflections])
-              @inflector.add_databases(db, db_strict)
+              @inflector.add_database(db, db_strict)
             end
           end
         end
@@ -127,9 +127,10 @@ module I18n
       # 
       # @return [void]
       def inflector_try_init
-        return nil if (defined?(@inflector) && !@inflector.nil?)
-        @inflector  = I18n::Inflector::API.new
-        nil
+        unless (defined?(@inflector) && !@inflector.nil?)
+          @inflector = I18n::Inflector::API.new
+          init_translations unless initialized?
+        end
       end
 
       # Takes care of loading inflection tokens
@@ -143,7 +144,9 @@ module I18n
       # @raise [I18n::DuplicatedInflectionToken] if a token has already appeard in loaded configuration
       # @return [Boolean] +true+ if everything went fine
       def init_translations
-        inflector_try_init
+        unless (defined?(@inflector) && !@inflector.nil?)
+          @inflector = I18n::Inflector::API.new
+        end
         super
       end
 

data/lib/i18n-inflector/config.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains configuration of I18n::Inflector module.
 
@@ -36,7 +36,7 @@ module I18n
 
       # @private
       def gen_regexp(ary)
-        ::Regexp.new '[' + ary.join + ']'
+        ::Regexp.new '[' << ary.join << ']'
       end
       module_function :gen_regexp
 
@@ -45,7 +45,7 @@ module I18n
 
       # Regexp matching a prefix that makes option
       # a controlling option.
-      OPTION_PREFIX_REGEXP = Regexp.new '^' + OPTION_PREFIX
+      OPTION_PREFIX_REGEXP = Regexp.new('^' << OPTION_PREFIX)
 
       # This module contains keys that have special
       # meaning.
@@ -146,7 +146,7 @@ module I18n
         end # module Token
 
         # All operators.
-        ALL = (Tokens::ALL + Token::ALL).uniq
+        ALL = Tokens::ALL | Token::ALL
 
       end # module Operators
 
@@ -164,7 +164,7 @@ module I18n
         module Tokens
 
           # Reserved characters in token identifiers placed in configuration.
-          DB        = (Operators::ALL + Markers::ALL - [Markers::LOUD_VALUE]).uniq
+          DB        = (Operators::ALL | Markers::ALL) - [Markers::LOUD_VALUE]
 
           # Reserved characters in token identifiers passed as options.
           OPTION    = DB
@@ -212,13 +212,13 @@ module I18n
         module Kinds
 
           # Reserved characters in kind identifiers placed in configuration.
-          DB        = (Operators::ALL + Markers::ALL - [Markers::ALIAS, Markers::LOUD_VALUE]).uniq
+          DB        = (Operators::ALL | Markers::ALL) - [Markers::ALIAS, Markers::LOUD_VALUE]
 
           # Reserved characters in kind identifiers passed as option values.
           OPTION    = DB
 
           # Reserved characters in kind identifiers placed in patterns.
-          PATTERN   = (Operators::ALL + Markers::ALL - [Markers::LOUD_VALUE]).uniq
+          PATTERN   = (Operators::ALL | Markers::ALL) - [Markers::LOUD_VALUE]
 
           # This module contains constants defining
           # regular expressions for reserved characters
@@ -259,23 +259,23 @@ module I18n
       end # module Reserved
 
       # A string for regular expression that catches patterns.
-      PATTERN_RESTR   = '(.?)'  + Markers::PATTERN       +
-                        '([^\\' + Markers::PATTERN_BEGIN + ']*)\\' + Markers::PATTERN_BEGIN +
-                        '([^\\' + Markers::PATTERN_END   + ']+)\\' + Markers::PATTERN_END   +
-                        '((?:\\'+ Markers::PATTERN_BEGIN + '([^\\' + Markers::PATTERN_BEGIN +
-                        ']+)\\' + Markers::PATTERN_END   + ')*)'
+      PATTERN_RESTR   = '(.?)'  << Markers::PATTERN       <<
+                        '([^\\' << Markers::PATTERN_BEGIN << ']*)\\' << Markers::PATTERN_BEGIN <<
+                        '([^\\' << Markers::PATTERN_END   << ']+)\\' << Markers::PATTERN_END   <<
+                        '((?:\\'<< Markers::PATTERN_BEGIN << '([^\\' << Markers::PATTERN_BEGIN <<
+                        ']+)\\' << Markers::PATTERN_END   << ')*)'
 
       # A string for regular expression that extracts additional patterns attached.
-      MULTI_RESTR     = '\\'    + Markers::PATTERN_BEGIN          +
-                        '([^\\' + Markers::PATTERN_END + ']+)\\'  +
+      MULTI_RESTR     = '\\'    << Markers::PATTERN_BEGIN          <<
+                        '([^\\' << Markers::PATTERN_END + ']+)\\'  <<
                         Markers::PATTERN_END
 
       # A regular expression that catches token groups or single tokens.
-      TOKENS_RESTR   = '(?:'   +
-                       '([^'   + Operators::Tokens::ASSIGN + '\\'      + Operators::Tokens::OR + ']+)' +
-                                 Operators::Tokens::ASSIGN + '+'       +
-                       '([^\\' + Operators::Tokens::OR     + ']+)\1?)' +
-                       '|([^'  + Operators::Tokens::ASSIGN + '\\'      + Operators::Tokens::OR + ']+)'
+      TOKENS_RESTR   = '(?:'   <<
+                       '([^'   << Operators::Tokens::ASSIGN  << '\\'      << Operators::Tokens::OR << ']+)' <<
+                                  Operators::Tokens::ASSIGN  << '+'       <<
+                       '([^\\' << Operators::Tokens::OR      << ']+)\1?)' <<
+                       '|([^'  << Operators::Tokens::ASSIGN  << '\\'      << Operators::Tokens::OR << ']+)'
 
       # A regular expression that catches patterns.
       PATTERN_REGEXP  = Regexp.new PATTERN_RESTR

data/lib/i18n-inflector/errors.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains error reporting classes for I18n::Backend::Inflector module.
 
@@ -81,7 +81,7 @@ module I18n
           kindmsg = kind.to_sym.inspect
         end
       end
-      super +
+      "" << super <<
       "required option #{kindmsg} was not found"
     end
 
@@ -92,7 +92,7 @@ module I18n
   class InflectionOptionIncorrect < InvalidOptionForKind
 
     def message
-      super +
+      "" << super <<
       "required value #{@option.inspect} of option #{@kind.inspect} " \
       "does not match any token"
     end
@@ -113,7 +113,7 @@ module I18n
         kind = @kind.to_s.empty? ? "" : @kind.to_sym
         badkind = " (processed kind: #{kind.inspect})"
       end
-      super + "token #{@token.to_s.inspect} is invalid" + badkind
+      "" << super << "token #{@token.to_s.inspect} is invalid" + badkind
     end
 
   end
@@ -127,7 +127,7 @@ module I18n
     end
 
     def message
-      super + "inflection option #{@kind.inspect} is invalid"
+      "" << super << "inflection option #{@kind.inspect} is invalid"
     end
 
   end
@@ -141,7 +141,7 @@ module I18n
     end
 
     def message
-      super + "kind #{@kind.to_s.inspect} is invalid"
+      "" << super << "kind #{@kind.to_s.inspect} is invalid"
     end
 
   end
@@ -156,7 +156,7 @@ module I18n
     end
 
     def message
-      super +
+      "" << super <<
       "token #{@token.to_s.inspect} " \
       "is not of the expected kind #{@kind.inspect}"
     end
@@ -175,7 +175,7 @@ module I18n
     end
 
     def message
-      super + "pattern is malformed; token count differs from kind count"
+      "" << super << "pattern is malformed; token count differs from kind count"
     end
 
   end
@@ -192,7 +192,7 @@ module I18n
     end
 
     def message
-      super +
+      "" << super <<
       "token #{@token.inspect} " \
       "was already assigned to the kind #{@original_kind.inspect}"
     end
@@ -213,7 +213,7 @@ module I18n
 
     def message
       what = token == :default ? "default token" : "alias #{@token.inspect}"
-      super +
+      "" << super <<
       "the #{what} " \
       "points to an unknown token #{@pointer.inspect}"
     end
@@ -233,11 +233,11 @@ module I18n
 
     def message
       if @description.nil?
-        super +
+        "" << super <<
         "inflection token #{@token.inspect} " \
         "has a bad name"
       else
-        super +
+        "" << super <<
         "inflection token #{@token.inspect} " \
         "has a bad description #{@description.inspect}"
       end
@@ -255,7 +255,7 @@ module I18n
     end
 
     def message
-        super +
+        "" << super <<
         "inflection kind #{@kind.inspect} has bad name or type"
     end