i18n-inflector 1.0.11 → 2.0.0

data/lib/i18n-inflector/options.rb

@@ -0,0 +1,201 @@
+# 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 a class used to set up some options,
+# for engine.
+
+module I18n
+  module Inflector
+
+    # This class contains structures for keeping parsed translation data
+    # and basic operations.
+    # 
+    # All global options are available for current backend's inflector by
+    # calling:
+    #   I18n.backend.inflector.options.<option_name>
+    # or just:
+    #   I18n.inflector.options.<option_name>
+    # A global option may be overriden by passing a proper option to
+    # the translation method. Such option should have the name of a
+    # global option but prefixed with +inflector_+:
+    #   translate('welcome', :inflector_<option_name> => value)
+    class InflectionOptions
+
+      # This is a switch that enables extended error reporting. When it's enabled then
+      # errors are raised in case of unknown or empty tokens present in a pattern
+      # or in options. This switch is by default set to +false+.
+      # 
+      # @note Local option +:raises+ passed to the {I18n::Backend::Inflector#translate}
+      #   overrides this setting.
+      # 
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :raises
+
+      # This is a switch that enables you to use aliases in patterns. When it's enabled then
+      # aliases may be used in inflection patterns, not only true tokens. This operation
+      # may make your translation data a bit messy if you're not alert.
+      # That's why this switch is by default set to +false+.
+      # 
+      # @note Local option +:aliased_patterns+ passed to the {I18n::Backend::Inflector#translate}
+      #   overrides this setting.
+      # 
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :aliased_patterns
+
+      # When this switch is set to +true+ then inflector falls back to the default
+      # token for a kind if an inflection option passed to the {I18n::Backend::Inflector#translate} is unknown
+      # or +nil+. Note that the value of the default token will be
+      # interpolated only when this token is present in a pattern. This switch
+      # is by default set to +true+.
+      # 
+      # @note Local option +:unknown_defaults+ passed to the {I18n::Backend::Inflector#translate}
+      #   overrides this setting.
+      # 
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      # 
+      # @example YAML:
+      #    en:
+      #     i18n:
+      #       inflections:
+      #         gender:
+      #           n:       'neuter'
+      #           o:       'other'
+      #           default:  n
+      # 
+      #     welcome:         "Dear @{n:You|o:Other}"
+      #     welcome_free:    "Dear @{n:You|o:Other|Free}"
+      #   
+      # @example Example 1
+      #   
+      #   # :gender option is not present,
+      #   # unknown tokens in options are falling back to default
+      #    
+      #   I18n.t('welcome')
+      #   # => "Dear You"
+      #   
+      #   # :gender option is not present,
+      #   # unknown tokens from options are not falling back to default
+      #   
+      #   I18n.t('welcome', :unknown_defaults => false)
+      #   # => "Dear You"
+      # 
+      #   # other way of setting an option – globally
+      #   
+      #   I18n.inflector.options.unknown_defaults = false
+      #   I18n.t('welcome')
+      #   # => "Dear You"
+      #   
+      #   # :gender option is not present, free text is present,
+      #   # unknown tokens from options are not falling back to default
+      #   
+      #   I18n.t('welcome_free', :unknown_defaults => false)
+      #   # => "Dear You"
+      #   
+      # @example Example 2
+      #   
+      #   # :gender option is nil,
+      #   # unknown tokens from options are falling back to default token for a kind
+      #   
+      #   I18n.t('welcome', :gender => nil)
+      #   # => "Dear You"
+      #   
+      #   # :gender option is nil
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #   
+      #   I18n.t('welcome', :gender => nil, :unknown_defaults => false)
+      #   # => "Dear "
+      #   
+      #   # :gender option is nil, free text is present
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #   
+      #   I18n.t('welcome_free', :gender => nil, :unknown_defaults => false)
+      #   # => "Dear Free"
+      # 
+      # @example Example 3
+      #   
+      #   # :gender option is unknown,
+      #   # unknown tokens from options are falling back to default token for a kind
+      #   
+      #   I18n.t('welcome', :gender => :unknown_blabla)
+      #   # => "Dear You"
+      #   
+      #   # :gender option is unknown,
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #   
+      #   I18n.t('welcome', :gender => :unknown_blabla, :unknown_defaults => false)
+      #   # => "Dear "
+      #   
+      #   # :gender option is unknown, free text is present
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #   
+      #   I18n.t('welcome_free', :gender => :unknown_blabla, :unknown_defaults => false)
+      #   # => "Dear Free"
+      attr_accessor :unknown_defaults
+
+      # When this switch is set to +true+ then inflector falls back to the default
+      # token for a kind if the given inflection option is correct but doesn't exist in a pattern.
+      # 
+      # There might happend that the inflection option
+      # given to {#translate} method will contain some proper token, but that token
+      # will not be present in a processed pattern. Normally an empty string will
+      # be generated from such a pattern or a free text (if a local fallback is present
+      # in a pattern). You can change that behavior and tell interpolating routine to
+      # use the default token for a processed kind in such cases.
+      # 
+      # This switch is by default set to +false+.
+      # 
+      # @note Local option +:excluded_defaults+ passed to the {I18n::Backend::Inflector#translate}
+      #   overrides this setting.
+      # 
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      # 
+      # @example YAML:
+      #   en:
+      #     i18n:
+      #       inflections:
+      #         gender:
+      #           o:      "other"
+      #           m:      "male"
+      #           n:      "neuter"
+      #           default: n
+      #   
+      #     welcome:  'Dear @{n:You|m:Sir}'
+      # @example Usage of +:excluded_defaults+ option
+      #   I18n.t('welcome', :gender => :o)
+      #   # => "Dear "
+      #   
+      #   I18n.t('welcome', :gender => :o, :excluded_defaults => true)
+      #   # => "Dear You"
+      attr_accessor :excluded_defaults
+
+      # This method initializes all internal structures.
+      def initialize
+        reset
+      end
+
+      # This method resets all options to their default values.
+      # 
+      # @return [void]
+      def reset
+        @excluded_defaults  = false
+        @unknown_defaults   = true
+        @aliased_patterns   = false
+        @raises             = false
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/i18n-inflector/util.rb

