i18n-inflector 2.0.1 → 2.1.0

data/lib/i18n-inflector/inflection_data.rb

@@ -4,8 +4,8 @@
 # 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 utility methods,
-# that are used by I18n::Inflector and I18n::Backend::Inflector.
+# This file contains class that is used to keep
+# inflection data.
 
 # @abstract This namespace is shared with I18n subsystem.
 module I18n
@@ -13,38 +13,50 @@ module I18n
 
     # This class contains structures for keeping parsed translation data
     # and basic operations for performing on them.
-    class InflectionData
+    class InflectionData < InflectionData_Strict
 
       # Initializes internal structures.
+      # 
+      # @param [Symbol,nil] locale the locale identifier for the object to be labeled with
       def initialize(locale=nil)
-        dummy_token = {:kind=>nil,:target=>nil,:description=>nil}
-        @kinds      = Hash.new(false)
-        @tokens     = Hash.new(dummy_token)
-        @defaults   = {}
-        @locale     = locale
+        @kinds          = Hash.new(false)
+        @tokens         = Hash.new(DUMMY_TOKEN)
+        @defaults       = Hash.new
+        @lazy_tokens    = LazyHashEnumerator.new(@tokens)
+        @locale         = locale
       end
 
-      # Locale that this database works on.
-      attr_reader :locale
-
-      # Adds an alias (overwriting existing alias).
+      # Adds an alias (overwriting an existing alias).
       # 
-      # @param [Symbol] name the name of an alias
-      # @param [Symbol] target the target token for the given +alias+
       # @return [Boolean] +true+ if everything went ok, +false+ otherwise
-      #  (in case of bad or +nil+ names or non-existent targets)
-      def add_alias(name, target)
+      #     (in case of bad or +nil+ names or non-existent targets)
+      # @overload add_alias(name, target)
+      #   Adds an alias (overwriting an existing alias).
+      #   @param [Symbol] name the name of an alias
+      #   @param [Symbol] target the target token for the given +alias+
+      #   @return [Boolean] +true+ if everything went ok, +false+ otherwise
+      #     (in case of bad or +nil+ names or non-existent targets)
+      # @overload add_alias(name, target, kind)
+      #   Adds an alias (overwriting an existing alias) if the given
+      #   +kind+ matches the kind of the given target.
+      #   @param [Symbol] name the name of an alias
+      #   @param [Symbol] target the target token for the given +alias+
+      #   @param [Symbol] kind the optional kind of a taget
+      #   @return [Boolean] +true+ if everything went ok, +false+ otherwise
+      #     (in case of bad or +nil+ names or non-existent targets)
+      def add_alias(name, target, kind=nil)
         target  = target.to_s
         name    = name.to_s
         return false if (name.empty? || target.empty?)
+        kind    = nil if kind.to_s.empty? unless kind.nil?
         name    = name.to_sym
         target  = target.to_sym
-        kind    = get_kind(target)
-        return false if kind.nil?
+        t_kind  = get_kind(target)
+        return false if (t_kind.nil? || (!kind.nil? && t_kind != kind))
         @tokens[name] = {}
-        @tokens[name][:kind]         = kind
-        @tokens[name][:target]       = target
-        @tokens[name][:description]  = @tokens[target][:description]
+        @tokens[name][:kind]        = kind
+        @tokens[name][:target]      = target
+        @tokens[name][:description] = @tokens[target][:description]
         true
       end
 
@@ -53,8 +65,10 @@ module I18n
       # @param [Symbol] token the name of a token to add
       # @param [Symbol] kind the kind of a token
       # @param [String] description the description of a token
-      # @return [void]
+      # @return [Boolean] +true+ if everything went ok, +false+ otherwise
+      #  (in case of bad names or non-existent targets)
       def add_token(token, kind, description)
+        return false if (token.to_s.empty? || kind.to_s.empty? || description.nil?)
         token = token.to_sym
         @tokens[token] = {}
         @tokens[token][:kind]         = kind.to_sym
@@ -62,16 +76,6 @@ module I18n
         @kinds[kind] = true
       end
 
-      # Sets the default token for a kind.
-      # 
-      # @param [Symbol] kind the kind to which the default
-      #   token should be assigned
-      # @param [Symbol] target the token to set
-      # @return [void]
-      def set_default_token(kind, target)
-        @defaults[kind.to_sym] = target.to_sym
-      end
-
       # Tests if the token is a true token.
       # 
       # @overload has_true_token?(token)
