i18n-inflector 2.0.1 → 2.1.0

data/lib/i18n-inflector/backend.rb

@@ -42,7 +42,7 @@ module I18n
       # Translates given key taking care of inflections.
       # 
       # @api public
-      # @see I18n::Inflector::Core#interpolate
+      # @see I18n::Inflector::API#interpolate
       # @see I18n::Inflector::InflectionOptions
       # @param [Symbol] locale locale
       # @param [Symbol,String] key translation key
@@ -52,12 +52,13 @@ module I18n
       #   particular option should be the same as the name of a kind of tokens from a pattern.
       #   All +options+ along with a +string+ and +locale+ are passed to
       #   {I18n::Backend::Simple#translate I18n::Backend::Simple#translate}
-      #   and the result is processed by {I18n::Inflector::Core#interpolate}
+      #   and the result is processed by {I18n::Inflector::API#interpolate}
       # @return [String] the translated string with interpolated patterns
       def translate(locale, key, options = {})
+        orig_options = options.dup
         translated_string = super
 
-        return translated_string if locale.to_s.empty?
+        return translated_string if (locale.nil? || locale.to_s.empty?)
 
         unless @inflector.inflected_locale?(locale)
           return translated_string.gsub(I18n::Inflector::PATTERN,'')
@@ -67,7 +68,7 @@ module I18n
           return translated_string
         end
 
-        @inflector.interpolate(translated_string, locale, options.dup)
+        @inflector.interpolate(translated_string, locale, orig_options)
       end
 
       # Stores translations in memory.
@@ -88,8 +89,8 @@ module I18n
           unless subdata.nil?
             subdata = (subdata[:inflections] || subdata['inflections'])
             unless subdata.nil?
-              inflection_data = load_inflection_tokens(locale, r[:i18n][:inflections])
-              @inflector.add_database(inflection_data)
+              db, db_strict = load_inflection_tokens(locale, r[:i18n][:inflections])
+              @inflector.add_databases(db, db_strict)
             end
           end
         end
@@ -103,7 +104,7 @@ module I18n
       # @return [void]
       def inflector_try_init
         return nil if (defined?(@inflector) && !@inflector.nil?)
-        @inflector  = I18n::Inflector::Core.new
+        @inflector  = I18n::Inflector::API.new
         nil
       end
 
@@ -122,7 +123,7 @@ module I18n
       end
 
       # Gives an access to the internal structure containing configuration data
-      # for a given locale.
+      # for the given locale.
       # 
       # @note Under some very rare conditions this method may be called while
       #   translation data is loading. It must always return when translations
@@ -130,7 +131,7 @@ module I18n
       #   will eat a kittien!
       # @param [Symbol] locale the locale to use
       # @return [Hash,nil] part of the translation data that
-      #   reflects inflections for a given locale or +nil+
+      #   reflects inflections for the given locale or +nil+
       #   if translations are not initialized
       def inflection_subtree(locale)
         return nil unless initialized?
@@ -174,13 +175,13 @@ module I18n
           if kind_subtree.has_key?(token)
             return token
           else
-            # that should never happend but who knows
             raise I18n::BadInflectionToken.new(locale, token, kind)
           end
         else
           orig_token = token
           token = value[1..-1]
-          if token.to_s.empty?
+
+          if (token.nil? || token.to_s.empty?)
             raise I18n::BadInflectionToken.new(locale, token, kind)
           end
           token = token.to_sym
@@ -195,7 +196,8 @@ module I18n
 
       # Uses the inflections subtree and creates internal mappings
       # to resolve kinds assigned to inflection tokens and aliases, including defaults.
-      # @return [Hash,nil] the internal Hash containing inflections tokens or +nil+ if something went wrong
+      # @return [I18n::Inflector::InflectionData,nil] the database containing inflections tokens
+      #   or +nil+ if something went wrong
       # @raise [I18n::BadInflectionToken] if a name of some loaded token is invalid
       # @raise [I18n::BadInflectionAlias] if a loaded alias points to a token that does not exists
       # @raise [I18n::DuplicatedInflectionToken] if a token has already appeard in loaded configuration
@@ -204,65 +206,100 @@ module I18n
       #   Loads inflection tokens for the given locale using internal hash of stored translations. Requires
       #   translations to be initialized.
       #   @param [Symbol] locale the locale to use and work for
-      #   @return [Hash,nil] the internal Hash containing inflections or +nil+ if translations were not initialized
+      #   @return [I18n::Inflector::InflectionData,nil] the database containing inflections tokens
+      #     or +nil+ if something went wrong
       # @overload load_inflection_tokens(locale, subtree)
-      #   Loads inflection tokens for the given locale using data given in an argument
+      #   Loads inflection tokens for the given locale using datthe given in an argument
       #   @param [Symbol] locale the locale to use and work for
       #   @param [Hash] subtree the tree (in a form of nested Hashes) containing inflection tokens to scan