@@ -0,0 +1,67 @@
+# 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 utility methods,
+# that are used by I18n::Inflector.
+
+module I18n
+  module Inflector
+
+    # This module contains some methods that are helpful.
+    module Util
+
+      protected
+
+      # Processes +locale+ name and validates
+      # if it's correct (not empty and not +nil+).
+      # 
+      # @note If the +locale+ is not correct, it
+      #   tries to use locale from {I18n.locale} and validates it
+      #   as well.
+      # @param [Symbol,String] locale the locale identifier
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @return [Symbol] the given locale or the global locale
+      def prep_locale(locale=nil)
+        locale ||= I18n.locale
+        raise I18n::InvalidLocale.new(locale) if locale.to_s.empty?
+        locale.to_sym
+      end
+
+      # This method is the internal helper that prepares arguments
+      # containing +token+, +kind+ and +locale+.
+      # 
+      # @note This method leaves +kind+ as is when it's +nil+ or empty. It sets
+      #   +token+ to +nil+ when it's empty.
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @raise [ArgumentError] if the count of arguments is invalid
+      # @return [Array<Symbol,Symbol,Symbol>] the array containing
+      #   cleaned and validated +token+, +kind+ and +locale+
+      # @overload tkl_args(token, kind, locale)
+      #   Prepares arguments containing +token+, +kind+ and +locale+.
+      #   @param [String,Hash] token the token
+      #   @param [String,Hash] kind the inflection kind
+      #   @param [String,Hash] locale the locale identifier
+      #   @return [Array<Symbol,Symbol,Symbol>] the array containing
+      #     cleaned and validated +token+, +kind+ and +locale+
+      # @overload tkl_args(token, locale)
+      #   Prepares arguments containing +token+ and +locale+.
+      #   @param [String,Hash] token the token
+      #   @param [String,Hash] locale the locale identifier
+      #   @return [Array<Symbol,Symbol,Symbol>] the array containing
+      #     cleaned and validated +token+, +kind+ and +locale+
+      def tkl_args(args)
+        token, kind, locale = case args.count
+        when 1 then [args[0], nil, nil]
+        when 2 then [args[0], nil, args[1]]
+        when 3 then args
+        else raise ArgumentError.new("wrong number of arguments: #{args.count} for (1..3)")
+        end
+        [token,kind,locale]
+      end
+
+    end
+  end
+end

data/lib/i18n-inflector/version.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:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
 # 
 # This file contains version information.
 
@@ -14,7 +14,7 @@ module I18n
     # @private
     EMAIL       = 'pw@gnu.org'
     # @private
-    VERSION     = '1.0.11'
+    VERSION     = '2.0.0'
     # @private
     NAME        = 'i18n-inflector'
     # @private

data/lib/i18n-inflector.rb

@@ -1,10 +1,14 @@
 # encoding: utf-8
 
 require 'i18n'
+
 require 'i18n-inflector/version'
 require 'i18n-inflector/errors'
+require 'i18n-inflector/util'
+require 'i18n-inflector/inflection_data'
+require 'i18n-inflector/options'
+require 'i18n-inflector/backend'
 require 'i18n-inflector/inflector'
 
 I18n::Backend::Simple.send(:include, I18n::Backend::Inflector)
 