@@ -81,6 +85,7 @@ module I18n
       #     a token and not an alias, +false+ otherwise 
       # @overload has_true_token?(token, kind)
       #   Tests if the token is a true token.
+      #   The kind will work as the expectation filter.
       #   @param [Symbol] token the identifier of a token
       #   @param [Symbol] kind the identifier of a kind
       #   @return [Boolean] +true+ if the given +token+ is
@@ -102,6 +107,7 @@ module I18n
       #     (which may be an alias) exists
       # @overload has_token(token, kind)
       #   Tests if a token (or alias) is present.
+      #   The kind will work as the expectation filter.
       #   @param [Symbol] token the identifier of a token
       #   @param [Symbol] kind the identifier of a kind
       #   @return [Boolean] +true+ if the given +token+ 
@@ -129,15 +135,16 @@ module I18n
         @defaults.has_key?(kind)
       end
 
-      # Tests if a given alias is really an alias.
+      # Tests if the given alias is really an alias.
       # 
       # @overload has_alias?(alias_name)
-      #   Tests if a given alias is really an alias.
+      #   Tests if the given alias is really an alias.
       #   @param [Symbol] alias_name the identifier of an alias
       #   @return [Boolean] +true+ if the given alias is really an alias,
       #     +false+ otherwise
       # @overload has_alias?(alias_name, kind)
-      #   Tests if a given alias is really an alias.
+      #   Tests if the given alias is really an alias.
+      #   The kind will work as the expectation filter.
       #   @param [Symbol] alias_name the identifier of an alias
       #   @param [Symbol] kind the identifier of a kind
       #   @return [Boolean] +true+ if the given alias is really an alias
@@ -148,45 +155,49 @@ module I18n
         kind.nil? ? true : o[:kind] == kind
       end
 
-      # Reads the all the true tokens (not aliases).
+      # Reads all the true tokens (not aliases).
       # 
       # @return [Hash] the true tokens in a
       #     form of Hash (<tt>token => description</tt>)
-      # @overload get_true_tokens(kind)
-      #   Reads the all the true tokens (not aliases).
+      # @overload get_true_tokens
+      #   Reads all the true tokens (not aliases).
       #   @return [Hash] the true tokens in a
       #     form of Hash (<tt>token => description</tt>)
       # @overload get_true_tokens(kind)
-      #   Reads the all the true tokens (not aliases).
+      #   Reads all the true tokens (not aliases) of the given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the true tokens of the given kind in a
+      #   @return [Hash] the true tokens in a
       #     form of Hash (<tt>token => description</tt>)
       def get_true_tokens(kind=nil)
-        tokens = @tokens.reject{|k,v| !v[:target].nil?}
-        tokens = tokens.reject{|k,v| v[:kind]!=kind} unless kind.nil?
-        tokens.merge(tokens){|k,v| v[:description]}
+        t = @lazy_tokens
+        t = t.select  { |token,data| data[:kind] == kind  } unless kind.nil?
+        t.select      { |token,data| data[:target].nil?   }.
+          map         { |token,data| data[:description]   }.
+          to_h
       end
 
-      # Reads the all the aliases.
+      # Reads all the aliases.
       # 
       # @return [Hash] the aliases in a
       #     form of Hash (<tt>alias => target</tt>)
-      # @overload get_aliases(kind)
-      #   Reads the all the aliases.
+      # @overload get_aliases
+      #   Reads all the aliases.
       #   @return [Hash] the aliases in a
       #     form of Hash (<tt>alias => target</tt>)
       # @overload get_aliases(kind)
-      #   Reads the all the aliases.
+      #   Reads all the aliases of the given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the aliases of the given kind in a
+      #   @return [Hash] the aliases in a
       #     form of Hash (<tt>alias => target</tt>)
       def get_aliases(kind=nil)
-        aliases = @tokens.reject{|k,v| v[:target].nil?}
-        aliases = aliases.reject{|k,v| v[:kind]!=kind} unless kind.nil?
-        aliases.merge(aliases){|k,v| v[:target]}
+        t = @lazy_tokens
+        t = t.select  { |token,data| data[:kind] == kind  } unless kind.nil?
+        t.reject      { |token,data| data[:target].nil?   }.
+          map         { |token,data| data[:target]        }.
+          to_h
       end
 
