i18n-inflector 2.5.1 → 2.6.1

data/lib/i18n-inflector/hset.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains more intuitive version of Set.
 

data/lib/i18n-inflector/inflection_data.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains class that is used to keep
 # inflection data.
@@ -21,9 +21,9 @@ module I18n
       def initialize(locale=nil)
         @kinds          = Hash.new(false)
         @tokens         = Hash.new(DUMMY_TOKEN)
-        @defaults       = Hash.new
-        @known_kinds    = nil
         @lazy_tokens    = LazyHashEnumerator.new(@tokens)
+        @lazy_kinds     = LazyArrayEnumerator.new(@kinds)
+        @defaults       = Hash.new
         @locale         = locale
       end
 
@@ -75,7 +75,6 @@ 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.
@@ -157,94 +156,95 @@ module I18n
         kind.nil? ? true : o[:kind] == kind
       end
 
-      # Reads all the true tokens (not aliases).
+      # Iterates through all the true tokens (not aliases).
       # 
-      # @return [Hash] the true tokens in a
-      #     form of Hash (<tt>token => description</tt>)
-      # @overload get_true_tokens
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @overload each_true_token
       #   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)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @overload each_true_token(kind)
       #   Reads all the true tokens (not aliases) of the given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the true tokens in a
-      #     form of Hash (<tt>token => description</tt>)
-      def get_true_tokens(kind=nil)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      def each_true_token(kind=nil, &block)
         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
+          map         { |token,data| data[:description]   }.each(&block)
       end
 
-      # Reads all the aliases.
+      # Iterates through all the aliases.
       # 
-      # @return [Hash] the aliases in a
-      #     form of Hash (<tt>alias => target</tt>)
-      # @overload get_aliases
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>alias => target</tt>)
+      # @yield [alias, target] optional block in which each alias will be yielded
+      # @yieldparam [Symbol] alias an alias
+      # @yieldparam [Symbol] target a name of the target token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @overload each_alias
       #   Reads all the aliases.
-      #   @return [Hash] the aliases in a
-      #     form of Hash (<tt>alias => target</tt>)
-      # @overload get_aliases(kind)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>alias => target</tt>)
+      # @overload each_alias(kind)
       #   Reads all the aliases of the given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the aliases in a
-      #     form of Hash (<tt>alias => target</tt>)
-      def get_aliases(kind=nil)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>alias => target</tt>)
+      def each_alias(kind=nil, &block)
         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
+          map         { |token,data| data[:target]        }.each(&block)
       end
 
-      # Reads all the tokens in a way that it is possible to
+      # Iterates through all the tokens 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.
-      # @return [Hash] the tokens in a
-      #     form of Hash (<tt>token => description|target</tt>)
-      # @overload get_raw_tokens
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      # @yield [token, value] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [Symbol, String] value a description string for a token or a target (if alias)
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @overload each_raw_token
       #   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)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      # @overload each_raw_token(kind)
       #   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 in a
-      #     form of Hash (<tt>token => description|target</tt>)
-      def get_raw_tokens(kind=nil)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      def each_raw_token(kind=nil, &block)
         t = @lazy_tokens
         t = t.select  { |token,data| data[:kind] == kind } unless kind.nil?
         t.map         { |token,data| data[:target] || data[:description]  }.
-          to_h
+        each(&block)
       end
 
-      # Reads all the tokens (including aliases).
+      # Iterates through all the tokens (including aliases).
       # 
-      # @note Use {#get_raw_tokens} if you want to distinguish
+      # @note Use {#each_raw_token} if you want to distinguish
       #   true tokens from aliases.
-      # @return [Hash] the tokens in a
-      #     form of Hash (<tt>token => description</tt>)
-      # @overload get_tokens
+      # @return return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      # @overload each_token
       #   Reads all the tokens (including aliases).
-      #   @return [Hash] the tokens in a
-      #     form of Hash (<tt>token => description</tt>)
-      # @overload get_tokens(kind)
+      #   @return return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @overload each_token(kind)
       #   Reads all the tokens (including aliases) of the
       #   given +kind+.
       #   @param [Symbol] kind the identifier of a kind
-      #   @return [Hash] the tokens in a
-      #     form of Hash (<tt>token => description</tt>)
-      def get_tokens(kind=nil)
+      #   @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      def each_token(kind=nil, &block)
         t = @lazy_tokens
         t = t.select  { |token,data| data[:kind] == kind } unless kind.nil?
-        t.map         { |token,data| data[:description]  }.
-          to_h
+        t.map         { |token,data| data[:description]  }.each(&block)
       end
 
       # Gets a target token for the alias.
@@ -317,13 +317,6 @@ module I18n
         k == kind ? r : nil
       end
 