-require 'i18n-inflector/shortcuts'

data/test/inflector_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class I18nBackendInflectionTest < Test::Unit::TestCase
+class I18nInflectorTest < Test::Unit::TestCase
   class Backend < I18n::Backend::Simple
     include I18n::Backend::Inflector
     include I18n::Backend::Fallbacks
@@ -27,16 +27,18 @@ class I18nBackendInflectionTest < Test::Unit::TestCase
     store_translations(:xx, 'welcome' => 'Dear @{f:Lady|m:Sir|n:You|All}!')
   end
 
-  test "inflector has methods to test its switches" do
-    assert_equal true,  I18n.backend.inflector_unknown_defaults   = true
-    assert_equal false, I18n.backend.inflector_excluded_defaults  = false
-    assert_equal false, I18n.backend.inflector_raises             = false
-    assert_equal false, I18n.backend.inflector_raises?
-    assert_equal true,  I18n.backend.inflector_unknown_defaults?
-    assert_equal false, I18n.backend.inflector_excluded_defaults?
+  test "backend inflector has methods to test its switches" do
+    assert_equal true,  I18n.inflector.options.unknown_defaults   = true
+    assert_equal false, I18n.inflector.options.excluded_defaults  = false
+    assert_equal false, I18n.inflector.options.aliased_patterns   = false
+    assert_equal false, I18n.inflector.options.raises             = false
+    assert_equal false, I18n.backend.inflector.options.raises
+    assert_equal true,  I18n.backend.inflector.options.unknown_defaults
+    assert_equal false, I18n.backend.inflector.options.excluded_defaults
+    assert_equal false, I18n.backend.inflector.options.aliased_patterns
   end
 
-  test "inflector store_translations: regenerates inflection structures when translations are loaded" do
+  test "backend inflector store_translations: regenerates inflection structures when translations are loaded" do
     store_translations(:xx, :i18n => { :inflections => { :gender => { :o => 'other' }}})
     store_translations(:xx, 'hi' => 'Dear @{f:Lady|o:Others|n:You|All}!')
     assert_equal 'Dear Others!',  I18n.t('hi', :gender => :o,       :locale => :xx)
@@ -45,13 +47,13 @@ class I18nBackendInflectionTest < Test::Unit::TestCase
     assert_equal 'Dear All!',     I18n.t('hi', :gender => :m,       :locale => :xx)
   end
 
-  test "inflector store_translations: raises I18n::DuplicatedInflectionToken when duplicated token is given" do
+  test "backend inflector store_translations: raises I18n::DuplicatedInflectionToken when duplicated token is given" do
     assert_raise I18n::DuplicatedInflectionToken do
       store_translations(:xx, :i18n => { :inflections => { :gender => { :o => 'other' }, :person => { :o => 'o' }}})
     end
   end
 
-  test "inflector store_translations: raises I18n::BadInflectionAlias when bad alias is given" do
+  test "backend inflector store_translations: raises I18n::BadInflectionAlias when bad alias is given" do
      assert_raise I18n::BadInflectionAlias do
        store_translations(:xx, :i18n => { :inflections => { :gender => { :o => '@nonexistant' }}})
      end
@@ -60,109 +62,104 @@ class I18nBackendInflectionTest < Test::Unit::TestCase
      end
    end
 
-   test "inflector store_translations: raises I18n::BadInflectionToken when duplicated token is given" do
+   test "backend inflector store_translations: raises I18n::BadInflectionToken when duplicated token is given" do
      assert_raise I18n::BadInflectionToken do
        store_translations(:xx, :i18n => { :inflections => { :gender => { :o => '@' }}})
        store_translations(:xx, :i18n => { :inflections => { :gender => { :tok => nil }}})
      end
    end
 
-  test "inflector translate: allows pattern-only translation data" do
+  test "backend inflector translate: allows pattern-only translation data" do
     store_translations(:xx, 'clear_welcome' => '@{f:Lady|m:Sir|n:You|All}')
     assert_equal 'Lady', I18n.t('clear_welcome', :gender => 'f', :locale => :xx)
   end
 
-  test "inflector translate: allows patterns to be escaped using @@ or \\@" do
+  test "backend inflector translate: allows patterns to be escaped using @@ or \\@" do
     store_translations(:xx, 'escaped_welcome' => '@@{f:AAAAA|m:BBBBB}')
     assert_equal '@{f:AAAAA|m:BBBBB}', I18n.t('escaped_welcome', :gender => 'f', :locale => :xx)
     store_translations(:xx, 'escaped_welcome' => '\@{f:AAAAA|m:BBBBB}')
     assert_equal '@{f:AAAAA|m:BBBBB}', I18n.t('escaped_welcome', :gender => 'f', :locale => :xx)
   end
 