-      # Reads the all the tokens in a way that it is possible to
+      # Reads all the tokens in a way that it is possible to
       # distinguish true tokens from aliases.
       # 
       # @note True tokens have descriptions (String) and aliases
@@ -194,55 +205,85 @@ module I18n
       # @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description|target</tt>)
       # @overload get_raw_tokens
-      #   Reads the all the tokens.
+      #   Reads all the tokens in a way that it is possible to
+      #   distinguish true tokens from aliases.
       #   @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description|target</tt>)
       # @overload get_raw_tokens(kind)
-      #   Reads the all the tokens.
+      #   Reads all the tokens of the given +kind+ in a way
+      #   that it is possible to distinguish true tokens from aliases.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the tokens of the given kind in a
+      #   @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description|target</tt>)
       def get_raw_tokens(kind=nil)
-        get_true_tokens(kind).merge(get_aliases(kind))
+        t = @lazy_tokens
+        t = t.select  { |token,data| data[:kind] == kind } unless kind.nil?
+        t.map         { |token,data| data[:target] || data[:description]  }.
+          to_h
       end
 
-      # Reads the all the tokens (including aliases).
+      # Reads all the tokens (including aliases).
       # 
-      # @note Use {get_raw_tokens} if you want to distinguish
+      # @note Use {#get_raw_tokens} if you want to distinguish
       #   true tokens from aliases.
       # @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description</tt>)
-      # @overload get_raw_tokens(kind)
-      #   Reads the all the tokens (including aliases).
+      # @overload get_tokens
+      #   Reads all the tokens (including aliases).
       #   @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description</tt>)
-      # @overload get_raw_tokens(kind)
-      #   Reads the all the tokens (including aliases).
+      # @overload get_tokens(kind)
+      #   Reads all the tokens (including aliases) of the
+      #   given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the tokens of the given kind in a
+      #   @return [Hash] the tokens in a
       #     form of Hash (<tt>token => description</tt>)
       def get_tokens(kind=nil)
-        tokens = @tokens
-        tokens = tokens.reject{|k,v| v[:kind]!=kind} unless kind.nil?
-        tokens.merge(tokens){|k,v| v[:description]}
+        t = @lazy_tokens
+        t = t.select  { |token,data| data[:kind] == kind } unless kind.nil?
+        t.map         { |token,data| data[:description]  }.
+          to_h
       end
 
       # Gets a target token for the alias.
       # 
-      # @param [Symbol] alias_name the identifier of an alias
       # @return [Symbol,nil] the token that the given alias points to
       #   or +nil+ if it isn't really an alias
-      def get_target_for_alias(alias_name)
+      # @overload get_target_for_alias(alias_name)
+      #   Gets a target token for the alias.
+      #   @param [Symbol] alias_name the identifier of an alias
+      #   @return [Symbol,nil] the token that the given alias points to
+      #     or +nil+ if it isn't really an alias
+      # @overload get_target_for_alias(alias_name, kind)
+      #   Gets a target token for the alias that's +kind+ is given.
+      #   @param [Symbol] alias_name the identifier of an alias
+      #   @param [Symbol] kind the identifier of a kind
+      #   @return [Symbol,nil] the token that the given alias points to
+      #     or +nil+ if it isn't really an alias
+      def get_target_for_alias(alias_name, kind=nil)
         @tokens[alias_name][:target]
       end
 
       # Gets a kind of the given token or alias.
       # 
-      # @param [Symbol] token identifier of a token
       # @return [Symbol,nil] the kind of the given +token+
       #   or +nil+ if the token is unknown
-      def get_kind(token)
-        @tokens[token][:kind]
+      # @overload get_kind(token)
+      #   Gets a kind of the given token or alias.
+      #   @param [Symbol] token identifier of a token
+      #   @return [Symbol,nil] the kind of the given +token+
+      #     or +nil+ if the token is unknown
+      # @overload get_kind(token, kind)
+      #   Gets a kind of the given token or alias.
+      #   The kind will work as the expectation filter.
+      #   @param [Symbol] token identifier of a token
+      #   @param [Symbol] kind the identifier of a kind
+      #   @return [Symbol,nil] the kind of the given +token+
+      #     or +nil+ if the token is unknown
+      def get_kind(token, kind=nil)
+        k = @tokens[token][:kind]
+        return k if (kind.nil? || kind == k)
+        nil
       end
 
       # Gets a true token for the given identifier.