-      # Gets all known kinds.
-      # 
-      # @return [Array<Symbol>] an array containing all the known kinds
-      def get_kinds
-        @known_kinds ||= @kinds.keys
-      end
-
       # Reads the default token of a kind.
       # 
       # @note It will always return true token (not an alias).

data/lib/i18n-inflector/inflection_data_strict.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains class that is used to keep
 # inflection data for strict kinds.
@@ -26,15 +26,11 @@ module I18n
       # 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.
+      # Locale this database works for.
       attr_reader :locale
 
       # Initializes internal structures.
@@ -43,9 +39,8 @@ module I18n
       #   the object to be labeled with
       def initialize(locale=nil)
         @tokens       = Hash.new(DUMMY_TOKENS)
-        @lazy_tokens  = Hash.new(DUMMY_T_LAZY)
+        @lazy_kinds   = LazyArrayEnumerator.new(@tokens)
         @defaults     = Hash.new
-        @known_kinds  = nil
         @locale       = locale
       end
 
@@ -83,9 +78,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
         token = kind_tree[token] = {}
         token[:description] = description.to_s
@@ -155,56 +148,70 @@ module I18n
         not @tokens[kind][alias_name][:target].nil?
       end
 
-      # Reads all the true tokens (not aliases) of the
+      # Iterates through 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? }.
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      def each_true_token(kind, &block)
+        LazyHashEnumerator.new(@tokens[kind]).
+        select { |token,data| data[:target].nil?  }.
         map    { |token,data| data[:description]  }.
-        to_h
+        each(&block)
       end
 
-      # Reads all the aliases of the given strict kind.
+      # Iterates through 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].
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => target</tt>)
+      # @yield [alias, target] optional block in which each alias will be yielded
+      # @yieldparam [Symbol] alias an alias
+      # @yieldparam [Symbol] target a name of the target token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      def each_alias(kind, &block)
+        LazyHashEnumerator.new(@tokens[kind]).
         reject { |token,data| data[:target].nil?  }.
         map    { |token,data| data[:target]       }.
-        to_h
+        each(&block)
       end
 
-      # Reads all the tokens of the given strict kind
+      # Iterates through 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].
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description|target</tt>)
+      # @yield [token, value] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [Symbol, String] value a description string for a token or a target (if alias)
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      def each_raw_token(kind, &block)
+        LazyHashEnumerator.new(@tokens[kind]).
         map { |token,data| data[:target] || data[:description] }.
-        to_h
+        each(&block)
       end
 
-      # Reads all the tokens (including aliases) of the given
+      # Iterates through all the tokens (including aliases) of the given
       # strict kind.
       # 
-      # @note Use {#get_raw_tokens} if you want to distinguish
+      # @note Use {#each_raw_token} 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
+      # @return [LazyHashEnumerator] the lazy enumerator (<tt>token => description</tt>)
+      # @yield [token, description] optional block in which each token will be yielded
+      # @yieldparam [Symbol] token a token
+      # @yieldparam [String] description a description string for a token
+      # @yieldreturn [LazyHashEnumerator] the lazy enumerator
+      def each_token(kind, &block)
+        LazyHashEnumerator.new(@tokens[kind]).
+        map{ |token,data| data[:description] }.
+        each(&block)
       end
 
       # Gets a target token for the given alias of a strict kind.
@@ -249,12 +256,14 @@ module I18n
         o[:target].nil? ? token : o[:target]
       end
 
-      # Gets all known strict kinds.
+      # Iterates through all known strict kinds.
       # 
-      # @return [Array<Symbol>] an array containing all the known strict
-      #   kinds
-      def get_kinds
-        @known_kinds ||= @tokens.keys
+      # @return [LazyArrayEnumerator] the lazy enumerator
+      # @yield [kind] optional block in which each kind will be yielded
+      # @yieldparam [Symbol] kind the inflection kind
+      # @yieldreturn [LazyArrayEnumerator] the lazy enumerator
+      def each_kind(&block)
+        @lazy_kinds.map{|k,v| k}.each(&block)
       end
 
       # Reads the default token of a strict kind.

data/lib/i18n-inflector/inflector.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains a stub of I18n::Inflector module,
 # which extends I18n by adding the ability
@@ -22,7 +22,7 @@ module I18n
     end
   end
 
-  # @version 2.5
+  # @version 2.6
   # @api public
   # 
   # This module contains inflection classes and modules for enabling
@@ -32,7 +32,7 @@ module I18n
   # so it will interpolate additional inflection data present
   # in translations.
   # 
-  # @see file:USAGE
+  # @see file:docs/USAGE
   module Inflector
 
   end # module Inflector