-  test "inflector translate: picks Lady for :f gender option" do
+  test "backend inflector translate: picks Lady for :f gender option" do
     assert_equal 'Dear Lady!', I18n.t('welcome', :gender => :f, :locale => :xx)
   end
 
-  test "inflector translate: picks Lady for f gender option" do
+  test "backend inflector translate: picks Lady for f gender option" do
     assert_equal 'Dear Lady!', I18n.t('welcome', :gender => 'f', :locale => :xx)
   end
 
-  test "inflector translate: picks Sir for :m gender option"  do
+  test "backend inflector translate: picks Sir for :m gender option"  do
     assert_equal 'Dear Sir!', I18n.t('welcome', :gender => :m, :locale => :xx)
   end
 
-  test "inflector translate: picks Sir for :masculine gender option" do
+  test "backend inflector translate: picks Sir for :masculine gender option" do
     assert_equal 'Dear Sir!', I18n.t('welcome', :gender => :masculine, :locale => :xx)
   end
 
-  test "inflector translate: picks Sir for masculine gender option" do
+  test "backend inflector translate: picks Sir for masculine gender option" do
     assert_equal 'Dear Sir!', I18n.t('welcome', :gender => 'masculine', :locale => :xx)
   end
 
-  test "inflector translate: picks an empty string when no default token is present and no free text is there" do
+  test "backend inflector translate: picks an empty string when no default token is present and no free text is there" do
     store_translations(:xx, 'none_welcome' => '@{n:You|f:Lady}')
     assert_equal '', I18n.t('none_welcome', :gender => 'masculine', :locale => :xx)
   end
 
-  test "inflector translate: allows multiple patterns in the same data" do
+  test "backend inflector translate: allows multiple patterns in the same data" do
     store_translations(:xx, 'multiple_welcome' => '@@{f:AAAAA|m:BBBBB} @{f:Lady|m:Sir|n:You|All} @{f:Lady|All}@{m:Sir|All}@{n:You|All}')
     assert_equal '@{f:AAAAA|m:BBBBB} Sir AllSirAll', I18n.t('multiple_welcome', :gender => 'masculine', :locale => :xx)
   end
 
-  test "inflector translate: falls back to default for the unknown gender option" do
+  test "backend inflector translate: falls back to default for the unknown gender option" do
     assert_equal 'Dear You!', I18n.t('welcome', :gender => :unknown, :locale => :xx)
   end
 
-  test "inflector translate: falls back to default for a gender option set to nil" do
+  test "backend inflector translate: falls back to default for a gender option set to nil" do
     assert_equal 'Dear You!', I18n.t('welcome', :gender => nil, :locale => :xx)
   end
 
-  test "inflector translate: falls back to default for no gender option" do
+  test "backend inflector translate: falls back to default for no gender option" do
     assert_equal 'Dear You!', I18n.t('welcome', :locale => :xx)
   end
 
-  test "inflector translate: falls back to free text for the proper gender option but not present in pattern" do
+  test "backend inflector translate: falls back to free text for the proper gender option but not present in pattern" do
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :s, :locale => :xx)
   end
 
-  test "inflector translate: falls back to free text when :inflector_unknown_defaults is false" do
+  test "backend inflector translate: falls back to free text when :inflector_unknown_defaults is false" do
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :unknown,  :locale => :xx, :inflector_unknown_defaults => false)
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :s,        :locale => :xx, :inflector_unknown_defaults => false)
     assert_equal 'Dear All!', I18n.t('welcome', :gender => nil,       :locale => :xx, :inflector_unknown_defaults => false)
   end
 
-  test "inflector translate: falls back to default for no gender option when :inflector_unknown_defaults is false" do
+  test "backend inflector translate: falls back to default for no gender option when :inflector_unknown_defaults is false" do
     assert_equal 'Dear You!', I18n.t('welcome', :locale => :xx, :inflector_unknown_defaults => false)
   end
 
-  test "inflector translate: falls back to free text for the unknown gender option when global inflector_unknown_defaults is false" do
-    I18n.backend.inflector_unknown_defaults = false
+  test "backend inflector translate: falls back to free text for the unknown gender option when global inflector_unknown_defaults is false" do
+    I18n.inflector.options.unknown_defaults = false
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :unknown, :locale => :xx)
   end
 
-  test "inflector translate: falls back to default for the unknown gender option when global inflector_unknown_defaults is overriden" do
-    I18n.backend.inflector_unknown_defaults = false
+  test "backend inflector translate: falls back to default for the unknown gender option when global inflector_unknown_defaults is overriden" do
+    I18n.inflector.options.unknown_defaults = false
     assert_equal 'Dear You!', I18n.t('welcome', :gender => :unknown, :locale => :xx, :inflector_unknown_defaults => true)
   end