-      #   @return [Hash,nil] the internal Hash containing inflections or +nil+ if the given subtree was wrong or empty
+      #   @return [I18n::Inflector::InflectionData,nil] the database containing inflections tokens
+      #     or +nil+ if something went wrong
       def load_inflection_tokens(locale, subtree=nil)
         inflections_tree = subtree || inflection_subtree(locale)
         return nil if (inflections_tree.nil? || inflections_tree.empty?)
 
-        idb = I18n::Inflector::InflectionData.new(locale)
+        idb         = I18n::Inflector::InflectionData.new(locale)
+        idb_strict  = I18n::Inflector::InflectionData_Strict.new(locale)
+
+        return nil if (idb.nil? || idb_strict.nil?)
 
-        inflections_tree.each_pair do |kind, tokens|
+        inflections = prepare_inflections(inflections_tree, idb, idb_strict)
+
+        inflections.each do |orig_kind, kind, strict_kind, subdb, tokens|
           tokens.each_pair do |token, description|
 
             # test for duplicate
-            if idb.has_token?(token)
-              raise I18n::DuplicatedInflectionToken.new(idb.get_kind(token), kind, token)
+            if subdb.has_token?(token, strict_kind)
+              raise I18n::DuplicatedInflectionToken.new(subdb.get_kind(token, strict_kind), orig_kind, token)
             end
 
             # validate token's name
-            raise I18n::BadInflectionToken.new(locale, token, kind) if token.to_s.empty?
+            raise I18n::BadInflectionToken.new(locale, token, orig_kind) if (token.nil? || token.to_s.empty?)
 
             # validate token's description
             if description.nil?
-              raise I18n::BadInflectionToken.new(locale, token, kind, description)
+              raise I18n::BadInflectionToken.new(locale, token, orig_kind, description)
             elsif description[0..0] == I18n::Inflector::ALIAS_MARKER
               next
             end
 
-            # handle default token for a kind
-            if token == :default
-              if idb.has_default_token?(kind) # should never happend unless someone is messing with @translations
-                raise I18n::DuplicatedInflectionToken.new(kind, nil, token)
-              end
-              idb.set_default_token(kind, description)
-              next
-            end
+            # skip default token for later processing
+            next if token == :default
 
-            idb.add_token(token, kind, description)
+            subdb.add_token(token, kind, description)
           end
         end
 
         # handle aliases
-        inflections_tree.each_pair do |kind, tokens|
+        inflections.each do |orig_kind, kind, strict_kind, subdb, tokens|
           tokens.each_pair do |token, description|
+            next if token == :default
             next if description[0..0] != I18n::Inflector::ALIAS_MARKER
-            real_token = shorten_inflection_alias(token, kind, locale, inflections_tree)
-            idb.add_alias(token, real_token) unless real_token.nil?
+            real_token = shorten_inflection_alias(token, orig_kind, locale, inflections_tree)
+            subdb.add_alias(token, real_token, kind) unless real_token.nil?
           end
         end
 
-        # process and validate defaults
-        valid = idb.validate_default_tokens
-        raise I18n::BadInflectionAlias.new(locale, :default, valid[0], valid[1]) unless valid.nil?
+        # handle default tokens
+        inflections.each do |orig_kind, kind, strict_kind, subdb, tokens|
+          next unless tokens.has_key?(:default)
+          if subdb.has_default_token?(kind)
+            raise I18n::DuplicatedInflectionToken.new(orig_kind, nil, :default)
+          end
+          orig_target = tokens[:default]
+          target = orig_target.to_s
+          target = target[1..-1] if target[0..0] == I18n::Inflector::ALIAS_MARKER
+          if target.empty?
+            raise I18n::BadInflectionToken.new(locale, token, orig_kind, orig_target)
+          end
+          target = subdb.get_true_token(target.to_sym, kind)
+          if target.nil?
+            raise I18n::BadInflectionAlias.new(locale, :default, orig_kind, orig_target)
+          end
+          subdb.set_default_token(kind, target)
+        end
+
+        [idb, idb_strict]
+      end
 
-        idb
+      # @private
+      def prepare_inflections(inflections, idb, idb_strict)
+        I18n::Inflector::LazyHashEnumerator.new(inflections).ary_map do |kind, tokens|
+          next if (tokens.nil? || tokens.empty?)
+          subdb       = idb
+          strict_kind = nil
+          orig_kind   = kind
+          if kind.to_s[0..0] == I18n::Inflector::NAMED_MARKER
+            kind        = kind.to_s[1..-1]
+            next if kind.empty?
+            kind        = kind.to_sym
+            subdb       = idb_strict
+            strict_kind = kind
+          end
+          [orig_kind, kind, strict_kind, subdb, tokens]
+        end
       end
 
-    end
-  end
-end
+    end # module Inflector
+  end # module Backend
+end # module I18n

data/lib/i18n-inflector/errors.rb

@@ -8,78 +8,119 @@
 
 module I18n
 