data/lib/i18n-inflector/interpolate.rb

@@ -2,7 +2,7 @@
 #
 # Author::    Paweł Wilk (mailto:pw@gnu.org)
 # Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
 # 
 # This file contains I18n::Inflector::Interpolate module,
 # which is included in the API.
@@ -44,6 +44,7 @@ module I18n
       #   that overrides global setting (see: {I18n::Inflector::InflectionOptions#interpolate_symbols})
       # @return [String] the string with interpolated patterns
       def interpolate(string, locale, options = {})
+        @inflector_opt_cache = nil
 
         case string
 
@@ -96,18 +97,21 @@ module I18n
         suff = key.delete(:@suffix).to_s
         kind = key.delete(:@kind).to_s
         free = key.delete(:@free)
-        free = free.nil? ? "" : (Operators::Tokens::OR + free.to_s)
+        free = free.nil? ? "" : ("" << Operators::Tokens::OR << free.to_s)
 
-        pref + Markers::PATTERN + kind + Markers::PATTERN_BEGIN  +
-        key.map { |k,v| k.to_s + Operators::Tokens::ASSIGN + v.to_s }.
-        join(Operators::Tokens::OR) + free + Markers::PATTERN_END + suff
+        "" << pref << Markers::PATTERN << kind << Markers::PATTERN_BEGIN  <<
+        key.map { |k,v| "" << k.to_s << Operators::Tokens::ASSIGN << v.to_s }.
+        join(Operators::Tokens::OR) << free << Markers::PATTERN_END << suff
       end
 
       private
 
       # @private
       def interpolate_core(string, locale, options)
-        passed_kinds      = options.except(*Reserved::KEYS)
+
+        @inflector_opt_cache ||= options.except(*Reserved::KEYS)
+        passed_kinds = @inflector_opt_cache
+
         raises            = options[:inflector_raises]
         aliased_patterns  = options[:inflector_aliased_patterns]
         unknown_defaults  = options[:inflector_unknown_defaults]
@@ -117,11 +121,11 @@ module I18n
         idb_strict        = @idb_strict[locale]
 
         string.gsub(PATTERN_REGEXP) do
-          pattern_fix     = $1
-          strict_kind     = $2
-          pattern_content = $3
-          multipattern    = $4
-          ext_pattern     = $&
+          pattern_fix     = $1  # character sticked to the left side of a pattern
+          strict_kind     = $2  # strict kind(s) if any
+          pattern_content = $3  # content of a pattern
+          multipattern    = $4  # another pattern(s) sticked to the right side of a pattern
+          ext_pattern     = $&  # the matching string
 
           # initialize some defaults
           ext_freetext    = ''
@@ -141,11 +145,13 @@ module I18n
             patterns = []
             patterns << pattern_content
             patterns += multipattern.scan(MULTI_REGEXP).flatten
-            next pattern_fix + patterns.map do |content|
-              interpolate_core(Markers::PATTERN       + strict_kind   +
-                               Markers::PATTERN_BEGIN + content       +
-                               Markers::PATTERN_END, locale, options)
-            end.join
+            next "" << pattern_fix <<
+                       patterns.map do |content|
+                         interpolate_core("" << Markers::PATTERN       << strict_kind   <<
+                                                Markers::PATTERN_BEGIN << content       <<
+                                                Markers::PATTERN_END,
+                                          locale, options)
+                      end.join
           end
 
           # set parsed kind if strict kind is given (named pattern is parsed) 
@@ -156,7 +162,7 @@ module I18n
             default_token   = nil
             subdb           = idb
           else
-            sym_parsed_kind = (Markers::STRICT_KIND + strict_kind).to_sym
+            sym_parsed_kind = ("" << Markers::STRICT_KIND << strict_kind).to_sym
 
             if strict_kind.include?(Operators::Tokens::AND)
 
@@ -181,10 +187,10 @@ module I18n
                   !idb_strict.has_kind?(strict_kind.to_sym))
                 raise I18n::InvalidInflectionKind.new(locale, ext_pattern, sym_parsed_kind) if raises
                 # Take a free text for invalid kind and return it
-                next pattern_fix + pattern_content.scan(TOKENS_REGEXP).reverse.
-                                   select { |t,v,f| t.nil? && !f.nil? }.
-                                   map    { |t,v,f| f.to_s            }.
-                                   first.to_s
+                next "" << pattern_fix << pattern_content.scan(TOKENS_REGEXP).reverse.
+                                          select { |t,v,f| t.nil? && !f.nil? }.
+                                          map    { |t,v,f| f.to_s            }.
+                                          first.to_s
               else
                 strict_kind   = strict_kind.to_sym
                 parsed_kind   = strict_kind