-    
-  test "inflector translate: falls back to default token for ommited gender option when :inflector_excluded_defaults is true" do
+
+  test "backend inflector translate: falls back to default token for ommited gender option when :inflector_excluded_defaults is true" do
     assert_equal 'Dear You!', I18n.t('welcome', :gender => :s, :locale => :xx, :inflector_excluded_defaults => true)
-    I18n.backend.inflector_excluded_defaults = true
+    I18n.inflector.options.excluded_defaults = true
     assert_equal 'Dear You!', I18n.t('welcome', :gender => :s, :locale => :xx)
   end
 
-  test "inflector translate: falls back to free text for ommited gender option when :inflector_excluded_defaults is false" do
+  test "backend inflector translate: falls back to free text for ommited gender option when :inflector_excluded_defaults is false" do
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :s, :locale => :xx, :inflector_excluded_defaults => false)
-    I18n.backend.inflector_excluded_defaults = false
+    I18n.inflector.options.excluded_defaults = false
     assert_equal 'Dear All!', I18n.t('welcome', :gender => :s, :locale => :xx)
   end
 
-  test "inflector translate: works with %{} patterns" do
-    store_translations(:xx, 'hi' => 'Dear @{f:Lady|m:%{test}}!')
-    assert_equal 'Dear Dude!', I18n.t('hi', :gender => :m, :locale => :xx, :test => "Dude")
-  end
-
-  test "inflector translate: raises I18n::InvalidOptionForKind when bad kind is given and inflector_raises is true" do
+  test "backend inflector translate: raises I18n::InvalidOptionForKind when bad kind is given and inflector_raises is true" do
     assert_nothing_raised I18n::InvalidOptionForKind do
       I18n.t('welcome', :locale => :xx, :inflector_raises => true)
     end
@@ -173,128 +170,212 @@ class I18nBackendInflectionTest < Test::Unit::TestCase
     assert_raise(I18n::InvalidOptionForKind) { I18n.t('welcome', :locale => :xx, :gender => "", :inflector_raises => true) }
     assert_raise(I18n::InvalidOptionForKind) { I18n.t('welcome', :locale => :xx, :gender => nil, :inflector_raises => true) }
     assert_raise I18n::InvalidOptionForKind do
-     I18n.backend.inflector_raises = true
+     I18n.inflector.options.raises = true
      I18n.t('welcome', :locale => :xx)
     end
   end
 
-  test "inflector translate: raises I18n::InvalidInflectionToken when bad token is given and inflector_raises is true" do
+  test "backend inflector translate: raises I18n::InvalidInflectionToken when bad token is given and inflector_raises is true" do
     store_translations(:xx, 'hi' => 'Dear @{f:Lady|o:BAD_TOKEN|n:You|First}!')
     assert_raise(I18n::InvalidInflectionToken) { I18n.t('hi', :locale => :xx, :inflector_raises => true) }
     assert_raise I18n::InvalidInflectionToken do
-      I18n.backend.inflector_raises = true
+      I18n.inflector.options.raises = true
       I18n.t('hi', :locale => :xx)
     end
   end
 
-  test "inflector translate: raises I18n::MisplacedInflectionToken when bad token is given and inflector_raises is true" do
+  test "backend inflector translate: raises I18n::MisplacedInflectionToken when bad token is given and inflector_raises is true" do
     store_translations(:xx, 'hi' => 'Dear @{f:Lady|i:Me|n:You|First}!')
     assert_raise(I18n::MisplacedInflectionToken) { I18n.t('hi', :locale => :xx, :inflector_raises => true) }
     assert_raise I18n::MisplacedInflectionToken do
-      I18n.backend.inflector_raises = true
+      I18n.inflector.options.raises = true
       I18n.t('hi', :locale => :xx)
     end
   end
 
