i18n-inflector 2.1.0 → 2.2.0

data/lib/i18n-inflector/errors.rb

@@ -8,16 +8,62 @@
 
 module I18n
 
-  # @abstract This class is a parent class for exceptions raised when
+  # @abstract It is a parent class for all exceptions
+  #   related to inflections.
+  class InflectionException < I18n::ArgumentError
+
+    attr_accessor :token
+    attr_accessor :kind
+    attr_accessor :key
+
+    def initialize(locale, token, kind)
+      @locale, @token, @kind = locale, token, kind
+      @key = nil
+      super()
+    end
+
+  end
+
+  # @abstract It is a parent class for all exceptions
+  #   related to inflection patterns that are processed.
+  class InflectionPatternException < InflectionException
+
+    attr_accessor :pattern
+
+    def initialize(locale, pattern, token, kind)
+      super(locale, token, kind)
+      @pattern = pattern
+    end
+
+    def message
+      mkey = @key.nil? ? "" : ".#{@key}"
+      @pattern.nil? ? "" : "#{@locale}#{mkey}: #{@pattern} - "
+    end
+
+  end
+
+  # @abstract It is a parent class for all exceptions
+  #   related to configuration data of inflections that is processed.
+  class InflectionConfigurationException < InflectionException
+
+    attr_accessor :locale
+
+    def message
+      mkey = @key.nil? ? ".i18n.inflections.#{@kind}" : ".#{@key}"
+      "#{@locale}#{mkey}: "
+    end
+
+  end
+
+  # @abstract It is a parent class for exceptions raised when
   #   inflection option is bad or missing.
-  class InvalidOptionForKind < ArgumentError
+  class InvalidOptionForKind < InflectionPatternException
 
-    attr_reader :pattern, :kind, :token, :option
+    attr_accessor :option
 
-    def initialize(pattern, kind, token, option)
-      @pattern, @kind, @token, @option, @option_present = pattern, kind, token, option
-      @message ||= ""
-      super(@message)
+    def initialize(locale, pattern, token, kind, option)
+      super(locale, pattern, token, kind)
+      @option = option
     end
 
   end
@@ -26,73 +72,129 @@ module I18n
   # is determined by looking at token placed in a pattern.
   class InflectionOptionNotFound < InvalidOptionForKind
 
-    def initialize(pattern, kind, token, option=nil)
-      kind = kind.to_s
+    def message
+      kind = @kind.to_s
       unless kind.empty?
-        if kind[0..0] == I18n::Inflector::NAMED_MARKER
-          kind = ":#{kind} (or :#{kind[1..-1]})"
+        if kind[0..0] == I18n::Inflector::Config::Markers::PATTERN
+          kindmsg = ":#{kind} (or :#{kind[1..-1]})"
         else
-          kind = kind.to_sym.inspect
+          kindmsg = kind.to_sym.inspect
         end
       end
-      @message = "option #{kind} required by the " +
-                 "pattern #{pattern.inspect} was not found"  
-      super
+      super +
+      "required option #{kindmsg} was not found"
     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.
+  # for a kind contains a token that is not of the given kind.
   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
+    def message
+      super +
+      "required value #{@option.inspect} of option #{@kind.inspect} " \
+      "does not match any token"
     end
 
   end
 
-  # This is raised when token given in pattern is invalid (empty or has no
+  # This is raised when a token given in a pattern is invalid (empty or has no
   # kind assigned).
-  class InvalidInflectionToken < ArgumentError
+  class InvalidInflectionToken < InflectionPatternException
+
+    def initialize(locale, pattern, token, kind=nil)
+      super(locale, pattern, token, kind)
+    end
+
+    def message
+      badkind = ""
+      if (!@token.to_s.empty? && !kind.nil?)
+        kind = @kind.to_s.empty? ? "" : @kind.to_sym
+        badkind = " (processed kind: #{kind.inspect})"
+      end
+      super + "token #{@token.to_s.inspect} is invalid" + badkind
+    end
+
+  end
 
-    attr_reader :pattern, :token
+  # This is raised when an inflection option name is invalid (contains
+  # reserved symbols).
+  class InvalidInflectionOption < InflectionPatternException
 