@@ -197,11 +203,12 @@ module I18n
 
           # process pattern content's
           pattern_content.scan(TOKENS_REGEXP) do
-            ext_token     = $1.to_s
-            ext_value     = $2.to_s
-            ext_freetext  = $3.to_s
+            ext_token     = $1.to_s         # token(s)
+            ext_value     = $2.to_s         # value of token(s)
+            ext_freetext  = $3.to_s         # freetext if any
+            ext_tokens    = nil
             tokens        = Hash.new(false)
-            negatives     = Hash.new(false)
+            negatives     = Hash.new(false) 
             kind          = nil
             passed_token  = nil
             result        = nil
@@ -219,18 +226,20 @@ module I18n
 
             # unroll wildcard token
             if ext_token == Operators::Tokens::WILDCARD
-
               if parsed_kind.nil?
                 # wildcard for a regular kind that we do not know yet
                 wildcard_value = ext_value
               else
                 # wildcard for a known strict or regular kind
-                ext_token = subdb.get_true_tokens(parsed_kind).keys.join(Operators::Token::OR)
+                ext_tokens = subdb.each_true_token(parsed_kind).each_key.map{|k|k.to_s}
               end
             end
 
-            # split tokens from group if comma is present and put into fast list
-            ext_token.split(Operators::Token::OR).each do |t|
+            # split groupped tokens if comma is present and put into fast list
+            ext_tokens = ext_token.split(Operators::Token::OR) if ext_tokens.nil?
+
+            # for each token from group
+            ext_tokens.each do |t|
               # token name corrupted
               if t.to_s.empty?
                 raise I18n::InvalidInflectionToken.new(locale, ext_pattern, t) if raises
@@ -306,20 +315,29 @@ module I18n
 
             # get passed token from options or from a default token
             if passed_kinds.has_key?(expected_kind)
+
               passed_token = passed_kinds[expected_kind]
+
               if passed_token.is_a?(Method)
+
                 passed_token = passed_token.call { next expected_kind, locale }
-                passed_kinds[expected_kind] = passed_token # cache the result
+                passed_kinds[expected_kind] = passed_token  # cache the result
+
               elsif passed_token.is_a?(Proc)
+
                 passed_token = passed_token.call(expected_kind, locale)
-                passed_kinds[expected_kind] = passed_token # cache the result
+                passed_kinds[expected_kind] = passed_token  # cache the result
+
               end
+
               orig_passed_token = passed_token
+
               # validate passed token's name
               if Reserved::Tokens.invalid?(passed_token, :OPTION)
                 raise I18n::InvalidInflectionOption.new(locale, ext_pattern, orig_passed_token) if raises
                 passed_token = default_token if unknown_defaults
               end
+
             else
               # current inflection option wasn't found
               # but delay this exception because we might use
@@ -432,7 +450,7 @@ module I18n
 
           end
 
-          pattern_fix + (result || ext_freetext)
+          "" << pattern_fix << (result || ext_freetext)
 
         end # single pattern processing
 
@@ -469,13 +487,26 @@ module I18n
             results = tokens.split(Operators::Tokens::AND).map do |token|
               raise IndexError.new if token.empty?
               if value == Markers::LOUD_VALUE
-                r = interpolate_core(Markers::PATTERN + kinds.next.to_s + Markers::PATTERN_BEGIN + token.to_s +
-                                     Operators::Tokens::ASSIGN + value.to_s + Operators::Tokens::OR +
-                                     Markers::PATTERN + Markers::PATTERN_END, locale, options)
+                r = interpolate_core("" <<  Markers::PATTERN          <<
+                                            kinds.next.to_s           <<
+                                            Markers::PATTERN_BEGIN    <<
+                                            token.to_s                <<
+                                            Operators::Tokens::ASSIGN <<
+                                            value.to_s                <<
+                                            Operators::Tokens::OR     <<
+                                            Markers::PATTERN          <<
+                                            Markers::PATTERN_END,
+                                      locale, options)
                 break if r == Markers::PATTERN # using this marker only as a helper to indicate empty result!
               else
-                r = interpolate_core(Markers::PATTERN + kinds.next.to_s + Markers::PATTERN_BEGIN + token.to_s +
-                                     Operators::Tokens::ASSIGN + value.to_s + Markers::PATTERN_END, locale, options)
+                r = interpolate_core("" <<  Markers::PATTERN          <<
+                                            kinds.next.to_s           <<
+                                            Markers::PATTERN_BEGIN    <<
+                                            token.to_s                <<
+                                            Operators::Tokens::ASSIGN <<
+                                            value.to_s                <<
+                                            Markers::PATTERN_END,
+                                     locale, options)
                 break if r != value # stop with this set, because something is not matching
               end
               r