+  test "backend inflector translate: works with %{} patterns" do
+    store_translations(:xx, 'hi' => 'Dear @{f:Lady|m:%{test}}!')
+    assert_equal 'Dear Dude!', I18n.t('hi', :gender => :m, :locale => :xx, :test => "Dude")
+  end
+
+  test "backend inflector translate: works with tokens separated by commas" do
+    store_translations(:xx, 'hi' => 'Dear @{f,m:Someone|n:You|All}!')
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :m, :locale => :xx)
+  end
+
+  test "backend inflector translate: works with negative tokens" do
+    store_translations(:xx, 'hi' => 'Dear @{!m:Lady|m:Sir|n:You|All}!')
+    assert_equal 'Dear Lady!',  I18n.t('hi', :gender => :n, :locale => :xx)
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Dear Lady!',  I18n.t('hi', :locale => :xx)
+    assert_equal 'Dear Lady!',  I18n.t('hi', :gender => :unknown, :locale => :xx)
+    store_translations(:xx, 'hi' => 'Hello @{!m:Ladies|n:You}')
+    assert_equal 'Hello Ladies',  I18n.t('hi', :gender => :n, :locale => :xx)
+    assert_equal 'Hello Ladies',  I18n.t('hi', :gender => :f, :locale => :xx)
+    assert_equal 'Hello ',        I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Hello Ladies',  I18n.t('hi', :locale => :xx)
+    store_translations(:xx, 'hi' => 'Hello @{!n:Ladies|m,f:You}')
+    assert_equal 'Hello ',  I18n.t('hi', :locale => :xx, :inflector_raises => true)
+  end
+
+  test "backend inflector translate: works with tokens separated by commas and negative tokens" do
+    store_translations(:xx, 'hi' => 'Dear @{!f,!m:Someone|m:Sir}!')
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :n, :locale => :xx)
+    store_translations(:xx, 'hi' => 'Dear @{!f,!m,n:Someone|m:Sir}!')
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :n, :locale => :xx)
+    store_translations(:xx, 'hi' => 'Dear @{!f,n:Someone|m:Sir|f:Lady}!')
+    assert_equal 'Dear Someone!', I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Dear Lady!',    I18n.t('hi', :gender => :f, :locale => :xx)
+    assert_equal 'Dear Someone!', I18n.t('hi', :locale => :xx)
+  end
+
+  test "backend inflector translate: works with aliased patterns" do
+    store_translations(:xx, 'hi' => 'Dear @{masculine:Sir|feminine:Lady|n:You|All}!')
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :m,         :locale => :xx, :inflector_aliased_patterns => true)
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :masculine, :locale => :xx, :inflector_aliased_patterns => true)
+    assert_equal 'Dear Lady!',  I18n.t('hi', :gender => :f,         :locale => :xx, :inflector_aliased_patterns => true)
+    assert_equal 'Dear All!',   I18n.t('hi', :gender => :s,         :locale => :xx, :inflector_aliased_patterns => true)
+    assert_equal 'Dear You!',   I18n.t('hi', :locale => :xx, :inflector_aliased_patterns => true)
+    I18n.inflector.options.aliased_patterns = true
+    assert_equal 'Dear Sir!', I18n.t('hi', :gender => :masculine, :locale => :xx)
+  end
+
   test "inflector inflected_locales: lists languages that support inflection" do
-    assert_equal [:xx], I18n.backend.inflected_locales
-    assert_equal [:xx], I18n.backend.inflected_locales(:gender)
+    assert_equal [:xx], I18n.inflector.inflected_locales
+    assert_equal [:xx], I18n.inflector.inflected_locales(:gender)
   end
 
-  test "inflector inflected_locale?: checks if a language supports inflection" do
-    assert_equal true, I18n.backend.inflected_locale?(:xx)
-    assert_equal false, I18n.backend.inflected_locale?(:pl)
+  test "inflector locale_supported?: checks if a language supports inflection" do
+    assert_equal true,  I18n.inflector.locale_supported?(:xx)
+    assert_equal false, I18n.inflector.locale_supported?(:pl)
+    assert_equal false, I18n.inflector.locale_supported?(nil)
+    assert_equal false, I18n.inflector.locale_supported?("")
     I18n.locale = :xx
-    assert_equal true, I18n.backend.inflected_locale?
+    assert_equal true,  I18n.inflector.locale_supported?
     I18n.locale = :pl
-    assert_equal false, I18n.backend.inflected_locale?
+    assert_equal false, I18n.inflector.locale_supported?
+    I18n.locale = nil
+    assert_equal false, I18n.inflector.locale_supported?
+    I18n.locale = ""
+    assert_equal false, I18n.inflector.locale_supported?
+  end
+
+  test "inflector has_token?: checks if a token exists" do
+    assert_equal true, I18n.inflector.has_token?(:neuter, :gender, :xx)
+    assert_equal true, I18n.inflector.has_token?(:neuter, :xx)
+    assert_equal true, I18n.inflector.has_token?(:f, :xx)
+    assert_equal true, I18n.inflector.has_token?(:you, :xx)
+    I18n.locale = :xx
+    assert_equal true, I18n.inflector.has_token?(:f)
+    assert_equal true, I18n.inflector.has_token?(:you)  
+    assert_equal false,I18n.inflector.has_token?(:faafaffafafa)
   end
 