-    def initialize(pattern, token)
-      @pattern, @token = pattern, token
-      super "token #{token.inspect} used in translation " + 
-            "pattern #{pattern.inspect} is invalid"
+    def initialize(locale, pattern, option)
+      super(locale, pattern, nil, option)
+    end
+
+    def message
+      super + "inflection option #{@kind.inspect} is invalid"
+    end
+
+  end
+
+  # This is raised when a kind given in a pattern is invalid (empty, reserved
+  # or containing a reserved character).
+  class InvalidInflectionKind < InflectionPatternException
+
+    def initialize(locale, pattern, kind)
+      super(locale, pattern, nil, kind)
+    end
+
+    def message
+      super + "kind #{@kind.to_s.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
+  # an assumed kind determined by reading previous tokens from that pattern
+  # or by the given strict kind of a named pattern.
+  class MisplacedInflectionToken < InflectionPatternException
+
+    def initialize(locale, pattern, token, kind)
+      super(locale, pattern, token, kind)
+    end
 
-    attr_reader :pattern, :token, :kind
+    def message
+      super +
+      "token #{@token.to_s.inspect} " \
+      "is not of the expected kind #{@kind.inspect}"
+    end
+
+  end
+
+  # This is raised when a complex inflection pattern is malformed
+  # and cannot be reduced to regular patterns.
+  class ComplexPatternMalformed < InflectionPatternException
+
+    def initialize(locale, pattern, token, complex_kind)
+      unless pattern.include?(I18n::Inflector::Config::Markers::PATTERN)
+        pattern = I18n::Inflector::Config::Markers::PATTERN + "#{complex_kind}{#{pattern}}"
+      end
+      super(locale, pattern, token, complex_kind)
+    end
 
-    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}"
+    def message
+      super + "pattern is malformed; token count differs from kind count"
     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
+  class DuplicatedInflectionToken < InflectionConfigurationException
 
-    attr_reader :original_kind, :kind, :token
+    attr_accessor :original_kind
 
-    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
+    def initialize(locale, token, kind, original_kind)
+      super(locale, token, kind)
+      @original_kind = original_kind
+    end
+
+    def message
+      super +
+      "token #{@token.inspect} " \
+      "was already assigned to the kind #{@original_kind.inspect}"
     end
 
   end
@@ -100,39 +202,63 @@ module I18n
   # 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
+  class BadInflectionAlias < InflectionConfigurationException
 
-    attr_reader :locale, :token, :kind, :pointer
+    attr_accessor :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 +
-            "points to an unknown token #{pointer.inspect}"
+      super(locale, token, kind)
+      @pointer = pointer
+    end
+
+    def message
+      what = token == :default ? "default token" : "alias #{@token.inspect}"
+      super +
+      "the #{what} " \
+      "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
+  class BadInflectionToken < InflectionConfigurationException
 
-    attr_reader :locale, :token, :kind, :description
+    attr_accessor :description
 
     def initialize(locale, token, kind=nil, description=nil)
-      @locale, @token, @kind, @description = locale, token, kind, description
-      kinn = kind.nil? ? "" : "of kind #{kind.inspect} "
-      if description.nil?
-        super "Inflection token #{token.inspect} " + kinn +
-              "for language #{locale.inspect} has a bad name"
+      super(locale, token, kind)
+      @description = description
+    end
+
+    def message
+      if @description.nil?
+        super +
+        "inflection token #{@token.inspect} " \
+        "has a bad name"
       else
-        super "Inflection token #{token.inspect} " + kinn +
-              "for language #{locale.inspect} has a bad description #{description.inspect}"
+        super +
+        "inflection token #{@token.inspect} " \
+        "has a bad description #{@description.inspect}"
       end
     end
 
   end
 
+
+  # This is raised when an inflection kind has a bad name
+  # or is not a root for a tree of tokens.
+  class BadInflectionKind < InflectionConfigurationException
+
+    def initialize(locale, kind)
+      super(locale, nil, kind)
+    end
+
+    def message
+        super +
+        "inflection kind #{@kind.inspect} has bad name or type"
+    end
+
+  end
+
 end

data/lib/i18n-inflector/hset.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains more intuitive version of Set.
+
+require 'set'
+
+module I18n
+  module Inflector
+
+    # This class keeps sets of data
+    class HSet < Set
+
+      # This method performs a fast check
+      # if an element exists in a set.
+      # 
+      # @return [Boolean]
+      def [](k)
+        @hash[k] == true
+      end
+
+    end
+
+  end
+end