@@ -250,19 +291,21 @@ module I18n
       # @note If the given +token+ is really an alias it will
       #   be resolved and the real token pointed by that alias
       #   will be returned.
+      # @return [Symbol,nil] the true token for the given +token+
+      #   or +nil+
       # @overload get_true_token(token)
-      #   Gets a true token for the given token identifier.
+      #   Gets a true token for the given +token+ identifier.
       #   @param [Symbol] token the identifier of a token
       #   @return [Symbol,nil] the true token for the given +token+
       #     or +nil+ if the token is unknown
       # @overload get_true_token(token, kind)
-      #   Gets a true token for the given token identifier and the
-      #     given kind.
+      #   Gets a true token for the given +token+ identifier and the
+      #   given +kind+. The kind will work as the expectation filter.
       #   @param [Symbol] token the identifier of a token
       #   @param [Symbol] kind the identifier of a kind
       #   @return [Symbol,nil] the true token for the given +token+
-      #     or +nil+ if the token is unknown or is not kind of the
-      #     given kind
+      #     or +nil+ if the token is unknown or is not a kind of the
+      #     given +kind+
       def get_true_token(token, kind=nil)
         o = @tokens[token]
         k = o[:kind]
@@ -289,38 +332,23 @@ module I18n
         @defaults[kind]
       end
 
-      # Gets a description of a token or alias.
-      # 
+      # Gets a description of a token or an alias.
       # @note If the token is really an alias it will resolve the alias first.
-      # @param [Symbol] token the identifier of a token
       # @return [String,nil] the string containing description of the given
       #   token (which may be an alias) or +nil+ if the token is unknown
-      def get_description(token)
-        @tokens[token][:description]
-      end
-
-      # This method validates default tokens assigned
-      # for kinds and replaces targets with true tokens
-      # if they are aliases.
-      # 
-      # @return [nil,Array<Symbol>] +nil+ if everything went fine,
-      #   two dimensional array containing kind and target
-      #   in case of error while geting a token
-      def validate_default_tokens
-        @defaults.each_pair do |kind, pointer|
-          ttok = get_true_token(pointer)
-          return [kind, pointer] if ttok.nil?
-          set_default_token(kind, ttok) 
-        end
-        return nil
-      end
-
-      # Test if the inflection data have no elements.
-      # 
-      # @return [Boolean] +true+ if the inflection data
-      #   have no elements
-      def empty?
-        @tokens.empty?
+      # @overload get_description(token)
+      #   Gets a description of a token or an alias.
+      #   @param [Symbol] token the identifier of a token
+      #   @return [String,nil] the string containing description of the given
+      #     token (which may be an alias) or +nil+ if the token is unknown
+      # @overload get_description(token, kind)
+      #   Gets a description of a token or an alias of the given +kind+
+      #   @param [Symbol] token the identifier of a token
+      #   @param [Symbol] kind the identifier of a kind
+      #   @return [String,nil] the string containing description of the given
+      #     token (which may be an alias) or +nil+ if the token is unknown
+      def get_description(token, kind=nil)
+        @tokens[token][:description] if (kind.nil? || @tokens[token][:kind] == kind)
       end
 
     end # InflectionData

data/lib/i18n-inflector/inflection_data_strict.rb