-  # This is raised when there is no kind given in options or the kind is +nil+. The kind
-  # is determined by looking at token placed in a pattern.
-  # 
-  # This exception will also be raised when a required option, describing token selected
-  # for a kind, is empty or doesn't match any acceptable tokens.
+  # @abstract This class is a parent class for exceptions raised when
+  #   inflection option is bad or missing.
   class InvalidOptionForKind < ArgumentError
+
     attr_reader :pattern, :kind, :token, :option
+
     def initialize(pattern, kind, token, option)
-      @pattern, @kind, @token, @option = pattern, kind, token, option
-      if option.nil?
-        super "option #{kind.inspect} required by the " +
-              "pattern #{pattern.inspect} was not found"
-      else
-        super "value #{option.inspect} of #{kind.inspect} required by the " +
-              "pattern #{pattern.inspect} does not match any token"      
+      @pattern, @kind, @token, @option, @option_present = pattern, kind, token, option
+      @message ||= ""
+      super(@message)
+    end
+
+  end
+
+  # This is raised when there is no kind given in options. The kind
+  # is determined by looking at token placed in a pattern.
+  class InflectionOptionNotFound < InvalidOptionForKind
+
+    def initialize(pattern, kind, token, option=nil)
+      kind = kind.to_s
+      unless kind.empty?
+        if kind[0..0] == I18n::Inflector::NAMED_MARKER
+          kind = ":#{kind} (or :#{kind[1..-1]})"
+        else
+          kind = kind.to_sym.inspect
+        end
       end
+      @message = "option #{kind} required by the " +
+                 "pattern #{pattern.inspect} was not found"  
+      super
+    end
+
+  end
+
+  # This exception will be raised when a required option, describing token selected
+  # for a kind, is +nil+, empty or doesn't match any acceptable tokens.
+  class InflectionOptionIncorrect < InvalidOptionForKind
+
+    def initialize(pattern, kind, token, option)
+      @message = "value #{option.inspect} of option #{kind.inspect} required by " +
+                 "#{pattern.inspect} does not match any token"
+      super
     end
+
   end
 
   # This is raised when token given in pattern is invalid (empty or has no
   # kind assigned).
   class InvalidInflectionToken < ArgumentError
+
     attr_reader :pattern, :token
+
     def initialize(pattern, token)
       @pattern, @token = pattern, token
       super "token #{token.inspect} used in translation " + 
             "pattern #{pattern.inspect} is invalid"
     end
+
   end
 
   # This is raised when an inflection token used in a pattern does not match
   # an assumed kind determined by reading previous tokens from that pattern.
   class MisplacedInflectionToken < ArgumentError
+
     attr_reader :pattern, :token, :kind
+
     def initialize(pattern, token, kind)
       @pattern, @token, @kind = pattern, token, kind
       super "inflection token #{token.inspect} from pattern #{pattern.inspect} " +
             "is not of the expected kind #{kind.inspect}"
     end
+
   end
 
   # This is raised when an inflection token of the same name is already defined in
   # inflections tree of translation data.
   class DuplicatedInflectionToken < ArgumentError
+
     attr_reader :original_kind, :kind, :token
+
     def initialize(original_kind, kind, token)
       @original_kind, @kind, @token = original_kind, kind, token
       and_cannot = kind.nil? ? "" : "and cannot be used with kind #{kind.inspect}"
       super "inflection token #{token.inspect} was already assigned " +
-            "to kind #{original_kind}" + and_cannot
+            "to kind #{original_kind} " + and_cannot
     end
+
   end
 
   # This is raised when an alias for an inflection token points to a token that
   # doesn't exists. It is also raised when default token of some kind points
   # to a non-existent token.
   class BadInflectionAlias < ArgumentError
+
     attr_reader :locale, :token, :kind, :pointer
+
     def initialize(locale, token, kind, pointer)
       @locale, @token, @kind, @pointer = locale, token, kind, pointer
       what = token == :default ? "default token" : "alias"
       lang = locale.nil? ? "" : "for language #{locale.inspect} "
       kinn = kind.nil? ?   "" : "of kind #{kind.inspect} "
-      super "the #{what} #{token.inspect}" + kinn + lang +
+      super "the #{what} #{token.inspect} " + kinn + lang +
             "points to an unknown token #{pointer.inspect}"
     end
+
   end
 
   # This is raised when an inflection token or its description has a bad name. This
   # includes an empty name or a name containing prohibited characters.
   class BadInflectionToken < ArgumentError
+
     attr_reader :locale, :token, :kind, :description
+
     def initialize(locale, token, kind=nil, description=nil)
       @locale, @token, @kind, @description = locale, token, kind, description
       kinn = kind.nil? ? "" : "of kind #{kind.inspect} "
@@ -91,6 +132,7 @@ module I18n
               "for language #{locale.inspect} has a bad description #{description.inspect}"
       end
     end
+
   end
 
 end