data/lib/i18n-inflector/inflection_data.rb

@@ -22,6 +22,7 @@ module I18n
         @kinds          = Hash.new(false)
         @tokens         = Hash.new(DUMMY_TOKEN)
         @defaults       = Hash.new
+        @known_kinds    = nil
         @lazy_tokens    = LazyHashEnumerator.new(@tokens)
         @locale         = locale
       end
@@ -74,6 +75,7 @@ module I18n
         @tokens[token][:kind]         = kind.to_sym
         @tokens[token][:description]  = description.to_s
         @kinds[kind] = true
+        @known_kinds = nil
       end
 
       # Tests if the token is a true token.
@@ -319,7 +321,7 @@ module I18n
       # 
       # @return [Array<Symbol>] an array containing all the known kinds
       def get_kinds
-        @kinds.keys
+        @known_kinds ||= @kinds.keys
       end
 
       # Reads the default token of a kind.

data/lib/i18n-inflector/inflection_data_strict.rb

@@ -45,6 +45,7 @@ module I18n
         @tokens       = Hash.new(DUMMY_TOKENS)
         @lazy_tokens  = Hash.new(DUMMY_T_LAZY)
         @defaults     = Hash.new
+        @known_kinds  = nil
         @locale       = locale
       end
 
@@ -82,6 +83,7 @@ module I18n
         kind      = kind.to_sym
         kind_tree = @tokens[kind]
         if kind_tree.equal?(DUMMY_TOKENS)
+          @known_kinds = nil
           kind_tree = @tokens[kind] = Hash.new(DUMMY_TOKEN)
           @lazy_tokens[kind] = LazyHashEnumerator.new(kind_tree)
         end
@@ -252,7 +254,7 @@ module I18n
       # @return [Array<Symbol>] an array containing all the known strict
       #   kinds
       def get_kinds
-        @tokens.keys
+        @known_kinds ||= @tokens.keys
       end
 
       # Reads the default token of a strict kind.

data/lib/i18n-inflector/inflector.rb

@@ -4,7 +4,7 @@
 # Copyright:: (c) 2011 by Paweł Wilk
 # License::   This program is licensed under the terms of {file:LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
 # 
-# This file contains I18n::Inflector module,
+# This file contains a stub of I18n::Inflector module,
 # which extends I18n by adding the ability
 # to interpolate patterns containing inflection tokens
 # defined in translation data and manipulate on that data.
@@ -24,44 +24,6 @@ module I18n
 
   module Inflector
 
-    # @private
-    def get_reserved_keys
-      return I18n::RESERVED_KEYS                  if defined?(I18n::RESERVED_KEYS)
-      return I18n::Backend::Base::RESERVED_KEYS   if defined?(I18n::Backend::Base::RESERVED_KEYS)
-      return I18n::Backend::Simple::RESERVED_KEYS if defined?(I18n::Backend::Simple::RESERVED_KEYS)
-      return RESERVED_KEYS                        if defined?(RESERVED_KEYS)
-      []
-    end
-    module_function :get_reserved_keys
-
-    # Contains <tt>@</tt> string that is used to quickly fallback
-    # to standard +translate+ method if it's not found.
-    FAST_MATCHER  = '@'
-
-    # Contains a regular expression that catches patterns.
-    PATTERN       = /(.?)@([^\{]*)\{([^\}]+)\}/
-
-    # Contains a regular expression that catches tokens.
-    TOKENS        = /(?:([^\:\|]+):+([^\|]+)\1?)|([^:\|]+)/ 
-
-    # Contains a symbol that indicates an alias.
-    ALIAS_MARKER  = '@'
-
-    # Contains a symbol that indicates a named pattern.
-    NAMED_MARKER  = '@'
-
-    # Conatins a symbol used to separate multiple tokens.
-    OPERATOR_MULTI = ','
-
-    # Conatins a symbol used to mark tokens as negative.
-    OPERATOR_NOT  = '!'
-
-    # Contains a list of escape symbols that cause pattern to be escaped.
-    ESCAPES       = { '@' => true, '\\' => true }
-
-    # Reserved keys
-    INFLECTOR_RESERVED_KEYS = I18n::Inflector.get_reserved_keys
-
   end # module Inflector
 
 end # module I18n