-  test "inflector inflection_kind: checks what is the inflection kind of the given token" do
-    assert_equal :gender, I18n.backend.inflection_kind(:neuter, :xx)
-    assert_equal :gender, I18n.backend.inflection_kind(:f, :xx)
-    assert_equal :person, I18n.backend.inflection_kind(:you, :xx)
+  test "inflector kind: checks what is the inflection kind of the given token" do
+    assert_equal :gender, I18n.inflector.kind(:neuter, :xx)
+    assert_equal :gender, I18n.inflector.kind(:f, :xx)
+    assert_equal :person, I18n.inflector.kind(:you, :xx)
     I18n.locale = :xx
-    assert_equal :gender, I18n.backend.inflection_kind(:neuter)
-    assert_equal :gender, I18n.backend.inflection_kind(:f)
-    assert_equal :person, I18n.backend.inflection_kind(:you)  
-    assert_equal nil, I18n.backend.inflection_kind(:faafaffafafa)
+    assert_equal :gender, I18n.inflector.kind(:neuter)
+    assert_equal :gender, I18n.inflector.kind(:f)
+    assert_equal :person, I18n.inflector.kind(:you)  
+    assert_equal nil, I18n.inflector.kind(:faafaffafafa)
   end
 
-  test "inflector inflection_true_token: gets true token for a given token name" do
-    assert_equal :n, I18n.backend.inflection_true_token(:neuter, :xx)
-    assert_equal :f, I18n.backend.inflection_true_token(:f, :xx)
+  test "inflector true_token: gets true token for a given token name" do
+    assert_equal :n,  I18n.inflector.true_token(:neuter, :xx)
+    assert_equal :f,  I18n.inflector.true_token(:f, :xx)
     I18n.locale = :xx
-    assert_equal :n, I18n.backend.inflection_true_token(:neuter)
-    assert_equal :f, I18n.backend.inflection_true_token(:f)
-    assert_equal nil, I18n.backend.inflection_true_token(:faafaffafafa)
+    assert_equal :n,  I18n.inflector.true_token(:neuter)
+    assert_equal :f,  I18n.inflector.true_token(:f)
+    assert_equal :f,  I18n.inflector.true_token(:f, :xx)
+    assert_equal nil, I18n.inflector.true_token(:f, :person, :xx)
+    assert_equal nil, I18n.inflector.true_token(:f, :nokind, :xx)
+    assert_equal nil, I18n.inflector.true_token(:faafaffafafa)
   end
 
-  test "inflector available_inflection_kinds: lists inflection kinds" do
-    assert_not_nil I18n.backend.available_inflection_kinds(:xx)
-    assert_equal [:gender,:person], I18n.backend.available_inflection_kinds(:xx).sort{|k,v| k.to_s<=>v.to_s}
+  test "inflector has_true_token?: tests if true token exists for a given token name" do
+    assert_equal false, I18n.inflector.has_true_token?(:neuter, :xx)
+    assert_equal true,  I18n.inflector.has_true_token?(:f, :xx)
     I18n.locale = :xx
-    assert_equal [:gender,:person], I18n.backend.available_inflection_kinds.sort{|k,v| k.to_s<=>v.to_s}
+    assert_equal false, I18n.inflector.has_true_token?(:neuter)
+    assert_equal true,  I18n.inflector.has_true_token?(:f)
+    assert_equal true,  I18n.inflector.has_true_token?(:f, :xx)
+    assert_equal false, I18n.inflector.has_true_token?(:f, :person, :xx)
+    assert_equal false, I18n.inflector.has_true_token?(:f, :nokind, :xx)
+    assert_equal false, I18n.inflector.has_true_token?(:faafaffafafa)
   end
 
-  test "inflector inflection_tokens: lists inflection tokens" do
+  test "inflector kinds: lists inflection kinds" do
+    assert_not_nil I18n.inflector.kinds(:xx)
+    assert_equal [:gender,:person], I18n.inflector.kinds(:xx).sort{|k,v| k.to_s<=>v.to_s}
+    I18n.locale = :xx
+    assert_equal [:gender,:person], I18n.inflector.kinds.sort{|k,v| k.to_s<=>v.to_s}
+  end
+
+  test "inflector tokens: lists all inflection tokens including aliases" do
     h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
          :masculine=>"male",:feminine=>"female",:neuter=>"neuter",
          :neutral=>"neuter"}
     ha = h.merge(:i=>'I', :you=>'You')
-    assert_equal h, I18n.backend.inflection_tokens(:gender, :xx)
+    assert_equal h,   I18n.inflector.tokens(:gender, :xx)
     I18n.locale = :xx