@@ -0,0 +1,290 @@
+# 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 class that is used to keep
+# inflection data for strict kinds.
+
+# @abstract This namespace is shared with I18n subsystem.
+module I18n
+  module Inflector
+
+    # This class contains structures for keeping parsed translation data
+    # and basic operations for strict kinds and tokens assigned to them.
+    # Methods in this class vary from methods from {I18n::Inflector::InflectionData}
+    # in a way that +kind+ argument is usually required, not optional, since
+    # managing the strict kinds requires a kind of any token to be always known.
+    class InflectionData_Strict
+
+      # This constant contains a dummy hash for an empty token. It makes
+      # chaining calls to internal data easier.
+      DUMMY_TOKEN   = {:kind=>nil, :target=>nil, :description=>nil}.freeze
+
+      # This constant contains a dummy hash of hashes for tokens collection.
+      # It makes chaining calls to internal data easier.
+      DUMMY_TOKENS  = Hash.new(DUMMY_TOKEN).freeze
+
+      # This constant contains a dummy iterator for hash of hashes.
+      # It makes chaining calls to internal data easier.
+      DUMMY_T_LAZY  = LazyHashEnumerator.new(DUMMY_TOKENS).freeze
+
+      # This constant contains a dummy hash. It makes
+      # chaining calls to internal data easier.
+      DUMMY_HASH    = Hash.new.freeze
+
+      # Locale that this database works for.
+      attr_reader :locale
+
+      # Initializes internal structures.
+      # 
+      # @param [Symbol,nil] locale the locale identifier for
+      #   the object to be labeled with
+      def initialize(locale=nil)
+        @tokens       = Hash.new(DUMMY_TOKENS)
+        @lazy_tokens  = Hash.new(DUMMY_T_LAZY)
+        @defaults     = Hash.new
+        @locale       = locale
+      end
+
+      # Adds an alias (overwriting existing alias).
+      # 
+      # @param [Symbol] name the name of an alias
+      # @param [Symbol] target the target token for the created alias
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if everything went ok, +false+ otherwise
+      #  (in case of bad names or non-existent targets)
+      def add_alias(name, target, kind)
+        return false if (name.nil? || target.nil? || kind.nil?)
+        return false if (name.to_s.empty? || target.to_s.empty? || kind.to_s.empty?)
+        name    = name.to_sym
+        target  = target.to_sym
+        kind    = kind.to_sym
+        k       = @tokens[kind]
+        return false unless k.has_key?(target)
+        token               = k[name] = {}
+        token[:description] = k[target][:description]
+        token[:target]      = target
+        true
+      end
+
+      # Adds a token (overwriting existing token).
+      # 
+      # @param [Symbol] token the name of a token to add
+      # @param [Symbol] kind the identifier of a kind
+      # @param [String] description the description of a token
+      # @return [Boolean] +true+ if everything went ok, +false+ otherwise
+      #  (in case of bad names)
+      def add_token(token, kind, description)
+        return false if (token.to_s.empty? || kind.to_s.empty? || description.nil?)
+        token     = token.to_sym
+        kind      = kind.to_sym
+        kind_tree = @tokens[kind]
+        if kind_tree.equal?(DUMMY_TOKENS)
+          kind_tree = @tokens[kind] = Hash.new(DUMMY_TOKEN)
+          @lazy_tokens[kind] = LazyHashEnumerator.new(kind_tree)
+        end
+        token = kind_tree[token] = {}
+        token[:description] = description.to_s
+        true
+      end
+
+      # Sets the default token for the given strict kind.
+      # 
+      # @param [Symbol] kind the kind to which the default
+      #   token should be assigned
+      # @param [Symbol] target the token to set
+      # @return [void]
+      def set_default_token(kind, target)
+        @defaults[kind.to_sym] = target.to_sym
+      end
+
+      # Tests if the given token of the given
+      # strict kind is a true token.
+      # 
+      # @param [Symbol] token the identifier of a token
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if the given +token+ is
+      #   a token and not an alias, and is a kind of
+      #   the given kind, +false+ otherwise 
+      def has_true_token?(token, kind)
+        @tokens[kind].has_key?(token) && @tokens[kind][token][:target].nil?
+      end
+
+      # Tests if the given token (or alias) of the
+      # given strict kind is present.
+      # 
+      # @param [Symbol] token the identifier of a token
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if the given +token+ 
+      #   (which may be an alias) exists and if kind of
+      #   the given kind
+      def has_token?(token, kind)
+       @tokens[kind].has_key?(token)
+      end
+
+      # Tests if a strict kind exists.
+      # 
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if the given +kind+ exists
+      def has_kind?(kind)
+        @tokens.has_key?(kind)
+      end
+
+      # Tests if the given strict kind has a default
+      # token assigned.
+      # 
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if there is a default
+      #   token of the given kind
+      def has_default_token?(kind)
+        @defaults.has_key?(kind)
+      end
+
+      # Tests if the given alias of the given strict
+      # kind is really an alias.
+      # 
+      # @param [Symbol] alias_name the identifier of an alias
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Boolean] +true+ if the given alias is really an alias
+      #   being a kind of the given kind, +false+ otherwise
+      def has_alias?(alias_name, kind)
+        not @tokens[kind][alias_name][:target].nil?
+      end
+
+      # Reads all the true tokens (not aliases) of the
+      # given strict kind.
+      # 
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Hash] the true tokens of the given kind in a
+      #   form of Hash (<tt>token => description</tt>)
+      def get_true_tokens(kind)
+        @lazy_tokens[kind].
+        reject { |token,data| !data[:target].nil? }.
+        map    { |token,data| data[:description]  }.
+        to_h
+      end
+
+      # Reads all the aliases of the given strict kind.
+      # 
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Hash] the aliases of the given kind in a
+      #   form of Hash (<tt>alias => target</tt>)
+      def get_aliases(kind)
+        @lazy_tokens[kind].
+        reject { |token,data| data[:target].nil?  }.
+        map    { |token,data| data[:target]       }.
+        to_h
+      end
+
+      # Reads all the tokens of the given strict kind
+      # in a way that it is possible to
+      # distinguish true tokens from aliases.
+      # 
+      # @note True tokens have descriptions (String) and aliases
+      #   have targets (Symbol) assigned.
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Hash] the tokens of the given kind in a
+      #   form of Hash (<tt>token => description|target</tt>)
+      def get_raw_tokens(kind)
+        @lazy_tokens[kind].
+        map { |token,data| data[:target] || data[:description] }.
+        to_h
+      end
+
+      # Reads all the tokens (including aliases) of the given
+      # strict kind.
+      # 
+      # @note Use {#get_raw_tokens} if you want to distinguish
+      #   true tokens from aliases.
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Hash] the tokens of the given kind in a
+      #   form of Hash (<tt>token => description</tt>)
+      def get_tokens(kind)
+        @lazy_tokens[kind].map{ |token,data| data[:description] }.to_h
+      end
+
+      # Gets a target token for the given alias of a strict kind.
+      # 
+      # @param [Symbol] alias_name the identifier of an alias
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Symbol,nil] the token that the given alias points to
+      #   or +nil+ if it isn't really an alias
+      def get_target_for_alias(alias_name, kind)
+        @tokens[kind][alias_name][:target]
+      end
+
+      # Gets a strict kind of the given token or alias.
+      # 
+      # @note This method may be concidered dummy since there is a
+      #   need to give the inflection kind, but it's here in order
+      #   to preserve compatibility with the same method from
+      #   {I18n::Inflector::InflectionData} which guesses the kind.
+      # @param [Symbol] token identifier of a token
+      # @param [Symbol] kind the identifier of a kind (expectations filter)
+      # @return [Symbol,nil] the kind of the given +token+
+      #   or +nil+ if the token is unknown or is not of the given kind
+      def get_kind(token, kind)
+        @tokens[kind].has_key?(token) ? kind : nil
+      end
+
+      # Gets a true token (of the given strict kind) for the given
+      # identifier.
+      # 
+      # @note If the given +token+ is really an alias it will
+      #   be resolved and the real token pointed by that alias
+      #   will be returned.
+      # @param [Symbol] token the identifier of a token
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Symbol,nil] the true token for the given +token+
+      #   or +nil+ if the token is unknown or is not a kind of the
+      #   given +kind+
+      def get_true_token(token, kind)
+        o = @tokens[kind]
+        return nil unless o.has_key?(token)
+        o = o[token]
+        o[:target].nil? ? token : o[:target]
+      end
+
+      # Gets all known strict kinds.
+      # 
+      # @return [Array<Symbol>] an array containing all the known strict
+      #   kinds
+      def get_kinds
+        @tokens.keys
+      end
+
+      # Reads the default token of a strict kind.
+      # 
+      # @note It will always return true token (not an alias).
+      # @param [Symbol] kind the identifier of a kind
+      # @return [Symbol,nil] the default token of the given +kind+
+      #   or +nil+ if there is no default token set
+      def get_default_token(kind)
+        @defaults[kind]
+      end
+
+      # Gets a description of a token or alias belonging to a strict kind.
+      # 
+      # @note If the token is really an alias it will resolve the alias first.
+      # @param [Symbol] token the identifier of a token
+      # @param [Symbol] kind the identifier of a kind
+      # @return [String,nil] the string containing description of the given
+      #   token (which may be an alias) or +nil+ if the token is unknown
+      def get_description(token, kind)
+        @tokens[kind][token][:description]
+      end
+
+      # Test if the inflection data have no elements.
+      # 
+      # @return [Boolean] +true+ if the inflection data
+      #   have no elements
+      def empty?
+        @tokens.empty?
+      end
+
+    end # InflectionData_Strict
+
+  end
+end