addressable 2.2.3 → 2.7.0

data/lib/addressable/template.rb

@@ -1,42 +1,80 @@
+# frozen_string_literal: true
+
 # encoding:utf-8
 #--
-# Addressable, Copyright (c) 2006-2010 Bob Aman
+# Copyright (C) Bob Aman
 #
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
 #
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
+#        http://www.apache.org/licenses/LICENSE-2.0
 #
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
 #++
 
+
 require "addressable/version"
 require "addressable/uri"
 
 module Addressable
   ##
   # This is an implementation of a URI template based on
-  # <a href="http://tinyurl.com/uritemplatedraft03">URI Template draft 03</a>.
+  # RFC 6570 (http://tools.ietf.org/html/rfc6570).
   class Template
     # Constants used throughout the template code.
     anything =
       Addressable::URI::CharacterClasses::RESERVED +
       Addressable::URI::CharacterClasses::UNRESERVED
-    OPERATOR_EXPANSION =
-      /\{-([a-zA-Z]+)\|([#{anything}]+)\|([#{anything}]+)\}/
-    VARIABLE_EXPANSION = /\{([#{anything}]+?)(?:=([#{anything}]+))?\}/
+
+
+    variable_char_class =
+      Addressable::URI::CharacterClasses::ALPHA +
+      Addressable::URI::CharacterClasses::DIGIT + '_'
+
+    var_char =
+      "(?:(?:[#{variable_char_class}]|%[a-fA-F0-9][a-fA-F0-9])+)"
+    RESERVED =
+      "(?:[#{anything}]|%[a-fA-F0-9][a-fA-F0-9])"
+    UNRESERVED =
+      "(?:[#{
+        Addressable::URI::CharacterClasses::UNRESERVED
+      }]|%[a-fA-F0-9][a-fA-F0-9])"
+    variable =
+      "(?:#{var_char}(?:\\.?#{var_char})*)"
+    varspec =
+      "(?:(#{variable})(\\*|:\\d+)?)"
+    VARNAME =
+      /^#{variable}$/
+    VARSPEC =
+      /^#{varspec}$/
+    VARIABLE_LIST =
+      /^#{varspec}(?:,#{varspec})*$/
+    operator =
+      "+#./;?&=,!@|"
+    EXPRESSION =
+      /\{([#{operator}])?(#{varspec}(?:,#{varspec})*)\}/
+
+
+    LEADERS = {
+      '?' => '?',
+      '/' => '/',
+      '#' => '#',
+      '.' => '.',
+      ';' => ';',
+      '&' => '&'
+    }
+    JOINERS = {
+      '?' => '&',
+      '.' => '.',
+      ';' => ';',
+      '&' => '&',
+      '/' => '/'
+    }
 
     ##
     # Raised if an invalid template value is supplied.
@@ -63,7 +101,7 @@ module Addressable
       #
       # @param [Addressable::URI] uri
       #   The URI that the template was matched against.
-      def initialize(uri, template, mapping) # :nodoc:
+      def initialize(uri, template, mapping)
         @uri = uri.dup.freeze
         @template = template
         @mapping = mapping.dup.freeze
@@ -96,6 +134,7 @@ module Addressable
         self.template.variables
       end
       alias_method :keys, :variables
+      alias_method :names, :variables
 
       ##
       # @return [Array]
@@ -110,6 +149,64 @@ module Addressable
       end
       alias_method :captures, :values
 
+      ##
+      # Accesses captured values by name or by index.
+      #
+      # @param [String, Symbol, Fixnum] key
+      #   Capture index or name. Note that when accessing by with index
+      #   of 0, the full URI will be returned. The intention is to mimic
+      #   the ::MatchData#[] behavior.
+      #
+      # @param [#to_int, nil] len
+      #   If provided, an array of values will be returend with the given
+      #   parameter used as length.
+      #
+      # @return [Array, String, nil]
+      #   The captured value corresponding to the index or name. If the
+      #   value was not provided or the key is unknown, nil will be
+      #   returned.
+      #
+      #   If the second parameter is provided, an array of that length will
+      #   be returned instead.
+      def [](key, len = nil)
+        if len
+          to_a[key, len]
+        elsif String === key or Symbol === key
+          mapping[key.to_s]
+        else
+          to_a[key]
+        end
+      end
+
+      ##
+      # @return [Array]
+      #   Array with the matched URI as first element followed by the captured
+      #   values.
+      def to_a
+        [to_s, *values]
+      end
+
+      ##
+      # @return [String]
+      #   The matched URI as String.
+      def to_s
+        uri.to_s
+      end
+      alias_method :string, :to_s
+
+      # Returns multiple captured values at once.
+      #
+      # @param [String, Symbol, Fixnum] *indexes
+      #   Indices of the captures to be returned
+      #
+      # @return [Array]
+      #   Values corresponding to given indices.
+      #
+      # @see Addressable::Template::MatchData#[]
+      def values_at(*indexes)
+        indexes.map { |i| self[i] }
+      end
+
       ##
       # Returns a <tt>String</tt> representation of the MatchData's state.
       #
@@ -118,6 +215,15 @@ module Addressable
         sprintf("#<%s:%#0x RESULT:%s>",
           self.class.to_s, self.object_id, self.mapping.inspect)
       end
+
+      ##
+      # Dummy method for code expecting a ::MatchData instance
+      #
+      # @return [String] An empty string.
+      def pre_match
+        ""
+      end
+      alias_method :post_match, :pre_match
     end
 
     ##
@@ -130,7 +236,18 @@ module Addressable
       if !pattern.respond_to?(:to_str)
         raise TypeError, "Can't convert #{pattern.class} into String."
       end
-      @pattern = pattern.to_str.freeze
+      @pattern = pattern.to_str.dup.freeze
+    end
+
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.variables
+      self.variable_defaults
+      self.named_captures
+      super
     end
 
     ##
@@ -146,6 +263,26 @@ module Addressable
         self.class.to_s, self.object_id, self.pattern)
     end
 
+    ##
+    # Returns <code>true</code> if the Template objects are equal. This method
+    # does NOT normalize either Template before doing the comparison.
+    #
+    # @param [Object] template The Template to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the Templates are equivalent, <code>false</code>
+    #   otherwise.
+    def ==(template)
+      return false unless template.kind_of?(Template)
+      return self.pattern == template.pattern
+    end
+
+    ##
+    # Addressable::Template makes no distinction between `==` and `eql?`.
+    #
+    # @see #==
+    alias_method :eql?, :==
+
     ##
     # Extracts a mapping from the URI using a URI Template pattern.
     #
@@ -155,19 +292,21 @@ module Addressable
     # @param [#restore, #match] processor
     #   A template processor object may optionally be supplied.
     #
-    # The object should respond to either the <tt>restore</tt> or
-    # <tt>match</tt> messages or both.  The <tt>restore</tt> method should take
-    # two parameters: [String] name and [String] value.  The <tt>restore</tt>
-    # method should reverse any transformations that have been performed on the
-    # value to ensure a valid URI.  The <tt>match</tt> method should take a
-    # single parameter: [String] name.  The <tt>match</tt> method should return
-    # a <tt>String</tt> containing a regular expression capture group for
-    # matching on that particular variable.  The default value is ".*?".  The
-    # <tt>match</tt> method has no effect on multivariate operator expansions.
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`.  The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
     #
     # @return [Hash, NilClass]
-    # The <tt>Hash</tt> mapping that was extracted from the URI, or
-    # <tt>nil</tt> if the URI didn't match the template.
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
     #
     # @example
     #   class ExampleProcessor
@@ -215,19 +354,21 @@ module Addressable
     # @param [#restore, #match] processor
     #   A template processor object may optionally be supplied.
     #
-    # The object should respond to either the <tt>restore</tt> or
-    # <tt>match</tt> messages or both. The <tt>restore</tt> method should take
-    # two parameters: [String] name and [String] value. The <tt>restore</tt>
-    # method should reverse any transformations that have been performed on the
-    # value to ensure a valid URI. The <tt>match</tt> method should take a
-    # single parameter: [String] name. The <tt>match</tt> method should return
-    # a <tt>String</tt> containing a regular expression capture group for
-    # matching on that particular variable. The default value is ".*?". The
-    # <tt>match</tt> method has no effect on multivariate operator expansions.
+    #   The object should respond to either the <tt>restore</tt> or
+    #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+    #   take two parameters: `[String] name` and `[String] value`.
+    #   The <tt>restore</tt> method should reverse any transformations that
+    #   have been performed on the value to ensure a valid URI.
+    #   The <tt>match</tt> method should take a single
+    #   parameter: `[String] name`. The <tt>match</tt> method should return
+    #   a <tt>String</tt> containing a regular expression capture group for
+    #   matching on that particular variable. The default value is `".*?"`.
+    #   The <tt>match</tt> method has no effect on multivariate operator
+    #   expansions.
     #
     # @return [Hash, NilClass]
-    # The <tt>Hash</tt> mapping that was extracted from the URI, or
-    # <tt>nil</tt> if the URI didn't match the template.
+    #   The <tt>Hash</tt> mapping that was extracted from the URI, or
+    #   <tt>nil</tt> if the URI didn't match the template.
     #
     # @example
     #   class ExampleProcessor
@@ -255,7 +396,7 @@ module Addressable
     #
     #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
     #   match = Addressable::Template.new(
-    #     "http://example.com/{first}/{second}/"
+    #     "http://example.com/{first}/{+second}/"
     #   ).match(uri, ExampleProcessor)
     #   match.variables
     #   #=> ["first", "second"]
@@ -264,7 +405,7 @@ module Addressable
     #
     #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
     #   match = Addressable::Template.new(
-    #     "http://example.com/{first}/{-list|/|second}/"
+    #     "http://example.com/{first}{/second*}/"
     #   ).match(uri)
     #   match.variables
     #   #=> ["first", "second"]
@@ -277,42 +418,64 @@ module Addressable
       # First, we need to process the pattern, and extract the values.
       expansions, expansion_regexp =
         parse_template_pattern(pattern, processor)
+
+      return nil unless uri.to_str.match(expansion_regexp)
       unparsed_values = uri.to_str.scan(expansion_regexp).flatten
 
       if uri.to_str == pattern
         return Addressable::Template::MatchData.new(uri, self, mapping)
-      elsif expansions.size > 0 && expansions.size == unparsed_values.size
-        expansions.each_with_index do |expansion, index|
-          unparsed_value = unparsed_values[index]
-          if expansion =~ OPERATOR_EXPANSION
-            operator, argument, variables =
-              parse_template_expansion(expansion)
-            extract_method = "extract_#{operator}_operator"
-            if ([extract_method, extract_method.to_sym] &
-                private_methods).empty?
-              raise InvalidTemplateOperatorError,
-                "Invalid template operator: #{operator}"
-            else
-              begin
-                send(
-                  extract_method.to_sym, unparsed_value, processor,
-                  argument, variables, mapping
-                )
-              rescue TemplateOperatorAbortedError
-                return nil
+      elsif expansions.size > 0
+        index = 0
+        expansions.each do |expansion|
+          _, operator, varlist = *expansion.match(EXPRESSION)
+          varlist.split(',').each do |varspec|
+            _, name, modifier = *varspec.match(VARSPEC)
+            mapping[name] ||= nil
+            case operator
+            when nil, '+', '#', '/', '.'
+              unparsed_value = unparsed_values[index]
+              name = varspec[VARSPEC, 1]
+              value = unparsed_value
+              value = value.split(JOINERS[operator]) if value && modifier == '*'
+            when ';', '?', '&'
+              if modifier == '*'
+                if unparsed_values[index]
+                  value = unparsed_values[index].split(JOINERS[operator])
+                  value = value.inject({}) do |acc, v|
+                    key, val = v.split('=')
+                    val = "" if val.nil?
+                    acc[key] = val
+                    acc
+                  end
+                end
+              else
+                if (unparsed_values[index])
+                  name, value = unparsed_values[index].split('=')
+                  value = "" if value.nil?
+                end
               end
             end
-          else
-            name = expansion[VARIABLE_EXPANSION, 1]
-            value = unparsed_value
             if processor != nil && processor.respond_to?(:restore)
               value = processor.restore(name, value)
             end
-            if mapping[name] == nil || mapping[name] == value
+            if processor == nil
+              if value.is_a?(Hash)
+                value = value.inject({}){|acc, (k, v)|
+                  acc[Addressable::URI.unencode_component(k)] =
+                    Addressable::URI.unencode_component(v)
+                  acc
+                }
+              elsif value.is_a?(Array)
+                value = value.map{|v| Addressable::URI.unencode_component(v) }
+              else
+                value = Addressable::URI.unencode_component(value)
+              end
+            end
+            if !mapping.has_key?(name) || mapping[name].nil?
+              # Doesn't exist, set to value (even if value is nil)
               mapping[name] = value
-            else
-              return nil
             end
+            index = index + 1
           end
         end
         return Addressable::Template::MatchData.new(uri, self, mapping)
@@ -326,7 +489,9 @@ module Addressable
     #
     # @param [Hash] mapping The mapping that corresponds to the pattern.
     # @param [#validate, #transform] processor
-    #   An optional processor object may be supplied. 
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -349,50 +514,19 @@ module Addressable
     #   #=> "http://example.com/1/{two}/"
     #
     #   Addressable::Template.new(
-    #     "http://example.com/search/{-list|+|query}/"
-    #   ).partial_expand(
-    #     {"query" => "an example search query".split(" ")}
-    #   ).pattern
-    #   #=> "http://example.com/search/an+example+search+query/"
-    #
-    #   Addressable::Template.new(
-    #     "http://example.com/{-join|&|one,two}/"
+    #     "http://example.com/{?one,two}/"
     #   ).partial_expand({"one" => "1"}).pattern
-    #   #=> "http://example.com/?one=1{-prefix|&two=|two}"
+    #   #=> "http://example.com/?one=1{&two}/"
     #
     #   Addressable::Template.new(
-    #     "http://example.com/{-join|&|one,two,three}/"
+    #     "http://example.com/{?one,two,three}/"
     #   ).partial_expand({"one" => "1", "three" => 3}).pattern
-    #   #=> "http://example.com/?one=1{-prefix|&two=|two}&three=3"
-    def partial_expand(mapping, processor=nil)
+    #   #=> "http://example.com/?one=1{&two}&three=3"
+    def partial_expand(mapping, processor=nil, normalize_values=true)
       result = self.pattern.dup
-      transformed_mapping = transform_mapping(mapping, processor)
-      result.gsub!(
-        /#{OPERATOR_EXPANSION}|#{VARIABLE_EXPANSION}/
-      ) do |capture|
-        if capture =~ OPERATOR_EXPANSION
-          operator, argument, variables, default_mapping =
-            parse_template_expansion(capture, transformed_mapping)
-          expand_method = "expand_#{operator}_operator"
-          if ([expand_method, expand_method.to_sym] & private_methods).empty?
-            raise InvalidTemplateOperatorError,
-              "Invalid template operator: #{operator}"
-          else
-            send(
-              expand_method.to_sym, argument, variables,
-              default_mapping, true
-            )
-          end
-        else
-          varname, _, vardefault = capture.scan(/^\{(.+?)(=(.*))?\}$/)[0]
-          if transformed_mapping[varname]
-            transformed_mapping[varname]
-          elsif vardefault
-            "{#{varname}=#{vardefault}}"
-          else
-            "{#{varname}}"
-          end
-        end
+      mapping = normalize_keys(mapping)
+      result.gsub!( EXPRESSION ) do |capture|
+        transform_partial_capture(mapping, capture, processor, normalize_values)
       end
       return Addressable::Template.new(result)
     end
@@ -403,6 +537,8 @@ module Addressable
     # @param [Hash] mapping The mapping that corresponds to the pattern.
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -440,11 +576,11 @@ module Addressable
     #   #=> "http://example.com/search/an+example+search+query/"
     #
     #   Addressable::Template.new(
-    #     "http://example.com/search/{-list|+|query}/"
+    #     "http://example.com/search/{query}/"
     #   ).expand(
-    #     {"query" => "an example search query".split(" ")}
+    #     {"query" => "an example search query"}
     #   ).to_str
-    #   #=> "http://example.com/search/an+example+search+query/"
+    #   #=> "http://example.com/search/an%20example%20search%20query/"
     #
     #   Addressable::Template.new(
     #     "http://example.com/search/{query}/"
@@ -453,26 +589,11 @@ module Addressable
     #     ExampleProcessor
     #   ).to_str
     #   #=> Addressable::Template::InvalidTemplateValueError
-    def expand(mapping, processor=nil)
+    def expand(mapping, processor=nil, normalize_values=true)
       result = self.pattern.dup
-      transformed_mapping = transform_mapping(mapping, processor)
-      result.gsub!(
-        /#{OPERATOR_EXPANSION}|#{VARIABLE_EXPANSION}/
-      ) do |capture|
-        if capture =~ OPERATOR_EXPANSION
-          operator, argument, variables, default_mapping =
-            parse_template_expansion(capture, transformed_mapping)
-          expand_method = "expand_#{operator}_operator"
-          if ([expand_method, expand_method.to_sym] & private_methods).empty?
-            raise InvalidTemplateOperatorError,
-              "Invalid template operator: #{operator}"
-          else
-            send(expand_method.to_sym, argument, variables, default_mapping)
-          end
-        else
-          varname, _, vardefault = capture.scan(/^\{(.+?)(=(.*))?\}$/)[0]
-          transformed_mapping[varname] || vardefault
-        end
+      mapping = normalize_keys(mapping)
+      result.gsub!( EXPRESSION ) do |capture|
+        transform_capture(mapping, capture, processor, normalize_values)
       end
       return Addressable::URI.parse(result)
     end
@@ -488,6 +609,7 @@ module Addressable
       @variables ||= ordered_variable_defaults.map { |var, val| var }.uniq
     end
     alias_method :keys, :variables
+    alias_method :names, :variables
 
     ##
     # Returns a mapping of variables to their default values specified
@@ -499,31 +621,97 @@ module Addressable
         Hash[*ordered_variable_defaults.reject { |k, v| v.nil? }.flatten]
     end
 
+    ##
+    # Coerces a template into a `Regexp` object. This regular expression will
+    # behave very similarly to the actual template, and should match the same
+    # URI values, but it cannot fully handle, for example, values that would
+    # extract to an `Array`.
+    #
+    # @return [Regexp] A regular expression which should match the template.
+    def to_regexp
+      _, source = parse_template_pattern(pattern)
+      Regexp.new(source)
+    end
+
+    ##
+    # Returns the source of the coerced `Regexp`.
+    #
+    # @return [String] The source of the `Regexp` given by {#to_regexp}.
+    #
+    # @api private
+    def source
+      self.to_regexp.source
+    end
+
+    ##
+    # Returns the named captures of the coerced `Regexp`.
+    #
+    # @return [Hash] The named captures of the `Regexp` given by {#to_regexp}.
+    #
+    # @api private
+    def named_captures
+      self.to_regexp.named_captures
+    end
+
+    ##
+    # Generates a route result for a given set of parameters.
+    # Should only be used by rack-mount.
+    #
+    # @param params [Hash] The set of parameters used to expand the template.
+    # @param recall [Hash] Default parameters used to expand the template.
+    # @param options [Hash] Either a `:processor` or a `:parameterize` block.
+    #
+    # @api private
+    def generate(params={}, recall={}, options={})
+      merged = recall.merge(params)
+      if options[:processor]
+        processor = options[:processor]
+      elsif options[:parameterize]
+        # TODO: This is sending me into fits trying to shoe-horn this into
+        # the existing API. I think I've got this backwards and processors
+        # should be a set of 4 optional blocks named :validate, :transform,
+        # :match, and :restore. Having to use a singleton here is a huge
+        # code smell.
+        processor = Object.new
+        class <<processor
+          attr_accessor :block
+          def transform(name, value)
+            block.call(name, value)
+          end
+        end
+        processor.block = options[:parameterize]
+      else
+        processor = nil
+      end
+      result = self.expand(merged, processor)
+      result.to_s if result
+    end
+
   private
     def ordered_variable_defaults
-      @ordered_variable_defaults ||= (begin
-        expansions, expansion_regexp = parse_template_pattern(pattern)
-
-        expansions.inject([]) do |result, expansion|
-          case expansion
-          when OPERATOR_EXPANSION
-            _, _, variables, mapping = parse_template_expansion(expansion)
-            result.concat variables.map { |var| [var, mapping[var]] }
-          when VARIABLE_EXPANSION
-            result << [$1, $2]
+      @ordered_variable_defaults ||= begin
+        expansions, _ = parse_template_pattern(pattern)
+        expansions.map do |capture|
+          _, _, varlist = *capture.match(EXPRESSION)
+          varlist.split(',').map do |varspec|
+            varspec[VARSPEC, 1]
           end
-          result
-        end
-      end)
+        end.flatten
+      end
     end
 
+
     ##
-    # Transforms a mapping so that values can be substituted into the
-    # template.
+    # Loops through each capture and expands any values available in mapping
     #
-    # @param [Hash] mapping The mapping of variables to values.
+    # @param [Hash] mapping
+    #   Set of keys to expand
+    # @param [String] capture
+    #   The expression to expand
     # @param [#validate, #transform] processor
     #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
     # The object should respond to either the <tt>validate</tt> or
     # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
@@ -537,279 +725,252 @@ module Addressable
     # automatically. Unicode normalization will be performed both before and
     # after sending the value to the transform method.
     #
-    # @return [Hash] The transformed mapping.
-    def transform_mapping(mapping, processor=nil)
-      return mapping.inject({}) do |accu, pair|
-        name, value = pair
-        value = value.to_s if Numeric === value || Symbol === value
+    # @return [String] The expanded expression
+    def transform_partial_capture(mapping, capture, processor = nil,
+                                  normalize_values = true)
+      _, operator, varlist = *capture.match(EXPRESSION)
 
-        unless value.respond_to?(:to_ary) || value.respond_to?(:to_str)
-          raise TypeError,
-            "Can't convert #{value.class} into String or Array."
-        end
+      vars = varlist.split(",")
 
-        if Symbol === name
-          name = name.to_s
-        elsif name.respond_to?(:to_str)
-          name = name.to_str
-        else
-          raise TypeError,
-            "Can't convert #{name.class} into String."
-        end
-        value = value.respond_to?(:to_ary) ? value.to_ary : value.to_str
-
-        # Handle unicode normalization
-        if value.kind_of?(Array)
-          value.map! { |val| Addressable::IDNA.unicode_normalize_kc(val) }
-        else
-          value = Addressable::IDNA.unicode_normalize_kc(value)
-        end
-
-        if processor == nil || !processor.respond_to?(:transform)
-          # Handle percent escaping
-          if value.kind_of?(Array)
-            transformed_value = value.map do |val|
-              Addressable::URI.encode_component(
-                val, Addressable::URI::CharacterClasses::UNRESERVED)
-            end
-          else
-            transformed_value = Addressable::URI.encode_component(
-              value, Addressable::URI::CharacterClasses::UNRESERVED)
-          end
-        end
-
-        # Process, if we've got a processor
-        if processor != nil
-          if processor.respond_to?(:validate)
-            if !processor.validate(name, value)
-              display_value = value.kind_of?(Array) ? value.inspect : value
-              raise InvalidTemplateValueError,
-                "#{name}=#{display_value} is an invalid template value."
-            end
-          end
-          if processor.respond_to?(:transform)
-            transformed_value = processor.transform(name, value)
-            if transformed_value.kind_of?(Array)
-              transformed_value.map! do |val|
-                Addressable::IDNA.unicode_normalize_kc(val)
-              end
-            else
-              transformed_value =
-                Addressable::IDNA.unicode_normalize_kc(transformed_value)
-            end
-          end
-        end
+      if operator == "?"
+        # partial expansion of form style query variables sometimes requires a
+        # slight reordering of the variables to produce a valid url.
+        first_to_expand = vars.find { |varspec|
+          _, name, _ =  *varspec.match(VARSPEC)
+          mapping.key?(name) && !mapping[name].nil?
+        }
 
-        accu[name] = transformed_value
-        accu
+        vars = [first_to_expand] + vars.reject {|varspec| varspec == first_to_expand}  if first_to_expand
       end
-    end
 
-    ##
-    # Expands a URI Template opt operator.
-    #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The expanded result.
-    def expand_opt_operator(argument, variables, mapping, partial=false)
-      variables_present = variables.any? do |variable|
-        mapping[variable] != [] &&
-        mapping[variable]
-      end
-      if partial && !variables_present
-        "{-opt|#{argument}|#{variables.join(",")}}"
-      elsif variables_present
-        argument
-      else
-        ""
+      vars.
+        inject("".dup) do |acc, varspec|
+          _, name, _ =  *varspec.match(VARSPEC)
+          next_val = if mapping.key? name
+                       transform_capture(mapping, "{#{operator}#{varspec}}",
+                                         processor, normalize_values)
+                     else
+                       "{#{operator}#{varspec}}"
+                     end
+          # If we've already expanded at least one '?' operator with non-empty
+          # value, change to '&'
+          operator = "&" if (operator == "?") && (next_val != "")
+          acc << next_val
       end
     end
 
     ##
-    # Expands a URI Template neg operator.
+    # Transforms a mapped value so that values can be substituted into the
+    # template.
     #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
+    # @param [Hash] mapping The mapping to replace captures
+    # @param [String] capture
+    #   The expression to replace
+    # @param [#validate, #transform] processor
+    #   An optional processor object may be supplied.
+    # @param [Boolean] normalize_values
+    #   Optional flag to enable/disable unicode normalization. Default: true
     #
-    # @return [String] The expanded result.
-    def expand_neg_operator(argument, variables, mapping, partial=false)
-      variables_present = variables.any? do |variable|
-        mapping[variable] != [] &&
-        mapping[variable]
-      end
-      if partial && !variables_present
-        "{-neg|#{argument}|#{variables.join(",")}}"
-      elsif variables_present
-        ""
-      else
-        argument
-      end
-    end
-
-    ##
-    # Expands a URI Template prefix operator.
     #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
+    # The object should respond to either the <tt>validate</tt> or
+    # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+    # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+    # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+    # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+    # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt> exception
+    # will be raised if the value is invalid. The <tt>transform</tt> method
+    # should return the transformed variable value as a <tt>String</tt>. If a
+    # <tt>transform</tt> method is used, the value will not be percent encoded
+    # automatically. Unicode normalization will be performed both before and
+    # after sending the value to the transform method.
     #
-    # @return [String] The expanded result.
-    def expand_prefix_operator(argument, variables, mapping, partial=false)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'prefix' takes exactly one variable."
-      end
-      value = mapping[variables.first]
-      if !partial || value
-        if value.kind_of?(Array)
-          (value.map { |list_value| argument + list_value }).join("")
-        elsif value
-          argument + value.to_s
-        end
-      else
-        "{-prefix|#{argument}|#{variables.first}}"
-      end
-    end
+    # @return [String] The expanded expression
+    def transform_capture(mapping, capture, processor=nil,
+                          normalize_values=true)
+      _, operator, varlist = *capture.match(EXPRESSION)
+      return_value = varlist.split(',').inject([]) do |acc, varspec|
+        _, name, modifier = *varspec.match(VARSPEC)
+        value = mapping[name]
+        unless value == nil || value == {}
+          allow_reserved = %w(+ #).include?(operator)
+          # Common primitives where the .to_s output is well-defined
+          if Numeric === value || Symbol === value ||
+              value == true || value == false
+            value = value.to_s
+          end
+          length = modifier.gsub(':', '').to_i if modifier =~ /^:\d+/
 
-    ##
-    # Expands a URI Template suffix operator.
-    #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The expanded result.
-    def expand_suffix_operator(argument, variables, mapping, partial=false)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'suffix' takes exactly one variable."
-      end
-      value = mapping[variables.first]
-      if !partial || value
-        if value.kind_of?(Array)
-          (value.map { |list_value| list_value + argument }).join("")
-        elsif value
-          value.to_s + argument
-        end
-      else
-        "{-suffix|#{argument}|#{variables.first}}"
-      end
-    end
+          unless (Hash === value) ||
+            value.respond_to?(:to_ary) || value.respond_to?(:to_str)
+            raise TypeError,
+              "Can't convert #{value.class} into String or Array."
+          end
 
-    ##
-    # Expands a URI Template join operator.
-    #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The expanded result.
-    def expand_join_operator(argument, variables, mapping, partial=false)
-      if !partial
-        variable_values = variables.inject([]) do |accu, variable|
-          if !mapping[variable].kind_of?(Array)
-            if mapping[variable]
-              accu << variable + "=" + (mapping[variable])
+          value = normalize_value(value) if normalize_values
+
+          if processor == nil || !processor.respond_to?(:transform)
+            # Handle percent escaping
+            if allow_reserved
+              encode_map =
+                Addressable::URI::CharacterClasses::RESERVED +
+                Addressable::URI::CharacterClasses::UNRESERVED
+            else
+              encode_map = Addressable::URI::CharacterClasses::UNRESERVED
             end
-          else
-            raise InvalidTemplateOperatorError,
-              "Template operator 'join' does not accept Array values."
-          end
-          accu
-        end
-        variable_values.join(argument)
-      else
-        buffer = ""
-        state = :suffix
-        variables.each_with_index do |variable, index|
-          if !mapping[variable].kind_of?(Array)
-            if mapping[variable]
-              if buffer.empty? || buffer[-1..-1] == "}"
-                buffer << (variable + "=" + (mapping[variable]))
-              elsif state == :suffix
-                buffer << argument
-                buffer << (variable + "=" + (mapping[variable]))
-              else
-                buffer << (variable + "=" + (mapping[variable]))
+            if value.kind_of?(Array)
+              transformed_value = value.map do |val|
+                if length
+                  Addressable::URI.encode_component(val[0...length], encode_map)
+                else
+                  Addressable::URI.encode_component(val, encode_map)
+                end
               end
-            else
-              if !buffer.empty? && (buffer[-1..-1] != "}" || state == :prefix)
-                buffer << "{-opt|#{argument}|#{variable}}"
-                state = :prefix
+              unless modifier == "*"
+                transformed_value = transformed_value.join(',')
+              end
+            elsif value.kind_of?(Hash)
+              transformed_value = value.map do |key, val|
+                if modifier == "*"
+                  "#{
+                    Addressable::URI.encode_component( key, encode_map)
+                  }=#{
+                    Addressable::URI.encode_component( val, encode_map)
+                  }"
+                else
+                  "#{
+                    Addressable::URI.encode_component( key, encode_map)
+                  },#{
+                    Addressable::URI.encode_component( val, encode_map)
+                  }"
+                end
               end
-              if buffer.empty? && variables.size == 1
-                # Evaluates back to itself
-                buffer << "{-join|#{argument}|#{variable}}"
+              unless modifier == "*"
+                transformed_value = transformed_value.join(',')
+              end
+            else
+              if length
+                transformed_value = Addressable::URI.encode_component(
+                  value[0...length], encode_map)
               else
-                buffer << "{-prefix|#{variable}=|#{variable}}"
+                transformed_value = Addressable::URI.encode_component(
+                  value, encode_map)
               end
-              if (index != (variables.size - 1) && state == :suffix)
-                buffer << "{-opt|#{argument}|#{variable}}"
-              elsif index != (variables.size - 1) &&
-                  mapping[variables[index + 1]]
-                buffer << argument
-                state = :prefix
+            end
+          end
+
+          # Process, if we've got a processor
+          if processor != nil
+            if processor.respond_to?(:validate)
+              if !processor.validate(name, value)
+                display_value = value.kind_of?(Array) ? value.inspect : value
+                raise InvalidTemplateValueError,
+                  "#{name}=#{display_value} is an invalid template value."
+              end
+            end
+            if processor.respond_to?(:transform)
+              transformed_value = processor.transform(name, value)
+              if normalize_values
+                transformed_value = normalize_value(transformed_value)
               end
             end
-          else
-            raise InvalidTemplateOperatorError,
-              "Template operator 'join' does not accept Array values."
           end
+          acc << [name, transformed_value]
         end
-        buffer
+        acc
+      end
+      return "" if return_value.empty?
+      join_values(operator, return_value)
+    end
+
+    ##
+    # Takes a set of values, and joins them together based on the
+    # operator.
+    #
+    # @param [String, Nil] operator One of the operators from the set
+    #   (?,&,+,#,;,/,.), or nil if there wasn't one.
+    # @param [Array] return_value
+    #   The set of return values (as [variable_name, value] tuples) that will
+    #   be joined together.
+    #
+    # @return [String] The transformed mapped value
+    def join_values(operator, return_value)
+      leader = LEADERS.fetch(operator, '')
+      joiner = JOINERS.fetch(operator, ',')
+      case operator
+      when '&', '?'
+        leader + return_value.map{|k,v|
+          if v.is_a?(Array) && v.first =~ /=/
+            v.join(joiner)
+          elsif v.is_a?(Array)
+            v.map{|inner_value| "#{k}=#{inner_value}"}.join(joiner)
+          else
+            "#{k}=#{v}"
+          end
+        }.join(joiner)
+      when ';'
+        return_value.map{|k,v|
+          if v.is_a?(Array) && v.first =~ /=/
+            ';' + v.join(";")
+          elsif v.is_a?(Array)
+            ';' + v.map{|inner_value| "#{k}=#{inner_value}"}.join(";")
+          else
+            v && v != '' ?  ";#{k}=#{v}" : ";#{k}"
+          end
+        }.join
+      else
+        leader + return_value.map{|k,v| v}.join(joiner)
       end
     end
 
     ##
-    # Expands a URI Template list operator.
+    # Takes a set of values, and joins them together based on the
+    # operator.
     #
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
+    # @param [Hash, Array, String] value
+    #   Normalizes keys and values with IDNA#unicode_normalize_kc
     #
-    # @return [String] The expanded result.
-    def expand_list_operator(argument, variables, mapping, partial=false)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'list' takes exactly one variable."
+    # @return [Hash, Array, String] The normalized values
+    def normalize_value(value)
+      unless value.is_a?(Hash)
+        value = value.respond_to?(:to_ary) ? value.to_ary : value.to_str
       end
-      if !partial || mapping[variables.first]
-        values = mapping[variables.first]
-        if values
-          if values.kind_of?(Array)
-            values.join(argument)
-          else
-            raise InvalidTemplateOperatorError,
-              "Template operator 'list' only accepts Array values."
-          end
-        end
+
+      # Handle unicode normalization
+      if value.kind_of?(Array)
+        value.map! { |val| Addressable::IDNA.unicode_normalize_kc(val) }
+      elsif value.kind_of?(Hash)
+        value = value.inject({}) { |acc, (k, v)|
+          acc[Addressable::IDNA.unicode_normalize_kc(k)] =
+            Addressable::IDNA.unicode_normalize_kc(v)
+          acc
+        }
       else
-        "{-list|#{argument}|#{variables.first}}"
+        value = Addressable::IDNA.unicode_normalize_kc(value)
       end
+      value
     end
 
     ##
-    # Parses a URI template expansion <tt>String</tt>.
+    # Generates a hash with string keys
     #
-    # @param [String] expansion The operator <tt>String</tt>.
-    # @param [Hash] mapping An optional mapping to merge defaults into.
+    # @param [Hash] mapping A mapping hash to normalize
     #
-    # @return [Array]
-    #   A tuple of the operator, argument, variables, and mapping.
-    def parse_template_expansion(capture, mapping={})
-      operator, argument, variables = capture[1...-1].split("|", -1)
-      operator.gsub!(/^\-/, "")
-      variables = variables.split(",", -1)
-      mapping = (variables.inject({}) do |accu, var|
-        varname, _, vardefault = var.scan(/^(.+?)(=(.*))?$/)[0]
-        accu[varname] = vardefault
+    # @return [Hash]
+    #   A hash with stringified keys
+    def normalize_keys(mapping)
+      return mapping.inject({}) do |accu, pair|
+        name, value = pair
+        if Symbol === name
+          name = name.to_s
+        elsif name.respond_to?(:to_str)
+          name = name.to_str
+        else
+          raise TypeError,
+            "Can't convert #{name.class} into String."
+        end
+        accu[name] = value
         accu
-      end).merge(mapping)
-      variables = variables.map { |var| var.gsub(/=.*$/, "") }
-      return operator, argument, variables, mapping
+      end
     end
 
     ##
@@ -834,216 +995,51 @@ module Addressable
 
       # Create a regular expression that captures the values of the
       # variables in the URI.
-      regexp_string = escaped_pattern.gsub(
-        /#{OPERATOR_EXPANSION}|#{VARIABLE_EXPANSION}/
-      ) do |expansion|
+      regexp_string = escaped_pattern.gsub( EXPRESSION ) do |expansion|
+
         expansions << expansion
-        if expansion =~ OPERATOR_EXPANSION
-          capture_group = "(.*)"
-          operator, argument, names, _ =
-            parse_template_expansion(expansion)
-          if processor != nil && processor.respond_to?(:match)
-            # We can only lookup the match values for single variable
-            # operator expansions. Besides, ".*" is usually the only
-            # reasonable value for multivariate operators anyways.
-            if ["prefix", "suffix", "list"].include?(operator)
-              capture_group = "(#{processor.match(names.first)})"
+        _, operator, varlist = *expansion.match(EXPRESSION)
+        leader = Regexp.escape(LEADERS.fetch(operator, ''))
+        joiner = Regexp.escape(JOINERS.fetch(operator, ','))
+        combined = varlist.split(',').map do |varspec|
+          _, name, modifier = *varspec.match(VARSPEC)
+
+          result = processor && processor.respond_to?(:match) ? processor.match(name) : nil
+          if result
+            "(?<#{name}>#{ result })"
+          else
+            group = case operator
+            when '+'
+              "#{ RESERVED }*?"
+            when '#'
+              "#{ RESERVED }*?"
+            when '/'
+              "#{ UNRESERVED }*?"
+            when '.'
+              "#{ UNRESERVED.gsub('\.', '') }*?"
+            when ';'
+              "#{ UNRESERVED }*=?#{ UNRESERVED }*?"
+            when '?'
+              "#{ UNRESERVED }*=#{ UNRESERVED }*?"
+            when '&'
+              "#{ UNRESERVED }*=#{ UNRESERVED }*?"
+            else
+              "#{ UNRESERVED }*?"
+            end
+            if modifier == '*'
+              "(?<#{name}>#{group}(?:#{joiner}?#{group})*)?"
+            else
+              "(?<#{name}>#{group})?"
             end
-          elsif operator == "prefix"
-            capture_group = "(#{Regexp.escape(argument)}.*?)"
-          elsif operator == "suffix"
-            capture_group = "(.*?#{Regexp.escape(argument)})"
-          end
-          capture_group
-        else
-          capture_group = "(.*?)"
-          if processor != nil && processor.respond_to?(:match)
-            name = expansion[/\{([^\}=]+)(=[^\}]+)?\}/, 1]
-            capture_group = "(#{processor.match(name)})"
           end
-          capture_group
-        end
+        end.join("#{joiner}?")
+        "(?:|#{leader}#{combined})"
       end
 
       # Ensure that the regular expression matches the whole URI.
       regexp_string = "^#{regexp_string}$"
-
       return expansions, Regexp.new(regexp_string)
     end
 
-    ##
-    # Extracts a URI Template opt operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_opt_operator(
-        value, processor, argument, variables, mapping)
-      if value != "" && value != argument
-        raise TemplateOperatorAbortedError,
-          "Value for template operator 'opt' was unexpected."
-      end
-    end
-
-    ##
-    # Extracts a URI Template neg operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_neg_operator(
-        value, processor, argument, variables, mapping)
-      if value != "" && value != argument
-        raise TemplateOperatorAbortedError,
-          "Value for template operator 'neg' was unexpected."
-      end
-    end
-
-    ##
-    # Extracts a URI Template prefix operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_prefix_operator(
-        value, processor, argument, variables, mapping)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'prefix' takes exactly one variable."
-      end
-      if value[0...argument.size] != argument
-        raise TemplateOperatorAbortedError,
-          "Value for template operator 'prefix' missing expected prefix."
-      end
-      values = value.split(argument, -1)
-      values << "" if value[-argument.size..-1] == argument
-      values.shift if values[0] == ""
-      values.pop if values[-1] == ""
-
-      if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
-      end
-      values = values.first if values.size == 1
-      if mapping[variables.first] == nil || mapping[variables.first] == values
-        mapping[variables.first] = values
-      else
-        raise TemplateOperatorAbortedError,
-          "Value mismatch for repeated variable."
-      end
-    end
-
-    ##
-    # Extracts a URI Template suffix operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_suffix_operator(
-        value, processor, argument, variables, mapping)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'suffix' takes exactly one variable."
-      end
-      if value[-argument.size..-1] != argument
-        raise TemplateOperatorAbortedError,
-          "Value for template operator 'suffix' missing expected suffix."
-      end
-      values = value.split(argument, -1)
-      values.pop if values[-1] == ""
-      if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
-      end
-      values = values.first if values.size == 1
-      if mapping[variables.first] == nil || mapping[variables.first] == values
-        mapping[variables.first] = values
-      else
-        raise TemplateOperatorAbortedError,
-          "Value mismatch for repeated variable."
-      end
-    end
-
-    ##
-    # Extracts a URI Template join operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_join_operator(value, processor, argument, variables, mapping)
-      unparsed_values = value.split(argument)
-      parsed_variables = []
-      for unparsed_value in unparsed_values
-        name = unparsed_value[/^(.+?)=(.+)$/, 1]
-        parsed_variables << name
-        parsed_value = unparsed_value[/^(.+?)=(.+)$/, 2]
-        if processor && processor.respond_to?(:restore)
-          parsed_value = processor.restore(name, parsed_value)
-        end
-        if mapping[name] == nil || mapping[name] == parsed_value
-          mapping[name] = parsed_value
-        else
-          raise TemplateOperatorAbortedError,
-            "Value mismatch for repeated variable."
-        end
-      end
-      for variable in variables
-        if !parsed_variables.include?(variable) && mapping[variable] != nil
-          raise TemplateOperatorAbortedError,
-            "Value mismatch for repeated variable."
-        end
-      end
-      if (parsed_variables & variables) != parsed_variables
-        raise TemplateOperatorAbortedError,
-          "Template operator 'join' variable mismatch: " +
-          "#{parsed_variables.inspect}, #{variables.inspect}"
-      end
-    end
-
-    ##
-    # Extracts a URI Template list operator.
-    #
-    # @param [String] value The unparsed value to extract from.
-    # @param [#restore] processor The processor object.
-    # @param [String] argument The argument to the operator.
-    # @param [Array] variables The variables the operator is working on.
-    # @param [Hash] mapping The mapping of variables to values.
-    #
-    # @return [String] The extracted result.
-    def extract_list_operator(value, processor, argument, variables, mapping)
-      if variables.size != 1
-        raise InvalidTemplateOperatorError,
-          "Template operator 'list' takes exactly one variable."
-      end
-      values = value.split(argument, -1)
-      values.pop if values[-1] == ""
-      if processor && processor.respond_to?(:restore)
-        values.map! { |value| processor.restore(variables.first, value) }
-      end
-      if mapping[variables.first] == nil || mapping[variables.first] == values
-        mapping[variables.first] = values
-      else
-        raise TemplateOperatorAbortedError,
-          "Value mismatch for repeated variable."
-      end
-    end
   end
 end