-    assert_equal h, I18n.backend.inflection_tokens(:gender)
-    assert_equal ha, I18n.backend.inflection_tokens
+    assert_equal h,   I18n.inflector.tokens(:gender)
+    assert_equal ha,  I18n.inflector.tokens
   end
 
-  test "inflector inflection_true_tokens: lists true tokens" do
+  test "inflector true_tokens: lists true tokens" do
     h  = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange"}
     ha = h.merge(:i=>"I",:you=>"You")
-    assert_equal h, I18n.backend.inflection_true_tokens(:gender, :xx)
+    assert_equal h,   I18n.inflector.true_tokens(:gender, :xx)
     I18n.locale = :xx
-    assert_equal h, I18n.backend.inflection_true_tokens(:gender)
-    assert_equal ha, I18n.backend.inflection_true_tokens
+    assert_equal h,   I18n.inflector.true_tokens(:gender)
+    assert_equal ha,  I18n.inflector.true_tokens
   end
 
-  test "inflector inflection_raw_tokens: lists tokens in a so called raw format" do
+  test "inflector raw_tokens: lists tokens in a so called raw format" do
     h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
          :masculine=>:m,:feminine=>:f,:neuter=>:n,
          :neutral=>:n}
     ha = h.merge(:i=>'I',:you=>"You")
-    assert_equal h, I18n.backend.inflection_raw_tokens(:gender, :xx)
+    assert_equal h,   I18n.inflector.raw_tokens(:gender, :xx)
     I18n.locale = :xx
-    assert_equal h, I18n.backend.inflection_raw_tokens(:gender)
-    assert_equal ha, I18n.backend.inflection_raw_tokens    
+    assert_equal h,   I18n.inflector.raw_tokens(:gender)
+    assert_equal ha,  I18n.inflector.raw_tokens    
   end
 
-  test "inflector inflection_default_token: returns a default token for a kind" do
-    assert_equal :n, I18n.backend.inflection_default_token(:gender, :xx)
+  test "inflector default_token: returns a default token for a kind" do
+    assert_equal :n, I18n.inflector.default_token(:gender, :xx)
     I18n.locale = :xx
-    assert_equal :n, I18n.backend.inflection_default_token(:gender)
+    assert_equal :n, I18n.inflector.default_token(:gender)
   end
 
-  test "inflector inflection_aliases: lists aliases" do
+  test "inflector aliases: lists aliases" do
     a = {:masculine=>:m, :feminine=>:f, :neuter=>:n, :neutral=>:n}
-    assert_equal a, I18n.backend.inflection_aliases(:gender, :xx)
+    assert_equal a, I18n.inflector.aliases(:gender, :xx)
     I18n.locale = :xx
-    assert_equal a, I18n.backend.inflection_aliases(:gender)
-    assert_equal a, I18n.backend.inflection_aliases
+    assert_equal a, I18n.inflector.aliases(:gender)
+    assert_equal a, I18n.inflector.aliases
   end
 
-  test "inflector inflection_token_description: returns token's description" do
-    assert_equal "male", I18n.backend.inflection_token_description(:m, :xx)
+  test "inflector token_description: returns token's description" do
+    assert_equal "male",    I18n.inflector.token_description(:m, :xx)
     I18n.locale = :xx
-    assert_equal "male", I18n.backend.inflection_token_description(:m)
-    assert_equal nil, I18n.backend.inflection_token_description(:nonexistent, :xx)
-    assert_equal "neuter", I18n.backend.inflection_token_description(:neutral, :xx)
+    assert_equal "male",    I18n.inflector.token_description(:m)
+    assert_equal nil,       I18n.inflector.token_description(:nonexistent, :xx)
+    assert_equal "neuter",  I18n.inflector.token_description(:neutral, :xx)
   end
 
-  test "inflector inflection_is_alias?: tests whether a token is an alias" do
-      assert_equal true, I18n.backend.inflection_is_alias?(:neutral, :xx)
-      assert_equal false, I18n.backend.inflection_is_alias?(:you, :xx)
+  test "inflector has_alias?: tests whether a token is an alias" do
+      assert_equal true,  I18n.inflector.has_alias?(:neutral, :xx)
+      assert_equal false, I18n.inflector.has_alias?(:you, :xx)
+      assert_equal true,  I18n.inflector.has_alias?(:neutral, :gender, :xx)
+      assert_equal false, I18n.inflector.has_alias?(:you, :gender, :xx)
+      assert_equal false, I18n.inflector.has_alias?(:neutral, :nokind, :xx)
       I18n.locale = :xx
-      assert_equal true, I18n.backend.inflection_is_alias?(:neutral)
+      assert_equal true,  I18n.inflector.has_alias?(:neutral)
   end
-    
+
 end