Vendor unreleased rack-mount 0.6.6.pre dependency

36 files changed, 4015 insertions, 2 deletions

diff --git a/actionpack/actionpack.gemspec b/actionpack/actionpack.gemspec
index 1dede257f9..54e8ad9acb 100644
--- a/actionpack/actionpack.gemspec
+++ b/actionpack/actionpack.gemspec
@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.add_dependency('i18n',          '~> 0.4.1')
   s.add_dependency('rack',          '~> 1.1.0')
   s.add_dependency('rack-test',     '~> 0.5.4')
-  s.add_dependency('rack-mount',    '~> 0.6.5')
+  #s.add_dependency('rack-mount',    '~> 0.6.6')
   s.add_dependency('tzinfo',        '~> 0.3.16')
   s.add_dependency('erubis',        '~> 2.6.5')
 end
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index 7be79d3200..05200f0338 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -1,8 +1,10 @@
-require 'rack/mount'
 require 'forwardable'
 require 'active_support/core_ext/object/to_query'
 require 'action_dispatch/routing/deprecated_mapper'
 
+$: << File.expand_path('../../vendor/rack-mount-0.6.6.pre', __FILE__)
+require 'rack/mount'
+
 module ActionDispatch
   module Routing
     class RouteSet #:nodoc:
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb
new file mode 100644
index 0000000000..9fbf707724
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount.rb
@@ -0,0 +1,32 @@
+require 'rack'
+
+module Rack #:nodoc:
+  # A stackable dynamic tree based Rack router.
+  #
+  # Rack::Mount supports Rack's Cascade style of trying several routes until
+  # it finds one that is not a 404. This allows multiple routes to be nested
+  # or stacked on top of each other. Since the application endpoint can
+  # trigger the router to continue matching, middleware can be used to add
+  # arbitrary conditions to any route. This allows you to route based on
+  # other request attributes, session information, or even data dynamically
+  # pulled from a database.
+  module Mount
+    autoload :CodeGeneration, 'rack/mount/code_generation'
+    autoload :GeneratableRegexp, 'rack/mount/generatable_regexp'
+    autoload :Multimap, 'rack/mount/multimap'
+    autoload :Prefix, 'rack/mount/prefix'
+    autoload :RegexpWithNamedGroups, 'rack/mount/regexp_with_named_groups'
+    autoload :Route, 'rack/mount/route'
+    autoload :RouteSet, 'rack/mount/route_set'
+    autoload :RoutingError, 'rack/mount/route_set'
+    autoload :Strexp, 'rack/mount/strexp'
+    autoload :Utils, 'rack/mount/utils'
+    autoload :Version, 'rack/mount/version'
+
+    module Analysis #:nodoc:
+      autoload :Frequency, 'rack/mount/analysis/frequency'
+      autoload :Histogram, 'rack/mount/analysis/histogram'
+      autoload :Splitting, 'rack/mount/analysis/splitting'
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb
new file mode 100644
index 0000000000..671258f807
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/frequency.rb
@@ -0,0 +1,60 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Analysis
+    class Frequency #:nodoc:
+      def initialize(*keys)
+        clear
+        keys.each { |key| self << key }
+      end
+
+      def clear
+        @raw_keys = []
+        @key_frequency = Analysis::Histogram.new
+        self
+      end
+
+      def <<(key)
+        raise ArgumentError unless key.is_a?(Hash)
+        @raw_keys << key
+        nil
+      end
+
+      def possible_keys
+        @possible_keys ||= begin
+          @raw_keys.map do |key|
+            key.inject({}) { |requirements, (method, requirement)|
+              process_key(requirements, method, requirement)
+              requirements
+            }
+          end
+        end
+      end
+
+      def process_key(requirements, method, requirement)
+        if requirement.is_a?(Regexp)
+          expression = Utils.parse_regexp(requirement)
+
+          if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+            expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
+            return requirements[method] = expression.to_s if expression.literal?
+          end
+        end
+
+        requirements[method] = requirement
+      end
+
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.keys_in_upper_quartile
+        end
+      end
+
+      def expire!
+        @possible_keys = @report = nil
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb
new file mode 100644
index 0000000000..20aaa132f9
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/histogram.rb
@@ -0,0 +1,74 @@
+module Rack::Mount
+  module Analysis
+    class Histogram < Hash #:nodoc:
+      attr_reader :count
+
+      def initialize
+        @count = 0
+        super(0)
+        expire_caches!
+      end
+
+      def <<(value)
+        @count += 1
+        self[value] += 1 if value
+        expire_caches!
+        self
+      end
+
+      def sorted_by_frequency
+        sort_by { |_, value| value }.reverse!
+      end
+
+      def max
+        @max ||= values.max || 0
+      end
+
+      def min
+        @min ||= values.min || 0
+      end
+
+      def mean
+        @mean ||= calculate_mean
+      end
+
+      def standard_deviation
+        @standard_deviation ||= calculate_standard_deviation
+      end
+
+      def upper_quartile_limit
+        @upper_quartile_limit ||= calculate_upper_quartile_limit
+      end
+
+      def keys_in_upper_quartile
+        @keys_in_upper_quartile ||= compute_keys_in_upper_quartile
+      end
+
+      private
+        def calculate_mean
+          count / size
+        end
+
+        def calculate_variance
+          values.inject(0) { |sum, e| sum + (e - mean) ** 2 } / count.to_f
+        end
+
+        def calculate_standard_deviation
+          Math.sqrt(calculate_variance)
+        end
+
+        def calculate_upper_quartile_limit
+          mean + standard_deviation
+        end
+
+        def compute_keys_in_upper_quartile
+          sorted_by_frequency.select { |_, value| value >= upper_quartile_limit }.map! { |key, _| key }
+        end
+
+        def expire_caches!
+          @max = @min = @mean = @standard_deviation = nil
+          @keys_in_upper_quartile = nil
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb
new file mode 100644
index 0000000000..8a8c551302
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/analysis/splitting.rb
@@ -0,0 +1,159 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Analysis
+    class Splitting < Frequency
+      NULL = "\0".freeze
+
+      class Key < Struct.new(:method, :index, :separators)
+        def self.split(value, separator_pattern)
+          keys = value.split(separator_pattern)
+          keys.shift if keys[0] == ''
+          keys << NULL
+          keys
+        end
+
+        def call(cache, obj)
+          (cache[method] ||= self.class.split(obj.send(method), separators))[index]
+        end
+
+        def call_source(cache, obj)
+          "(#{cache}[:#{method}] ||= Analysis::Splitting::Key.split(#{obj}.#{method}, #{separators.inspect}))[#{index}]"
+        end
+
+        def inspect
+          "#{method}[#{index}]"
+        end
+      end
+
+      def clear
+        @boundaries = {}
+        super
+      end
+
+      def <<(key)
+        super
+        key.each_pair do |k, v|
+          analyze_capture_boundaries(v, @boundaries[k] ||= Histogram.new)
+        end
+      end
+
+      def separators(key)
+        (@boundaries[key].keys_in_upper_quartile + ['/']).uniq
+      end
+
+      def process_key(requirements, method, requirement)
+        separators = separators(method)
+        if requirement.is_a?(Regexp) && separators.any?
+          generate_split_keys(requirement, separators).each_with_index do |value, index|
+            requirements[Key.new(method, index, Regexp.union(*separators))] = value
+          end
+        else
+          super
+        end
+      end
+
+      private
+        def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
+          return boundaries unless regexp.is_a?(Regexp)
+
+          parts = Utils.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            if part.is_a?(Regin::Group)
+              if index > 0
+                previous = parts[index-1]
+                if previous.is_a?(Regin::Character) && previous.literal?
+                  boundaries << previous.to_s
+                end
+              end
+
+              if inside = part.expression[0]
+                if inside.is_a?(Regin::Character) && inside.literal?
+                  boundaries << inside.to_s
+                end
+              end
+
+              if index < parts.length
+                following = parts[index+1]
+                if following.is_a?(Regin::Character) && following.literal?
+                  boundaries << following.to_s
+                end
+              end
+            end
+          end
+
+          boundaries
+        end
+
+        def generate_split_keys(regexp, separators) #:nodoc:
+          segments = []
+          buf = nil
+          parts = Utils.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            case part
+            when Regin::Anchor
+              if part.value == '$' || part.value == '\Z'
+                segments << join_buffer(buf, regexp) if buf
+                segments << NULL
+                buf = nil
+                break
+              end
+            when Regin::CharacterClass
+              break if separators.any? { |s| part.include?(s) }
+              buf = nil
+              segments << part.to_regexp(true)
+            when Regin::Character
+              if separators.any? { |s| part.include?(s) }
+                segments << join_buffer(buf, regexp) if buf
+                peek = parts[index+1]
+                if peek.is_a?(Regin::Character) && separators.include?(peek.value)
+                  segments << ''
+                end
+                buf = nil
+              else
+                buf ||= Regin::Expression.new([])
+                buf += [part]
+              end
+            when Regin::Group
+              if part.quantifier == '?'
+                value = part.expression.first
+                if separators.any? { |s| value.include?(s) }
+                  segments << join_buffer(buf, regexp) if buf
+                  buf = nil
+                end
+                break
+              elsif part.quantifier == nil
+                break if separators.any? { |s| part.include?(s) }
+                buf = nil
+                segments << part.to_regexp(true)
+              else
+                break
+              end
+            else
+              break
+            end
+
+            if index + 1 == parts.size
+              segments << join_buffer(buf, regexp) if buf
+              buf = nil
+              break
+            end
+          end
+
+          while segments.length > 0 && (segments.last.nil? || segments.last == '')
+            segments.pop
+          end
+
+          segments
+        end
+
+        def join_buffer(parts, regexp)
+          if parts.literal?
+            parts.to_s
+          else
+            parts.to_regexp(true)
+          end
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb
new file mode 100644
index 0000000000..903c79fdc6
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/code_generation.rb
@@ -0,0 +1,113 @@
+module Rack::Mount
+  module CodeGeneration #:nodoc:
+    def _expired_recognize(env) #:nodoc:
+      raise 'route set not finalized'
+    end
+
+    def rehash
+      super
+      optimize_recognize!
+    end
+
+    private
+      def expire!
+        if @optimized_recognize_defined
+          remove_metaclass_method :recognize
+
+          class << self
+            alias_method :recognize, :_expired_recognize
+          end
+
+          @optimized_recognize_defined = false
+        end
+
+        super
+      end
+
+      def optimize_container_iterator(container)
+        body = []
+
+        container.each_with_index { |route, i|
+          body << "route = self[#{i}]"
+          body << 'matches = {}'
+          body << 'params = route.defaults.dup'
+
+          conditions = []
+          route.conditions.each do |method, condition|
+            b = []
+            if condition.is_a?(Regexp)
+              b << "if m = obj.#{method}.match(#{condition.inspect})"
+              b << "matches[:#{method}] = m"
+              if (named_captures = route.named_captures[method]) && named_captures.any?
+                b << 'captures = m.captures'
+                b << 'p = nil'
+                b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = captures[#{j}]" }.join('; ')
+              end
+            else
+              b << "if m = obj.#{method} == route.conditions[:#{method}]"
+            end
+            b << 'true'
+            b << 'end'
+            conditions << "(#{b.join('; ')})"
+          end
+
+          body << <<-RUBY
+            if #{conditions.join(' && ')}
+              yield route, matches, params
+            end
+          RUBY
+        }
+
+        container.instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def optimized_each(obj)
+            #{body.join("\n")}
+            nil
+          end
+        RUBY
+      end
+
+      def optimize_recognize!
+        keys = @recognition_keys.map { |key|
+          if key.respond_to?(:call_source)
+            key.call_source(:cache, :obj)
+          else
+            "obj.#{key}"
+          end
+        }.join(', ')
+
+        @optimized_recognize_defined = true
+
+        remove_metaclass_method :recognize
+
+        instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def recognize(obj)
+            cache = {}
+            container = @recognition_graph[#{keys}]
+            optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
+
+            if block_given?
+              container.optimized_each(obj) do |route, matches, params|
+                yield route, matches, params
+              end
+            else
+              container.optimized_each(obj) do |route, matches, params|
+                return route, matches, params
+              end
+            end
+
+            nil
+          end
+        RUBY
+      end
+
+      # method_defined? can't distinguish between instance
+      # and meta methods. So we have to rescue if the method
+      # has not been defined in the metaclass yet.
+      def remove_metaclass_method(symbol)
+        metaclass = class << self; self; end
+        metaclass.send(:remove_method, symbol)
+      rescue NameError => e
+        nil
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb
new file mode 100644
index 0000000000..47bbab3784
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/generatable_regexp.rb
@@ -0,0 +1,210 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class GeneratableRegexp < Regexp #:nodoc:
+    class DynamicSegment #:nodoc:
+      attr_reader :name, :requirement
+
+      def initialize(name, requirement)
+        @name, @requirement = name.to_sym, requirement
+        freeze
+      end
+
+      def ==(obj)
+        @name == obj.name && @requirement == obj.requirement
+      end
+
+      def =~(str)
+        @requirement =~ str
+      end
+
+      def to_hash
+        { @name => @requirement }
+      end
+
+      def inspect
+        "/(?<#{@name}>#{@requirement.source})/"
+      end
+    end
+
+    module InstanceMethods
+      def self.extended(obj)
+        obj.segments
+      end
+
+      def defaults=(defaults)
+        @required_captures = nil
+        @required_params = nil
+        @required_defaults = nil
+        @defaults = defaults
+      end
+
+      def defaults
+        @defaults ||= {}
+      end
+
+      def generatable?
+        segments.any?
+      end
+
+      def generate(params = {}, recall = {}, options = {})
+        return nil unless generatable?
+
+        merged = recall.merge(params)
+        return nil unless required_params.all? { |p| merged.include?(p) }
+        return nil unless required_defaults.all? { |k, v| merged[k] == v }
+
+        generate_from_segments(segments, params, merged, options)
+      end
+
+      def segments
+        @segments ||= begin
+          defaults
+          segments = []
+          catch(:halt) do
+            expression = Utils.parse_regexp(self)
+            segments = parse_segments(expression)
+          end
+          segments
+        end
+      end
+
+      def captures
+        segments.flatten.find_all { |s| s.is_a?(DynamicSegment) }
+      end
+
+      def required_captures
+        @required_captures ||= segments.find_all { |s|
+          s.is_a?(DynamicSegment) && !@defaults.include?(s.name)
+        }.freeze
+      end
+
+      def required_params
+        @required_params ||= required_captures.map { |s| s.name }.freeze
+      end
+
+      def required_defaults
+        @required_defaults ||= begin
+          required_defaults = @defaults.dup
+          captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name|
+            required_defaults.delete(name)
+          }
+          required_defaults
+        end
+      end
+
+      def freeze
+        segments
+        captures
+        required_captures
+        required_params
+        required_defaults
+        super
+      end
+
+      private
+        def parse_segments(segments)
+          s = []
+          segments.each_with_index do |part, index|
+            case part
+            when Regin::Anchor
+              # ignore
+            when Regin::Character
+              throw :halt unless part.literal?
+
+              if s.last.is_a?(String)
+                s.last << part.value.dup
+              else
+                s << part.value.dup
+              end
+            when Regin::Group
+              if part.name
+                s << DynamicSegment.new(part.name, part.expression.to_regexp(true))
+              else
+                s << parse_segments(part.expression)
+              end
+            when Regin::Expression
+              return parse_segments(part)
+            else
+              throw :halt
+            end
+          end
+
+          s
+        end
+
+        EMPTY_STRING = ''.freeze
+
+        def generate_from_segments(segments, params, merged, options, optional = false)
+          if optional
+            return EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
+            return EMPTY_STRING unless segments.flatten.any? { |s|
+              params.has_key?(s.name) if s.is_a?(DynamicSegment)
+            }
+            return EMPTY_STRING if segments.any? { |segment|
+              if segment.is_a?(DynamicSegment)
+                value = merged[segment.name] || @defaults[segment.name]
+                value = parameterize(segment.name, value, options)
+
+                merged_value  = parameterize(segment.name, merged[segment.name], options)
+                default_value = parameterize(segment.name, @defaults[segment.name], options)
+
+                if value.nil? || segment !~ value
+                  true
+                elsif merged_value == default_value
+                  # Nasty control flow
+                  return :clear_remaining_segments
+                else
+                  false
+                end
+              end
+            }
+          end
+
+          generated = segments.map do |segment|
+            case segment
+            when String
+              segment
+            when DynamicSegment
+              value = params[segment.name] || merged[segment.name] || @defaults[segment.name]
+              value = parameterize(segment.name, value, options)
+              if value && segment =~ value.to_s
+                value
+              else
+                return
+              end
+            when Array
+              value = generate_from_segments(segment, params, merged, options, true)
+              if value == :clear_remaining_segments
+                segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+                EMPTY_STRING
+              elsif value.nil?
+                EMPTY_STRING
+              else
+                value
+              end
+            end
+          end
+
+          # Delete any used items from the params
+          segments.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+
+          generated.join
+        end
+
+        def parameterize(name, value, options)
+          if block = options[:parameterize]
+            block.call(name, value)
+          else
+            value
+          end
+        end
+    end
+    include InstanceMethods
+
+    def initialize(regexp)
+      super
+      segments
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb
new file mode 100644
index 0000000000..0f8eaaec67
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/multimap.rb
@@ -0,0 +1,53 @@
+begin
+  require 'nested_multimap'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/multimap'))
+  require 'nested_multimap'
+end
+
+module Rack::Mount
+  class Multimap < NestedMultimap #:nodoc:
+    def store(*args)
+      keys  = args.dup
+      value = keys.pop
+      key   = keys.shift
+
+      raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+      unless key.respond_to?(:=~)
+        raise ArgumentError, "unsupported key: #{args.first.inspect}"
+      end
+
+      if key.is_a?(Regexp)
+        if keys.empty?
+          @hash.each_pair { |k, l| l << value if k =~ key }
+          self.default << value
+        else
+          @hash.each_pair { |k, _|
+            if k =~ key
+              args[0] = k
+              super(*args)
+            end
+          }
+
+          self.default = self.class.new(default) unless default.is_a?(self.class)
+          default[*keys.dup] = value
+        end
+      else
+        super(*args)
+      end
+    end
+    alias_method :[]=, :store
+
+    undef :index, :invert
+
+    def height
+      containers_with_default.max { |a, b| a.length <=> b.length }.length
+    end
+
+    def average_height
+      lengths = containers_with_default.map { |e| e.length }
+      lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb
new file mode 100644
index 0000000000..58892e4c4f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/prefix.rb
@@ -0,0 +1,36 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class Prefix #:nodoc:
+    EMPTY_STRING = ''.freeze
+    PATH_INFO    = 'PATH_INFO'.freeze
+    SCRIPT_NAME  = 'SCRIPT_NAME'.freeze
+    SLASH        = '/'.freeze
+
+    KEY = 'rack.mount.prefix'.freeze
+
+    def initialize(app, prefix = nil)
+      @app, @prefix = app, prefix.freeze
+      freeze
+    end
+
+    def call(env)
+      if prefix = env[KEY] || @prefix
+        old_path_info = env[PATH_INFO].dup
+        old_script_name = env[SCRIPT_NAME].dup
+
+        begin
+          env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO].sub(prefix, EMPTY_STRING))
+          env[PATH_INFO] = EMPTY_STRING if env[PATH_INFO] == SLASH
+          env[SCRIPT_NAME] = Utils.normalize_path(env[SCRIPT_NAME].to_s + prefix)
+          @app.call(env)
+        ensure
+          env[PATH_INFO] = old_path_info
+          env[SCRIPT_NAME] = old_script_name
+        end
+      else
+        @app.call(env)
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb
new file mode 100644
index 0000000000..c11292b2a2
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/regexp_with_named_groups.rb
@@ -0,0 +1,69 @@
+module Rack::Mount
+  if Regin.regexp_supports_named_captures?
+    RegexpWithNamedGroups = Regexp
+  else
+    require 'strscan'
+
+    # A wrapper that adds shim named capture support to older
+    # versions of Ruby.
+    #
+    # Because the named capture syntax causes a parse error, an
+    # alternate syntax is used to indicate named captures.
+    #
+    # Ruby 1.9+ named capture syntax:
+    #
+    #   /(?<foo>[a-z]+)/
+    #
+    # Ruby 1.8 shim syntax:
+    #
+    #   /(?:<foo>[a-z]+)/
+    class RegexpWithNamedGroups < Regexp
+      def self.new(regexp) #:nodoc:
+        if regexp.is_a?(RegexpWithNamedGroups)
+          regexp
+        else
+          super
+        end
+      end
+
+      # Wraps Regexp with named capture support.
+      def initialize(regexp)
+        regexp = Regexp.compile(regexp) unless regexp.is_a?(Regexp)
+        source, options = regexp.source, regexp.options
+        @names, scanner = [], StringScanner.new(source)
+
+        while scanner.skip_until(/\(/)
+          if scanner.scan(/\?:<([^>]+)>/)
+            @names << scanner[1]
+          elsif scanner.scan(/\?(i?m?x?\-?i?m?x?)?:/)
+            # ignore noncapture
+          else
+            @names << nil
+          end
+        end
+        source.gsub!(/\?:<([^>]+)>/, '')
+
+        @names = [] unless @names.any?
+        @names.freeze
+
+        super(source, options)
+      end
+
+      def names
+        @names.dup
+      end
+
+      def named_captures
+        named_captures = {}
+        names.each_with_index { |n, i|
+          named_captures[n] = [i+1] if n
+        }
+        named_captures
+      end
+
+      def eql?(other)
+        super && @names.eql?(other.names)
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb
new file mode 100644
index 0000000000..680c40f147
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route.rb
@@ -0,0 +1,130 @@
+require 'rack/mount/generatable_regexp'
+require 'rack/mount/regexp_with_named_groups'
+require 'rack/mount/utils'
+
+module Rack::Mount
+  # Route is an internal class used to wrap a single route attributes.
+  #
+  # Plugins should not depend on any method on this class or instantiate
+  # new Route objects. Instead use the factory method, RouteSet#add_route
+  # to create new routes and add them to the set.
+  class Route
+    # Valid rack application to call if conditions are met
+    attr_reader :app
+
+    # A hash of conditions to match against. Conditions may be expressed
+    # as strings or regexps to match against.
+    attr_reader :conditions
+
+    # A hash of values that always gets merged into the parameters hash
+    attr_reader :defaults
+
+    # Symbol identifier for the route used with named route generations
+    attr_reader :name
+
+    attr_reader :named_captures
+
+    def initialize(app, conditions, defaults, name)
+      unless app.respond_to?(:call)
+        raise ArgumentError, 'app must be a valid rack application' \
+          ' and respond to call'
+      end
+      @app = app
+
+      @name = name ? name.to_sym : nil
+      @defaults = (defaults || {}).freeze
+
+      @conditions = {}
+
+      conditions.each do |method, pattern|
+        next unless method && pattern
+
+        pattern = Regexp.compile("\\A#{Regexp.escape(pattern)}\\Z") if pattern.is_a?(String)
+
+        if pattern.is_a?(Regexp)
+          pattern = Utils.normalize_extended_expression(pattern)
+          pattern = RegexpWithNamedGroups.new(pattern)
+          pattern.extend(GeneratableRegexp::InstanceMethods)
+          pattern.defaults = @defaults
+        end
+
+        @conditions[method] = pattern.freeze
+      end
+
+      @named_captures = {}
+      @conditions.map { |method, condition|
+        next unless condition.respond_to?(:named_captures)
+        @named_captures[method] = condition.named_captures.inject({}) { |named_captures, (k, v)|
+          named_captures[k.to_sym] = v.last - 1
+          named_captures
+        }.freeze
+      }
+      @named_captures.freeze
+
+      @has_significant_params = @conditions.any? { |method, condition|
+        (condition.respond_to?(:required_params) && condition.required_params.any?) ||
+          (condition.respond_to?(:required_defaults) && condition.required_defaults.any?)
+      }
+
+      if @conditions.has_key?(:path_info) &&
+          !Utils.regexp_anchored?(@conditions[:path_info])
+        @prefix = true
+        @app = Prefix.new(@app)
+      else
+        @prefix = false
+      end
+
+      @conditions.freeze
+    end
+
+    def prefix?
+      @prefix
+    end
+
+
+    def generation_keys
+      @conditions.inject({}) { |keys, (method, condition)|
+        if condition.respond_to?(:required_defaults)
+          keys.merge!(condition.required_defaults)
+        else
+          keys
+        end
+      }
+    end
+
+    def significant_params?
+      @has_significant_params
+    end
+
+    def generate(method, params = {}, recall = {}, options = {})
+      if method.nil?
+        result = @conditions.inject({}) { |h, (m, condition)|
+          if condition.respond_to?(:generate)
+            h[m] = condition.generate(params, recall, options)
+          end
+          h
+        }
+        return nil if result.values.compact.empty?
+      else
+        if condition = @conditions[method]
+          if condition.respond_to?(:generate)
+            result = condition.generate(params, recall, options)
+          end
+        end
+      end
+
+      if result
+        @defaults.each do |key, value|
+          params.delete(key) if params[key] == value
+        end
+      end
+
+      result
+    end
+
+
+    def inspect #:nodoc:
+      "#<#{self.class.name} @app=#{@app.inspect} @conditions=#{@conditions.inspect} @defaults=#{@defaults.inspect} @name=#{@name.inspect}>"
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb
new file mode 100644
index 0000000000..0e5a65a640
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/route_set.rb
@@ -0,0 +1,409 @@
+require 'rack/mount/multimap'
+require 'rack/mount/route'
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class RoutingError < StandardError; end
+
+  class RouteSet
+    # Initialize a new RouteSet without optimizations
+    def self.new_without_optimizations(options = {}, &block)
+      new(options.merge(:_optimize => false), &block)
+    end
+
+    # Basic RouteSet initializer.
+    #
+    # If a block is given, the set is yielded and finalized.
+    #
+    # See other aspects for other valid options:
+    # - <tt>Generation::RouteSet.new</tt>
+    # - <tt>Recognition::RouteSet.new</tt>
+    def initialize(options = {}, &block)
+      @parameters_key = options.delete(:parameters_key) || 'rack.routing_args'
+      @parameters_key.freeze
+
+      @named_routes = {}
+
+      @recognition_key_analyzer = Analysis::Splitting.new
+      @generation_key_analyzer  = Analysis::Frequency.new
+
+      @request_class = options.delete(:request_class) || Rack::Request
+      @valid_conditions = @request_class.public_instance_methods.map! { |m| m.to_sym }
+
+      extend CodeGeneration unless options[:_optimize] == false
+      @optimized_recognize_defined = false
+
+      @routes = []
+      expire!
+
+      if block_given?
+        yield self
+        rehash
+      end
+    end
+
+    # Builder method to add a route to the set
+    #
+    # <tt>app</tt>:: A valid Rack app to call if the conditions are met.
+    # <tt>conditions</tt>:: A hash of conditions to match against.
+    #                       Conditions may be expressed as strings or
+    #                       regexps to match against.
+    # <tt>defaults</tt>:: A hash of values that always gets merged in
+    # <tt>name</tt>:: Symbol identifier for the route used with named
+    #                 route generations
+    def add_route(app, conditions = {}, defaults = {}, name = nil)
+      unless conditions.is_a?(Hash)
+        raise ArgumentError, 'conditions must be a Hash'
+      end
+
+      unless conditions.all? { |method, pattern|
+          @valid_conditions.include?(method)
+        }
+        raise ArgumentError, 'conditions may only include ' +
+          @valid_conditions.inspect
+      end
+
+      route = Route.new(app, conditions, defaults, name)
+      @routes << route
+
+      @recognition_key_analyzer << route.conditions
+
+      @named_routes[route.name] = route if route.name
+      @generation_key_analyzer << route.generation_keys
+
+      expire!
+      route
+    end
+
+    def recognize(obj)
+      raise 'route set not finalized' unless @recognition_graph
+
+      cache = {}
+      keys = @recognition_keys.map { |key|
+        if key.respond_to?(:call)
+          key.call(cache, obj)
+        else
+          obj.send(key)
+        end
+      }
+
+      @recognition_graph[*keys].each do |route|
+        matches = {}
+        params  = route.defaults.dup
+
+        if route.conditions.all? { |method, condition|
+            value = obj.send(method)
+            if condition.is_a?(Regexp) && (m = value.match(condition))
+              matches[method] = m
+              captures = m.captures
+              route.named_captures[method].each do |k, i|
+                if v = captures[i]
+                  params[k] = v
+                end
+              end
+              true
+            elsif value == condition
+              true
+            else
+              false
+            end
+          }
+          if block_given?
+            yield route, matches, params
+          else
+            return route, matches, params
+          end
+        end
+      end
+
+      nil
+    end
+
+    X_CASCADE = 'X-Cascade'.freeze
+    PASS      = 'pass'.freeze
+    PATH_INFO = 'PATH_INFO'.freeze
+
+    # Rack compatible recognition and dispatching method. Routes are
+    # tried until one returns a non-catch status code. If no routes
+    # match, the catch status code is returned.
+    #
+    # This method can only be invoked after the RouteSet has been
+    # finalized.
+    def call(env)
+      raise 'route set not finalized' unless @recognition_graph
+
+      env[PATH_INFO] = Utils.normalize_path(env[PATH_INFO])
+
+      request = nil
+      req = @request_class.new(env)
+      recognize(req) do |route, matches, params|
+        # TODO: We only want to unescape params from uri related methods
+        params.each { |k, v| params[k] = Utils.unescape_uri(v) if v.is_a?(String) }
+
+        if route.prefix?
+          env[Prefix::KEY] = matches[:path_info].to_s
+        end
+
+        env[@parameters_key] = params
+        result = route.app.call(env)
+        return result unless result[1][X_CASCADE] == PASS
+      end
+
+      request || [404, {'Content-Type' => 'text/html', 'X-Cascade' => 'pass'}, ['Not Found']]
+    end
+
+    # Generates a url from Rack env and identifiers or significant keys.
+    #
+    # To generate a url by named route, pass the name in as a +Symbol+.
+    #   url(env, :dashboard) # => "/dashboard"
+    #
+    # Additional parameters can be passed in as a hash
+    #   url(env, :people, :id => "1") # => "/people/1"
+    #
+    # If no name route is given, it will fall back to a slower
+    # generation search.
+    #   url(env, :controller => "people", :action => "show", :id => "1")
+    #     # => "/people/1"
+    def url(env, *args)
+      named_route, params = nil, {}
+
+      case args.length
+      when 2
+        named_route, params = args[0], args[1].dup
+      when 1
+        if args[0].is_a?(Hash)
+          params = args[0].dup
+        else
+          named_route = args[0]
+        end
+      else
+        raise ArgumentError
+      end
+
+      only_path = params.delete(:only_path)
+      recall = env[@parameters_key] || {}
+
+      unless result = generate(:all, named_route, params, recall,
+          :parameterize => lambda { |name, param| Utils.escape_uri(param) })
+        return
+      end
+
+      parts, params = result
+      return unless parts
+
+      params.each do |k, v|
+        if v
+          params[k] = v
+        else
+          params.delete(k)
+        end
+      end
+
+      req = stubbed_request_class.new(env)
+      req._stubbed_values = parts.merge(:query_string => Utils.build_nested_query(params))
+      only_path ? req.fullpath : req.url
+    end
+
+    def generate(method, *args) #:nodoc:
+      raise 'route set not finalized' unless @generation_graph
+
+      method = nil if method == :all
+      named_route, params, recall, options = extract_params!(*args)
+      merged = recall.merge(params)
+      route = nil
+
+      if named_route
+        if route = @named_routes[named_route.to_sym]
+          recall = route.defaults.merge(recall)
+          url = route.generate(method, params, recall, options)
+          [url, params]
+        else
+          raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
+        end
+      else
+        keys = @generation_keys.map { |key|
+          if k = merged[key]
+            k.to_s
+          else
+            nil
+          end
+        }
+        @generation_graph[*keys].each do |r|
+          next unless r.significant_params?
+          if url = r.generate(method, params, recall, options)
+            return [url, params]
+          end
+        end
+
+        raise RoutingError, "No route matches #{params.inspect}"
+      end
+    end
+
+    # Number of routes in the set
+    def length
+      @routes.length
+    end
+
+    def rehash #:nodoc:
+      @recognition_keys  = build_recognition_keys
+      @recognition_graph = build_recognition_graph
+      @generation_keys   = build_generation_keys
+      @generation_graph  = build_generation_graph
+    end
+
+    # Finalizes the set and builds optimized data structures. You *must*
+    # freeze the set before you can use <tt>call</tt> and <tt>url</tt>.
+    # So remember to call freeze after you are done adding routes.
+    def freeze
+      unless frozen?
+        rehash
+
+        @recognition_key_analyzer = nil
+        @generation_key_analyzer  = nil
+        @valid_conditions         = nil
+
+        @routes.each { |route| route.freeze }
+        @routes.freeze
+      end
+
+      super
+    end
+
+    def marshal_dump #:nodoc:
+      hash = {}
+
+      instance_variables_to_serialize.each do |ivar|
+        hash[ivar] = instance_variable_get(ivar)
+      end
+
+      if graph = hash[:@recognition_graph]
+        hash[:@recognition_graph] = graph.dup
+      end
+
+      hash
+    end
+
+    def marshal_load(hash) #:nodoc:
+      hash.each do |ivar, value|
+        instance_variable_set(ivar, value)
+      end
+    end
+
+    protected
+      def recognition_stats
+        { :keys => @recognition_keys,
+          :keys_size => @recognition_keys.size,
+          :graph_size => @recognition_graph.size,
+          :graph_height => @recognition_graph.height,
+          :graph_average_height => @recognition_graph.average_height }
+      end
+
+    private
+      def expire! #:nodoc:
+        @recognition_keys = @recognition_graph = nil
+        @recognition_key_analyzer.expire!
+
+        @generation_keys = @generation_graph = nil
+        @generation_key_analyzer.expire!
+      end
+
+      def instance_variables_to_serialize
+        instance_variables.map { |ivar| ivar.to_sym } - [:@stubbed_request_class, :@optimized_recognize_defined]
+      end
+
+      # An internal helper method for constructing a nested set from
+      # the linear route set.
+      #
+      # build_nested_route_set([:request_method, :path_info]) { |route, method|
+      #   route.send(method)
+      # }
+      def build_nested_route_set(keys, &block)
+        graph = Multimap.new
+        @routes.each_with_index do |route, index|
+          catch(:skip) do
+            k = keys.map { |key| block.call(key, index) }
+            Utils.pop_trailing_nils!(k)
+            k.map! { |key| key || /.+/ }
+            graph[*k] = route
+          end
+        end
+        graph
+      end
+
+      def build_recognition_graph
+        build_nested_route_set(@recognition_keys) { |k, i|
+          @recognition_key_analyzer.possible_keys[i][k]
+        }
+      end
+
+      def build_recognition_keys
+        @recognition_key_analyzer.report
+      end
+
+      def build_generation_graph
+        build_nested_route_set(@generation_keys) { |k, i|
+          throw :skip unless @routes[i].significant_params?
+
+          if k = @generation_key_analyzer.possible_keys[i][k]
+            k.to_s
+          else
+            nil
+          end
+        }
+      end
+
+      def build_generation_keys
+        @generation_key_analyzer.report
+      end
+
+      def extract_params!(*args)
+        case args.length
+        when 4
+          named_route, params, recall, options = args
+        when 3
+          if args[0].is_a?(Hash)
+            params, recall, options = args
+          else
+            named_route, params, recall = args
+          end
+        when 2
+          if args[0].is_a?(Hash)
+            params, recall = args
+          else
+            named_route, params = args
+          end
+        when 1
+          if args[0].is_a?(Hash)
+            params = args[0]
+          else
+            named_route = args[0]
+          end
+        else
+          raise ArgumentError
+        end
+
+        named_route ||= nil
+        params  ||= {}
+        recall  ||= {}
+        options ||= {}
+
+        [named_route, params.dup, recall.dup, options.dup]
+      end
+
+      def stubbed_request_class
+        @stubbed_request_class ||= begin
+          klass = Class.new(@request_class)
+          klass.public_instance_methods.each do |method|
+            next if method =~ /^__|object_id/
+            klass.class_eval <<-RUBY
+              def #{method}(*args, &block)
+                @_stubbed_values[:#{method}] || super
+              end
+            RUBY
+          end
+          klass.class_eval { attr_accessor :_stubbed_values }
+          klass
+        end
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb
new file mode 100644
index 0000000000..d0d8797008
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp.rb
@@ -0,0 +1,68 @@
+require 'rack/mount/strexp/parser'
+
+module Rack::Mount
+  class Strexp
+    class << self
+      # Parses segmented string expression and converts it into a Regexp
+      #
+      #   Strexp.compile('foo')
+      #     # => %r{\Afoo\Z}
+      #
+      #   Strexp.compile('foo/:bar', {}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
+      #
+      #   Strexp.compile(':foo.example.com')
+      #     # => %r{\A(?<foo>.+)\.example\.com\Z}
+      #
+      #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
+      #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
+      #
+      #   Strexp.compile('foo(.:extension)')
+      #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
+      #
+      #   Strexp.compile('src/*files')
+      #     # => %r{\Asrc/(?<files>.+)\Z}
+      def compile(str, requirements = {}, separators = [], anchor = true)
+        return Regexp.compile(str) if str.is_a?(Regexp)
+
+        requirements = requirements ? requirements.dup : {}
+        normalize_requirements!(requirements, separators)
+
+        parser = StrexpParser.new
+        parser.anchor = anchor
+        parser.requirements = requirements
+
+        begin
+          re = parser.scan_str(str)
+        rescue Racc::ParseError => e
+          raise RegexpError, e.message
+        end
+
+        Regexp.compile(re)
+      end
+      alias_method :new, :compile
+
+      private
+        def normalize_requirements!(requirements, separators)
+          requirements.each do |key, value|
+            if value.is_a?(Regexp)
+              if regexp_has_modifiers?(value)
+                requirements[key] = value
+              else
+                requirements[key] = value.source
+              end
+            else
+              requirements[key] = Regexp.escape(value)
+            end
+          end
+          requirements.default ||= separators.any? ?
+            "[^#{separators.join}]+" : '.+'
+          requirements
+        end
+
+        def regexp_has_modifiers?(regexp)
+          regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb
new file mode 100644
index 0000000000..cfe05afc61
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.rb
@@ -0,0 +1,160 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require 'rack/mount/utils'
+require 'rack/mount/strexp/tokenizer'
+
+module Rack
+  module Mount
+    class StrexpParser < Racc::Parser
+
+
+if Regin.regexp_supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :anchor, :requirements
+##### State transition tables begin ###
+
+racc_action_table = [
+     1,     2,     3,     9,     4,     1,     2,     3,    12,     4,
+     1,     2,     3,    11,     4,     1,     2,     3,   nil,     4 ]
+
+racc_action_check = [
+     0,     0,     0,     5,     0,     3,     3,     3,     9,     3,
+     8,     8,     8,     8,     8,     6,     6,     6,   nil,     6 ]
+
+racc_action_pointer = [
+    -2,   nil,   nil,     3,   nil,     3,    13,   nil,     8,     8,
+   nil,   nil,   nil ]
+
+racc_action_default = [
+    -8,    -4,    -5,    -8,    -7,    -8,    -1,    -3,    -8,    -8,
+    -2,    -6,    13 ]
+
+racc_goto_table = [
+     6,     5,    10,     8,    10 ]
+
+racc_goto_check = [
+     2,     1,     3,     2,     3 ]
+
+racc_goto_pointer = [
+   nil,     1,     0,    -4 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     7 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 8, :_reduce_1,
+  2, 9, :_reduce_2,
+  1, 9, :_reduce_none,
+  1, 10, :_reduce_4,
+  1, 10, :_reduce_5,
+  3, 10, :_reduce_6,
+  1, 10, :_reduce_7 ]
+
+racc_reduce_n = 8
+
+racc_shift_n = 13
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :PARAM => 2,
+  :GLOB => 3,
+  :LPAREN => 4,
+  :RPAREN => 5,
+  :CHAR => 6 }
+
+racc_nt_base = 7
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "PARAM",
+  "GLOB",
+  "LPAREN",
+  "RPAREN",
+  "CHAR",
+  "$start",
+  "target",
+  "expr",
+  "token" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+ result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}"
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = val.join
+    result
+end
+
+# reduce 3 omitted
+
+def _reduce_4(val, _values, result)
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, requirement]
+
+    result
+end
+
+def _reduce_5(val, _values, result)
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement]
+
+    result
+end
+
+def _reduce_6(val, _values, result)
+ result = "(?:#{val[1]})?"
+    result
+end
+
+def _reduce_7(val, _values, result)
+ result = Regexp.escape(val[0])
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class StrexpParser
+  end   # module Mount
+end   # module Rack
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y
new file mode 100644
index 0000000000..ffbd9fae11
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/parser.y
@@ -0,0 +1,34 @@
+class Rack::Mount::StrexpParser
+rule
+  target: expr { result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" }
+
+  expr: expr token { result = val.join }
+      | token
+
+  token: PARAM {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, requirement]
+         }
+       | GLOB {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement]
+         }
+       | LPAREN expr RPAREN { result = "(?:#{val[1]})?" }
+       | CHAR { result = Regexp.escape(val[0]) }
+end
+
+---- header ----
+require 'rack/mount/utils'
+require 'rack/mount/strexp/tokenizer'
+
+---- inner
+
+if Regin.regexp_supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :anchor, :requirements
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb
new file mode 100644
index 0000000000..0ff7f67661
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rb
@@ -0,0 +1,83 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5.beta1
+# from lexical definition file "lib/rack/mount/strexp/tokenizer.rex".
+#++
+
+require 'racc/parser'
+class Rack::Mount::StrexpParser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\\(\(|\)|:|\*)/))
+         action { [:CHAR,  @ss[1]] }
+
+      when (text = @ss.scan(/\:([a-zA-Z_]\w*)/))
+         action { [:PARAM, @ss[1]] }
+
+      when (text = @ss.scan(/\*([a-zA-Z_]\w*)/))
+         action { [:GLOB,  @ss[1]] }
+
+      when (text = @ss.scan(/\(/))
+         action { [:LPAREN, text]  }
+
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN, text]  }
+
+      when (text = @ss.scan(/./))
+         action { [:CHAR,   text]  }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
+
+end # class
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex
new file mode 100644
index 0000000000..473bd096e1
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/strexp/tokenizer.rex
@@ -0,0 +1,12 @@
+class Rack::Mount::StrexpParser
+macro
+  RESERVED  \(|\)|:|\*
+  ALPHA_U   [a-zA-Z_]
+rule
+  \\({RESERVED})   { [:CHAR,  @ss[1]] }
+  \:({ALPHA_U}\w*) { [:PARAM, @ss[1]] }
+  \*({ALPHA_U}\w*) { [:GLOB,  @ss[1]] }
+  \(               { [:LPAREN, text]  }
+  \)               { [:RPAREN, text]  }
+  .                { [:CHAR,   text]  }
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb
new file mode 100644
index 0000000000..aa23b1162f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/utils.rb
@@ -0,0 +1,148 @@
+begin
+  require 'regin'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin'))
+  require 'regin'
+end
+
+require 'uri'
+
+module Rack::Mount
+  # Private utility methods used throughout Rack::Mount.
+  #--
+  # This module is a trash can. Try to move these functions into
+  # more appropriate contexts.
+  #++
+  module Utils
+    # Normalizes URI path.
+    #
+    # Strips off trailing slash and ensures there is a leading slash.
+    #
+    #   normalize_path("/foo")  # => "/foo"
+    #   normalize_path("/foo/") # => "/foo"
+    #   normalize_path("foo")   # => "/foo"
+    #   normalize_path("")      # => "/"
+    def normalize_path(path)
+      path = "/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
+    end
+    module_function :normalize_path
+
+    # Removes trailing nils from array.
+    #
+    #   pop_trailing_nils!([1, 2, 3])           # => [1, 2, 3]
+    #   pop_trailing_nils!([1, 2, 3, nil, nil]) # => [1, 2, 3]
+    #   pop_trailing_nils!([nil])               # => []
+    def pop_trailing_nils!(ary)
+      while ary.length > 0 && ary.last.nil?
+        ary.pop
+      end
+      ary
+    end
+    module_function :pop_trailing_nils!
+
+    RESERVED_PCHAR = ':@&=+$,;%'
+    SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}"
+    if RUBY_VERSION >= '1.9'
+      UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false).freeze
+    else
+      UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false, 'N').freeze
+    end
+
+    Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
+    def escape_uri(uri)
+      Parser.escape(uri.to_s, UNSAFE_PCHAR)
+    end
+    module_function :escape_uri
+
+    if ''.respond_to?(:force_encoding)
+      def unescape_uri(uri)
+        Parser.unescape(uri).force_encoding('utf-8')
+      end
+    else
+      def unescape_uri(uri)
+        URI.unescape(uri)
+      end
+    end
+    module_function :unescape_uri
+
+    # Taken from Rack 1.1.x to build nested query strings
+    def build_nested_query(value, prefix = nil) #:nodoc:
+      case value
+      when Array
+        value.map { |v|
+          build_nested_query(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          build_nested_query(v, prefix ? "#{prefix}[#{Rack::Utils.escape(k)}]" : Rack::Utils.escape(k))
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{Rack::Utils.escape(value)}"
+      else
+        prefix
+      end
+    end
+    module_function :build_nested_query
+
+    # Determines whether the regexp must match the entire string.
+    #
+    #   regexp_anchored?(/^foo$/) # => true
+    #   regexp_anchored?(/foo/)   # => false
+    #   regexp_anchored?(/^foo/)  # => false
+    #   regexp_anchored?(/foo$/)  # => false
+    def regexp_anchored?(regexp)
+     regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/m ? true : false
+    end
+    module_function :regexp_anchored?
+
+    def normalize_extended_expression(regexp)
+      return regexp unless regexp.options & Regexp::EXTENDED != 0
+      source = regexp.source
+      source.gsub!(/#.+$/, '')
+      source.gsub!(/\s+/, '')
+      source.gsub!(/\\\//, '/')
+      Regexp.compile(source)
+    end
+    module_function :normalize_extended_expression
+
+    def parse_regexp(regexp)
+      cache = @@_parse_regexp_cache ||= {}
+
+      if expression = cache[regexp]
+        return expression
+      end
+
+      unless regexp.is_a?(RegexpWithNamedGroups)
+        regexp = RegexpWithNamedGroups.new(regexp)
+      end
+
+      expression = Regin.parse(regexp)
+
+      unless Regin.regexp_supports_named_captures?
+        tag_captures = Proc.new do |group|
+          case group
+          when Regin::Group
+            # TODO: dup instead of mutating
+            group.instance_variable_set('@name', regexp.names[group.index]) if group.index
+            tag_captures.call(group.expression)
+          when Regin::Expression
+            group.each { |child| tag_captures.call(child) }
+          end
+        end
+        tag_captures.call(expression)
+      end
+
+      cache[regexp] = expression.freeze
+      expression
+    rescue Racc::ParseError, Regin::Parser::ScanError
+      []
+    end
+    module_function :parse_regexp
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb
new file mode 100644
index 0000000000..0b49b49280
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multimap.rb
@@ -0,0 +1,569 @@
+require 'forwardable'
+require 'multiset'
+
+# Multimap is a generalization of a map or associative array
+# abstract data type in which more than one value may be associated
+# with and returned for a given key.
+#
+# == Example
+#
+#   require 'multimap'
+#   map = Multimap.new
+#   map["a"] = 100
+#   map["b"] = 200
+#   map["a"] = 300
+#   map["a"]                              # -> [100, 300]
+#   map["b"]                              # -> [200]
+#   map.keys                              # -> #<Multiset: {a, a, b}>
+class Multimap
+  extend Forwardable
+
+  include Enumerable
+
+  # call-seq:
+  #   Multimap[ [key =>|, value]* ]   => multimap
+  #
+  # Creates a new multimap populated with the given objects.
+  #
+  #   Multimap["a", 100, "b", 200]       #=> {"a"=>[100], "b"=>[200]}
+  #   Multimap["a" => 100, "b" => 200]   #=> {"a"=>[100], "b"=>[200]}
+  def self.[](*args)
+    default = []
+
+    if args.size == 2 && args.last.is_a?(Hash)
+      default = args.shift
+    elsif !args.first.is_a?(Hash) && args.size % 2 == 1
+      default = args.shift
+    end
+
+    if args.size == 1 && args.first.is_a?(Hash)
+      args[0] = args.first.inject({}) { |hash, (key, value)|
+        unless value.is_a?(default.class)
+          value = (default.dup << value)
+        end
+        hash[key] = value
+        hash
+      }
+    else
+      index = 0
+      args.map! { |value|
+        unless index % 2 == 0 || value.is_a?(default.class)
+          value = (default.dup << value)
+        end
+        index += 1
+        value
+      }
+    end
+
+    map = new
+    map.instance_variable_set(:@hash, Hash[*args])
+    map.default = default
+    map
+  end
+
+  # call-seq:
+  #   Multimap.new           => multimap
+  #   Multimap.new(default)  => multimap
+  #
+  # Returns a new, empty multimap.
+  #
+  #   map = Multimap.new(Set.new)
+  #   h["a"] = 100
+  #   h["b"] = 200
+  #   h["a"]           #=> [100].to_set
+  #   h["c"]           #=> [].to_set
+  def initialize(default = [])
+    @hash = Hash.new(default)
+  end
+
+  def initialize_copy(original) #:nodoc:
+    @hash = Hash.new(original.default.dup)
+    original._internal_hash.each_pair do |key, container|
+      @hash[key] = container.dup
+    end
+  end
+
+  def_delegators :@hash, :clear, :default, :default=, :empty?,
+                         :fetch, :has_key?, :key?
+
+  # Retrieves the <i>value</i> object corresponding to the
+  # <i>*keys</i> object.
+  def [](key)
+    @hash[key]
+  end
+
+  # call-seq:
+  #   map[key] = value        => value
+  #   map.store(key, value)   => value
+  #
+  # Associates the value given by <i>value</i> with the key
+  # given by <i>key</i>. Unlike a regular hash, multiple can be
+  # assoicated with the same value.
+  #
+  #   map = Multimap["a" => 100, "b" => 200]
+  #   map["a"] = 9
+  #   map["c"] = 4
+  #   map   #=> {"a" => [100, 9], "b" => [200], "c" => [4]}
+  def store(key, value)
+    update_container(key) do |container|
+      container << value
+      container
+    end
+  end
+  alias_method :[]=, :store
+
+  # call-seq:
+  #   map.delete(key, value)  => value
+  #   map.delete(key)         => value
+  #
+  # Deletes and returns a key-value pair from <i>map</i>. If only
+  # <i>key</i> is given, all the values matching that key will be
+  # deleted.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.delete("b", 300) #=> 300
+  #   map.delete("a")      #=> [100]
+  def delete(key, value = nil)
+    if value
+      @hash[key].delete(value)
+    else
+      @hash.delete(key)
+    end
+  end
+
+  # call-seq:
+  #   map.each { |key, value| block } => map
+  #
+  # Calls <i>block</i> for each key/value pair in <i>map</i>, passing
+  # the key and value to the block as a two-element array.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each { |key, value| puts "#{key} is #{value}" }
+  #
+  # <em>produces:</em>
+  #
+  #   a is 100
+  #   b is 200
+  #   b is 300
+  def each
+    each_pair do |key, value|
+      yield [key, value]
+    end
+  end
+
+  # call-seq:
+  #   map.each_association { |key, container| block } => map
+  #
+  # Calls <i>block</i> once for each key/container in <i>map</i>, passing
+  # the key and container to the block as parameters.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each_association { |key, container| puts "#{key} is #{container}" }
+  #
+  # <em>produces:</em>
+  #
+  #   a is [100]
+  #   b is [200, 300]
+  def each_association(&block)
+    @hash.each_pair(&block)
+  end
+
+  # call-seq:
+  #   map.each_container { |container| block } => map
+  #
+  # Calls <i>block</i> for each container in <i>map</i>, passing the
+  # container as a parameter.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each_container { |container| puts container }
+  #
+  # <em>produces:</em>
+  #
+  #   [100]
+  #   [200, 300]
+  def each_container
+    each_association do |_, container|
+      yield container
+    end
+  end
+
+  # call-seq:
+  #   map.each_key { |key| block } => map
+  #
+  # Calls <i>block</i> for each key in <i>hsh</i>, passing the key
+  # as a parameter.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each_key { |key| puts key }
+  #
+  # <em>produces:</em>
+  #
+  #   a
+  #   b
+  #   b
+  def each_key
+    each_pair do |key, _|
+      yield key
+    end
+  end
+
+  # call-seq:
+  #   map.each_pair { |key_value_array| block } => map
+  #
+  # Calls <i>block</i> for each key/value pair in <i>map</i>,
+  # passing the key and value as parameters.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each_pair { |key, value| puts "#{key} is #{value}" }
+  #
+  # <em>produces:</em>
+  #
+  #   a is 100
+  #   b is 200
+  #   b is 300
+  def each_pair
+    each_association do |key, values|
+      values.each do |value|
+        yield key, value
+      end
+    end
+  end
+
+  # call-seq:
+  #   map.each_value { |value| block } => map
+  #
+  # Calls <i>block</i> for each key in <i>map</i>, passing the
+  # value as a parameter.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.each_value { |value| puts value }
+  #
+  # <em>produces:</em>
+  #
+  #   100
+  #   200
+  #   300
+  def each_value
+    each_pair do |_, value|
+      yield value
+    end
+  end
+
+  def ==(other) #:nodoc:
+    case other
+    when Multimap
+      @hash == other._internal_hash
+    else
+      @hash == other
+    end
+  end
+
+  def eql?(other) #:nodoc:
+    case other
+    when Multimap
+      @hash.eql?(other._internal_hash)
+    else
+      @hash.eql?(other)
+    end
+  end
+
+  def freeze #:nodoc:
+    each_container { |container| container.freeze }
+    default.freeze
+    super
+  end
+
+  # call-seq:
+  #   map.has_value?(value)    => true or false
+  #   map.value?(value)        => true or false
+  #
+  # Returns <tt>true</tt> if the given value is present for any key
+  # in <i>map</i>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.has_value?(300)   #=> true
+  #   map.has_value?(999)   #=> false
+  def has_value?(value)
+    values.include?(value)
+  end
+  alias_method :value?, :has_value?
+
+  # call-seq:
+  #   map.index(value)    => key
+  #
+  # Returns the key for a given value. If not found, returns
+  # <tt>nil</tt>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.index(100)   #=> "a"
+  #   map.index(200)   #=> "b"
+  #   map.index(999)   #=> nil
+  def index(value)
+    invert[value]
+  end
+
+  # call-seq:
+  #   map.delete_if {| key, value | block }  -> map
+  #
+  # Deletes every key-value pair from <i>map</i> for which <i>block</i>
+  # evaluates to <code>true</code>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.delete_if {|key, value| value >= 300 }
+  #     #=> Multimap["a" => 100, "b" => 200]
+  #
+  def delete_if
+    each_association do |key, container|
+      container.delete_if do |value|
+        yield [key, value]
+      end
+    end
+    self
+  end
+
+  # call-seq:
+  #   map.reject {| key, value | block }  -> map
+  #
+  # Same as <code>Multimap#delete_if</code>, but works on (and returns) a
+  # copy of the <i>map</i>. Equivalent to
+  # <code><i>map</i>.dup.delete_if</code>.
+  #
+  def reject(&block)
+    dup.delete_if(&block)
+  end
+
+  # call-seq:
+  #   map.reject! {| key, value | block }  -> map or nil
+  #
+  # Equivalent to <code>Multimap#delete_if</code>, but returns
+  # <code>nil</code> if no changes were made.
+  #
+  def reject!(&block)
+    old_size = size
+    delete_if(&block)
+    old_size == size ? nil : self
+  end
+
+  # call-seq:
+  #   map.replace(other_map) => map
+  #
+  # Replaces the contents of <i>map</i> with the contents of
+  # <i>other_map</i>.
+  #
+  #   map = Multimap["a" => 100, "b" => 200]
+  #   map.replace({ "c" => 300, "d" => 400 })
+  #   #=> Multimap["c" => 300, "d" => 400]
+  def replace(other)
+    case other
+    when Array
+      @hash.replace(self.class[self.default, *other])
+    when Hash
+      @hash.replace(self.class[self.default, other])
+    when self.class
+      @hash.replace(other)
+    else
+      raise ArgumentError
+    end
+  end
+
+  # call-seq:
+  #   map.invert => multimap
+  #
+  # Returns a new multimap created by using <i>map</i>'s values as keys,
+  # and the keys as values.
+  #
+  #   map = Multimap["n" => 100, "m" => 100, "d" => [200, 300]]
+  #   map.invert #=> Multimap[100 => ["n", "m"], 200 => "d", 300 => "d"]
+  def invert
+    h = self.class.new(default.dup)
+    each_pair { |key, value| h[value] = key }
+    h
+  end
+
+  # call-seq:
+  #   map.keys    => multiset
+  #
+  # Returns a new +Multiset+ populated with the keys from this hash. See also
+  # <tt>Multimap#values</tt> and <tt>Multimap#containers</tt>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
+  #   map.keys   #=> Multiset.new(["a", "b", "b", "c"])
+  def keys
+    keys = Multiset.new
+    each_key { |key| keys << key }
+    keys
+  end
+
+  # Returns true if the given key is present in Multimap.
+  def include?(key)
+    keys.include?(key)
+  end
+  alias_method :member?, :include?
+
+  # call-seq:
+  #   map.length    =>  fixnum
+  #   map.size      =>  fixnum
+  #
+  # Returns the number of key-value pairs in the map.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
+  #   map.length        #=> 4
+  #   map.delete("a")   #=> 100
+  #   map.length        #=> 3
+  def size
+    values.size
+  end
+  alias_method :length, :size
+
+  # call-seq:
+  #   map.merge(other_map) => multimap
+  #
+  # Returns a new multimap containing the contents of <i>other_map</i> and
+  # the contents of <i>map</i>.
+  #
+  #   map1 = Multimap["a" => 100, "b" => 200]
+  #   map2 = Multimap["a" => 254, "c" => 300]
+  #   map2.merge(map2) #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]
+  #   map1             #=> Multimap["a" => 100, "b" => 200]
+  def merge(other)
+    dup.update(other)
+  end
+
+  # call-seq:
+  #   map.merge!(other_map)    => multimap
+  #   map.update(other_map)    => multimap
+  #
+  # Adds each pair from <i>other_map</i> to <i>map</i>.
+  #
+  #   map1 = Multimap["a" => 100, "b" => 200]
+  #   map2 = Multimap["b" => 254, "c" => 300]
+  #
+  #   map1.merge!(map2)
+  #   #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]
+  def update(other)
+    case other
+    when self.class
+      other.each_pair { |key, value| store(key, value) }
+    when Hash
+      update(self.class[self.default, other])
+    else
+      raise ArgumentError
+    end
+    self
+  end
+  alias_method :merge!, :update
+
+  # call-seq:
+  #   map.select { |key, value| block }   => multimap
+  #
+  # Returns a new Multimap consisting of the pairs for which the
+  # block returns true.
+  #
+  #   map = Multimap["a" => 100, "b" => 200, "c" => 300]
+  #   map.select { |k,v| k > "a" }  #=> Multimap["b" => 200, "c" => 300]
+  #   map.select { |k,v| v < 200 }  #=> Multimap["a" => 100]
+  def select
+    inject(self.class.new) { |map, (key, value)|
+      map[key] = value if yield([key, value])
+      map
+    }
+  end
+
+  # call-seq:
+  #   map.to_a => array
+  #
+  # Converts <i>map</i> to a nested array of [<i>key,
+  # value</i>] arrays.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
+  #   map.to_a   #=> [["a", 100], ["b", 200], ["b", 300], ["c", 400]]
+  def to_a
+    ary = []
+    each_pair do |key, value|
+      ary << [key, value]
+    end
+    ary
+  end
+
+  # call-seq:
+  #   map.to_hash => hash
+  #
+  # Converts <i>map</i> to a basic hash.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.to_hash   #=> { "a" => [100], "b" => [200, 300] }
+  def to_hash
+    @hash.dup
+  end
+
+  # call-seq:
+  #   map.containers    => array
+  #
+  # Returns a new array populated with the containers from <i>map</i>. See
+  # also <tt>Multimap#keys</tt> and <tt>Multimap#values</tt>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.containers   #=> [[100], [200, 300]]
+  def containers
+    containers = []
+    each_container { |container| containers << container }
+    containers
+  end
+
+  # call-seq:
+  #   map.values    => array
+  #
+  # Returns a new array populated with the values from <i>map</i>. See
+  # also <tt>Multimap#keys</tt> and <tt>Multimap#containers</tt>.
+  #
+  #   map = Multimap["a" => 100, "b" => [200, 300]]
+  #   map.values   #=> [100, 200, 300]
+  def values
+    values = []
+    each_value { |value| values << value }
+    values
+  end
+
+  # Return an array containing the values associated with the given keys.
+  def values_at(*keys)
+    @hash.values_at(*keys)
+  end
+
+  def marshal_dump #:nodoc:
+    @hash
+  end
+
+  def marshal_load(hash) #:nodoc:
+    @hash = hash
+  end
+
+  def to_yaml(opts = {}) #:nodoc:
+    YAML::quick_emit(self, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        @hash.each do |k, v|
+          map.add(k, v)
+        end
+        map.add('__default__', @hash.default)
+      end
+    end
+  end
+
+  def yaml_initialize(tag, val) #:nodoc:
+    default = val.delete('__default__')
+    @hash = val
+    @hash.default = default
+    self
+  end
+
+  protected
+    def _internal_hash #:nodoc:
+      @hash
+    end
+
+    def update_container(key) #:nodoc:
+      container = @hash[key]
+      container = container.dup if container.equal?(default)
+      container = yield(container)
+      @hash[key] = container
+    end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb
new file mode 100644
index 0000000000..119bf12646
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/multiset.rb
@@ -0,0 +1,185 @@
+require 'set'
+
+# Multiset implements a collection of unordered values and
+# allows duplicates.
+#
+# == Example
+#
+#   require 'multiset'
+#   s1 = Multiset.new [1, 2]              # -> #<Multiset: {1, 2}>
+#   s1.add(2)                             # -> #<Multiset: {1, 2, 2}>
+#   s1.merge([2, 6])                      # -> #<Multiset: {1, 2, 2, 2, 3}>
+#   s1.multiplicity(2)                    # -> 3
+#   s1.multiplicity(3)                    # -> 1
+class Multiset < Set
+  def initialize(*args, &block) #:nodoc:
+    @hash = Hash.new(0)
+    super
+  end
+
+  # Returns the number of times an element belongs to the multiset.
+  def multiplicity(e)
+    @hash[e]
+  end
+
+  # Returns the total number of elements in a multiset, including
+  # repeated memberships
+  def cardinality
+    @hash.inject(0) { |s, (e, m)| s += m }
+  end
+  alias_method :size, :cardinality
+  alias_method :length, :cardinality
+
+  # Converts the set to an array. The order of elements is uncertain.
+  def to_a
+    inject([]) { |ary, (key, _)| ary << key }
+  end
+
+  # Returns true if the set is a superset of the given set.
+  def superset?(set)
+    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
+    return false if cardinality < set.cardinality
+    set.all? { |o| set.multiplicity(o) <= multiplicity(o) }
+  end
+
+  # Returns true if the set is a proper superset of the given set.
+  def proper_superset?(set)
+    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
+    return false if cardinality <= set.cardinality
+    set.all? { |o| set.multiplicity(o) <= multiplicity(o) }
+  end
+
+  # Returns true if the set is a subset of the given set.
+  def subset?(set)
+    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
+    return false if set.cardinality < cardinality
+    all? { |o| multiplicity(o) <= set.multiplicity(o) }
+  end
+
+  # Returns true if the set is a proper subset of the given set.
+  def proper_subset?(set)
+    set.is_a?(self.class) or raise ArgumentError, "value must be a set"
+    return false if set.cardinality <= cardinality
+    all? { |o| multiplicity(o) <= set.multiplicity(o) }
+  end
+
+  # Calls the given block once for each element in the set, passing
+  # the element as parameter. Returns an enumerator if no block is
+  # given.
+  def each
+    @hash.each_pair do |key, multiplicity|
+      multiplicity.times do
+        yield(key)
+      end
+    end
+    self
+  end
+
+  # Adds the given object to the set and returns self. Use +merge+ to
+  # add many elements at once.
+  def add(o)
+    @hash[o] ||= 0
+    @hash[o] += 1
+    self
+  end
+  alias << add
+
+  undef :add?
+
+  # Deletes all the identical object from the set and returns self.
+  # If +n+ is given, it will remove that amount of identical objects
+  # from the set. Use +subtract+ to delete many different items at
+  # once.
+  def delete(o, n = nil)
+    if n
+      @hash[o] ||= 0
+      @hash[o] -= n if @hash[o] > 0
+      @hash.delete(o) if @hash[o] == 0
+    else
+      @hash.delete(o)
+    end
+    self
+  end
+
+  undef :delete?
+
+  # Deletes every element of the set for which block evaluates to
+  # true, and returns self.
+  def delete_if
+    each { |o| delete(o) if yield(o) }
+    self
+  end
+
+  # Merges the elements of the given enumerable object to the set and
+  # returns self.
+  def merge(enum)
+    enum.each { |o| add(o) }
+    self
+  end
+
+  # Deletes every element that appears in the given enumerable object
+  # and returns self.
+  def subtract(enum)
+    enum.each { |o| delete(o, 1) }
+    self
+  end
+
+  # Returns a new set containing elements common to the set and the
+  # given enumerable object.
+  def &(enum)
+    s = dup
+    n = self.class.new
+    enum.each { |o|
+      if s.include?(o)
+        s.delete(o, 1)
+        n.add(o)
+      end
+    }
+    n
+  end
+  alias intersection &
+
+  # Returns a new set containing elements exclusive between the set
+  # and the given enumerable object.  (set ^ enum) is equivalent to
+  # ((set | enum) - (set & enum)).
+  def ^(enum)
+    n = self.class.new(enum)
+    each { |o| n.include?(o) ? n.delete(o, 1) : n.add(o) }
+    n
+  end
+
+  # Returns true if two sets are equal. Two multisets are equal if
+  # they have the same cardinalities and each element has the same
+  # multiplicity in both sets. The equality of each element inside
+  # the multiset is defined according to Object#eql?.
+  def eql?(set)
+    return true if equal?(set)
+    set = self.class.new(set) unless set.is_a?(self.class)
+    return false unless cardinality == set.cardinality
+    superset?(set) && subset?(set)
+  end
+  alias_method :==, :eql?
+
+  def marshal_dump #:nodoc:
+    @hash
+  end
+
+  def marshal_load(hash) #:nodoc:
+    @hash = hash
+  end
+
+  def to_yaml(opts = {}) #:nodoc:
+    YAML::quick_emit(self, opts) do |out|
+      out.map(taguri, to_yaml_style) do |map|
+        @hash.each do |k, v|
+          map.add(k, v)
+        end
+      end
+    end
+  end
+
+  def yaml_initialize(tag, val) #:nodoc:
+    @hash = val
+    self
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb
new file mode 100644
index 0000000000..4eb088b91a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/multimap/nested_multimap.rb
@@ -0,0 +1,158 @@
+require 'multimap'
+
+# NestedMultimap allows values to be assoicated with a nested
+# set of keys.
+class NestedMultimap < Multimap
+  # call-seq:
+  #   multimap[*keys] = value      => value
+  #   multimap.store(*keys, value) => value
+  #
+  # Associates the value given by <i>value</i> with multiple key
+  # given by <i>keys</i>.
+  #
+  #   map = NestedMultimap.new
+  #   map["a"] = 100
+  #   map["a", "b"] = 101
+  #   map["a"] = 102
+  #   map   #=> {"a"=>{"b"=>[100, 101, 102], default => [100, 102]}}
+  def store(*args)
+    keys  = args
+    value = args.pop
+
+    raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+    if keys.length > 1
+      update_container(keys.shift) do |container|
+        container = self.class.new(container) unless container.is_a?(self.class)
+        container[*keys] = value
+        container
+      end
+    elsif keys.length == 1
+      super(keys.first, value)
+    else
+      self << value
+    end
+  end
+  alias_method :[]=, :store
+
+  # call-seq:
+  #   multimap << obj  => multimap
+  #
+  # Pushes the given object on to the end of all the containers.
+  #
+  #   map = NestedMultimap["a" => [100], "b" => [200, 300]]
+  #   map << 300
+  #   map["a"] #=> [100, 300]
+  #   map["c"] #=> [300]
+  def <<(value)
+    @hash.each_value { |container| container << value }
+    self.default << value
+    self
+  end
+
+  # call-seq:
+  #   multimap[*keys]               =>  value
+  #   multimap[key1, key2, key3]    =>  value
+  #
+  # Retrieves the <i>value</i> object corresponding to the
+  # <i>*keys</i> object.
+  def [](*keys)
+    i, l, r, k = 0, keys.length, self, self.class
+    while r.is_a?(k)
+      r = i < l ? r._internal_hash[keys[i]] : r.default
+      i += 1
+    end
+    r
+  end
+
+  # call-seq:
+  #   multimap.each_association { |key, container| block } => multimap
+  #
+  # Calls <i>block</i> once for each key/container in <i>map</i>, passing
+  # the key and container to the block as parameters.
+  #
+  #   map = NestedMultimap.new
+  #   map["a"] = 100
+  #   map["a", "b"] = 101
+  #   map["a"] = 102
+  #   map["c"] = 200
+  #   map.each_association { |key, container| puts "#{key} is #{container}" }
+  #
+  # <em>produces:</em>
+  #
+  #   ["a", "b"] is [100, 101, 102]
+  #   "c" is [200]
+  def each_association
+    super() do |key, container|
+      if container.respond_to?(:each_association)
+        container.each_association do |nested_key, value|
+          yield [key, nested_key].flatten, value
+        end
+      else
+        yield key, container
+      end
+    end
+  end
+
+  # call-seq:
+  #   multimap.each_container_with_default { |container| block } => map
+  #
+  # Calls <i>block</i> for every container in <i>map</i> including
+  # the default, passing the container as a parameter.
+  #
+  #   map = NestedMultimap.new
+  #   map["a"] = 100
+  #   map["a", "b"] = 101
+  #   map["a"] = 102
+  #   map.each_container_with_default { |container| puts container }
+  #
+  # <em>produces:</em>
+  #
+  #   [100, 101, 102]
+  #   [100, 102]
+  #   []
+  def each_container_with_default(&block)
+    @hash.each_value do |container|
+      iterate_over_container(container, &block)
+    end
+    iterate_over_container(default, &block)
+    self
+  end
+
+  # call-seq:
+  #   multimap.containers_with_default    => array
+  #
+  # Returns a new array populated with all the containers from
+  # <i>map</i> including the default.
+  #
+  #   map = NestedMultimap.new
+  #   map["a"] = 100
+  #   map["a", "b"] = 101
+  #   map["a"] = 102
+  #   map.containers_with_default   #=> [[100, 101, 102], [100, 102], []]
+  def containers_with_default
+    containers = []
+    each_container_with_default { |container| containers << container }
+    containers
+  end
+
+  def inspect #:nodoc:
+    super.gsub(/\}$/, ", default => #{default.inspect}}")
+  end
+
+  private
+    def iterate_over_container(container)
+      if container.respond_to?(:each_container_with_default)
+        container.each_container_with_default do |value|
+          yield value
+        end
+      else
+        yield container
+      end
+    end
+end
+
+begin
+  require 'nested_multimap_ext'
+rescue LoadError
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb
new file mode 100644
index 0000000000..d38922bcc6
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin.rb
@@ -0,0 +1,45 @@
+module Regin
+  autoload :Alternation, 'regin/alternation'
+  autoload :Anchor, 'regin/anchor'
+  autoload :Atom, 'regin/atom'
+  autoload :Character, 'regin/character'
+  autoload :CharacterClass, 'regin/character_class'
+  autoload :Collection, 'regin/collection'
+  autoload :Expression, 'regin/expression'
+  autoload :Group, 'regin/group'
+  autoload :Options, 'regin/options'
+  autoload :Parser, 'regin/parser'
+
+  class << self
+    begin
+      eval('foo = /(?<foo>.*)/').named_captures
+
+      # Returns true if the interpreter is using the Oniguruma Regexp lib
+      # and supports named captures.
+      #
+      #   /(?<foo>bar)/
+      def regexp_supports_named_captures?
+        true
+      end
+    rescue SyntaxError, NoMethodError
+      def regexp_supports_named_captures? #:nodoc:
+        false
+      end
+    end
+
+    # Parses Regexp and returns a Expression data structure.
+    def parse(regexp)
+      Parser.parse_regexp(regexp)
+    end
+
+    # Recompiles Regexp by parsing it and turning it back into a Regexp.
+    #
+    # (In the future Regin will perform some Regexp optimizations
+    # such as removing unnecessary captures and options)
+    def compile(source)
+      regexp = Regexp.compile(source)
+      expression = parse(regexp)
+      Regexp.compile(expression.to_s(true), expression.flags)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb
new file mode 100644
index 0000000000..ce4f52bfdb
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/alternation.rb
@@ -0,0 +1,40 @@
+module Regin
+  class Alternation < Collection
+    def initialize(*args)
+      args, options = extract_options(args)
+
+      if args.length == 1 && args.first.instance_of?(Array)
+        super(args.first)
+      else
+        super(args)
+      end
+
+      if options.key?(:ignorecase)
+        @array.map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
+      end
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # Alternation groups are never literal.
+    def literal?
+      false
+    end
+
+    def flags
+      0
+    end
+
+    def dup(options = {})
+      self.class.new(to_a, options)
+    end
+
+    def to_s(parent = false)
+      map { |e| e.to_s(parent) }.join('|')
+    end
+
+    def inspect #:nodoc:
+      to_s.inspect
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb
new file mode 100644
index 0000000000..05520dd5e0
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/anchor.rb
@@ -0,0 +1,4 @@
+module Regin
+  class Anchor < Atom
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb
new file mode 100644
index 0000000000..eb1923a5a1
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/atom.rb
@@ -0,0 +1,59 @@
+module Regin
+  class Atom
+    attr_reader :value, :ignorecase
+
+    def initialize(value, options = {})
+      @value = value
+      @ignorecase = options[:ignorecase]
+    end
+
+    def option_names
+      %w( ignorecase )
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    def literal?
+      false
+    end
+
+    def casefold?
+      ignorecase ? true : false
+    end
+
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(value, original_options.merge(options))
+    end
+
+    def to_s(parent = false)
+      "#{value}"
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class.to_s.sub('Regin::', '')} #{to_s.inspect}>"
+    end
+
+    def ==(other) #:nodoc:
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      other.instance_of?(self.class) &&
+        self.value.eql?(other.value) &&
+        (!!self.ignorecase).eql?(!!other.ignorecase)
+    end
+
+    def freeze #:nodoc:
+      value.freeze
+      super
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb
new file mode 100644
index 0000000000..12a9199d2a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character.rb
@@ -0,0 +1,56 @@
+module Regin
+  class Character < Atom
+    attr_reader :quantifier
+
+    def initialize(value, options = {})
+      @quantifier = options[:quantifier]
+      super
+    end
+
+    def option_names
+      %w( quantifier ) + super
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Character is literal is there is no quantifier attached to it.
+    def literal?
+      quantifier.nil? && !ignorecase
+    end
+
+    def to_s(parent = false)
+      if !parent && ignorecase
+        "(?i-mx:#{value})#{quantifier}"
+      else
+        "#{value}#{quantifier}"
+      end
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s(true)
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re, ignorecase)
+    end
+
+    def match(char)
+      to_regexp(true).match(char)
+    end
+
+    def include?(char)
+      if ignorecase
+        value.downcase == char.downcase
+      else
+        value == char
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      super && quantifier.eql?(other.quantifier)
+    end
+
+    def freeze #:nodoc:
+      quantifier.freeze if quantifier
+      super
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb
new file mode 100644
index 0000000000..caed5ef9d0
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/character_class.rb
@@ -0,0 +1,55 @@
+module Regin
+  class CharacterClass < Character
+    def initialize(value, options = {})
+      @negate = options[:negate]
+      super
+    end
+
+    def option_names
+      %w( negate ) + super
+    end
+
+    attr_reader :negate
+
+    def negated?
+      negate ? true : false
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A CharacterClass is never literal.
+    def literal?
+      false
+    end
+
+    def bracketed?
+      value != '.' && value !~ /^\\[dDsSwW]$/
+    end
+
+    def to_s(parent = false)
+      if bracketed?
+        if !parent && ignorecase
+          "(?i-mx:[#{negate && '^'}#{value}])#{quantifier}"
+        else
+          "[#{negate && '^'}#{value}]#{quantifier}"
+        end
+      else
+        super
+      end
+    end
+
+    def include?(char)
+      re = quantifier ? to_s.sub(/#{Regexp.escape(quantifier)}$/, '') : to_s
+      Regexp.compile("\\A#{re}\\Z").match(char)
+    end
+
+    def eql?(other) #:nodoc:
+      super && negate == other.negate
+    end
+
+    def freeze #:nodoc:
+      negate.freeze if negate
+      super
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb
new file mode 100644
index 0000000000..b60353268a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/collection.rb
@@ -0,0 +1,83 @@
+module Regin
+  class Collection
+    include Enumerable
+
+    def initialize(*args)
+      @array = Array.new(*args)
+    end
+
+    def each
+      @array.each{ |item| yield item }
+    end
+
+    def [](i)
+      @array[i]
+    end
+
+    def length
+      @array.length
+    end
+    alias_method :size, :length
+
+    def first
+      @array.first
+    end
+
+    def last
+      @array.last
+    end
+
+    def +(other)
+      ary = other.is_a?(self.class) ? other.internal_array : other
+      self.class.new(@array + ary)
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s(true)
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re, flags)
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      any? { |e| e.include?(char) }
+    end
+
+    def ==(other) #:nodoc:
+      case other
+      when String
+        other == to_s
+      when Array
+        other == @array
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      other.instance_of?(self.class) && @array.eql?(other.internal_array)
+    end
+
+    def freeze #:nodoc:
+      each { |e| e.freeze }
+      @array.freeze
+      super
+    end
+
+    protected
+      def internal_array #:nodoc:
+        @array
+      end
+
+      def extract_options(args)
+        if args.last.is_a?(Hash)
+          return args[0..-2], args.last
+        else
+          return args, {}
+        end
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb
new file mode 100644
index 0000000000..18e4965097
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/expression.rb
@@ -0,0 +1,126 @@
+module Regin
+  class Expression < Collection
+    attr_reader :ignorecase, :multiline, :extended
+
+    def initialize(*args)
+      args, options = extract_options(args)
+
+      @multiline = @ignorecase = @extended = nil
+
+      if args.length == 1 && args.first.instance_of?(Array)
+        super(args.first)
+      else
+        args = args.map { |e| e.instance_of?(String) ? Character.new(e) : e }
+        super(args)
+      end
+
+      self.multiline  = options[:multiline] if options.key?(:multiline)
+      self.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      self.extended   = options[:extended] if options.key?(:extended)
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Expression is literal if all its elements are literal.
+    def literal?
+      !ignorecase && all? { |e| e.literal? }
+    end
+
+    def anchored?
+      anchored_to_start? && anchored_to_end?
+    end
+
+    def anchored_to_start?
+      first.is_a?(Anchor) && first == '\A'
+    end
+
+    def anchored_to_end?
+      last.is_a?(Anchor) && last == '\Z'
+    end
+
+    def anchored_to_line?
+      anchored_to_start_of_line? && anchored_to_end_of_line?
+    end
+
+    def anchored_to_start_of_line?
+      anchored_to_start? || (first.is_a?(Anchor) && first == '^')
+    end
+
+    def anchored_to_end_of_line?
+      anchored_to_end? || (last.is_a?(Anchor) && last == '$')
+    end
+
+    def options?
+      options.any?(true)
+    end
+
+    def flags
+      options.to_i
+    end
+
+    def +(other)
+      ary = other.is_a?(self.class) ? other.internal_array : other
+      ary = @array + ary + [options.to_h(true)]
+      self.class.new(*ary)
+    end
+
+    def dup(options = {})
+      expression = super()
+      expression.multiline  = options[:multiline] if options.key?(:multiline)
+      expression.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      expression.extended   = options[:extended] if options.key?(:extended)
+      expression
+    end
+
+    def to_s(parent = false)
+      if parent || !options?
+        map { |e| e.to_s(parent) }.join
+      else
+        with, without = [], []
+        multiline ? (with << 'm') : (without << 'm')
+        ignorecase ? (with << 'i') : (without << 'i')
+        extended ? (with << 'x') : (without << 'x')
+
+        with = with.join
+        without = without.any? ? "-#{without.join}" : ''
+
+        "(?#{with}#{without}:#{map { |e| e.to_s(true) }.join})"
+      end
+    end
+
+    def inspect #:nodoc:
+      "#<Expression #{to_s.inspect}>"
+    end
+
+    def casefold?
+      ignorecase
+    end
+
+    def eql?(other) #:nodoc:
+      super &&
+        !!self.multiline == !!other.multiline &&
+        !!self.ignorecase == !!other.ignorecase &&
+        !!self.extended == !!other.extended
+    end
+
+    protected
+      def options
+        Options.new(multiline, ignorecase, extended)
+      end
+
+      def multiline=(multiline)
+        @multiline = multiline
+      end
+
+      def ignorecase=(ignorecase)
+        if @ignorecase.nil?
+          @array.map! { |e| e.dup(:ignorecase => ignorecase) }
+          @ignorecase = ignorecase
+        end
+      end
+
+      def extended=(extended)
+        @extended = extended
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb
new file mode 100644
index 0000000000..d682148bd9
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/group.rb
@@ -0,0 +1,90 @@
+module Regin
+  class Group
+    attr_reader :expression, :quantifier, :capture, :index, :name
+
+    def initialize(expression, options = {})
+      @quantifier = @index = @name = nil
+      @capture = true
+      @expression = expression.dup(options)
+
+      @quantifier = options[:quantifier] if options.key?(:quantifier)
+      @capture    = options[:capture] if options.key?(:capture)
+      @index      = options[:index] if options.key?(:index)
+      @name       = options[:name] if options.key?(:name)
+    end
+
+    def option_names
+      %w( quantifier capture index name )
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Group is literal if its expression is literal and it has no quantifier.
+    def literal?
+      quantifier.nil? && expression.literal?
+    end
+
+    def to_s(parent = false)
+      if !expression.options?
+        "(#{capture ? '' : '?:'}#{expression.to_s(parent)})#{quantifier}"
+      elsif capture == false
+        "#{expression.to_s}#{quantifier}"
+      else
+        "(#{expression.to_s})#{quantifier}"
+      end
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re)
+    end
+
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(expression, original_options.merge(options))
+    end
+
+    def inspect #:nodoc:
+      to_s.inspect
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      expression.include?(char)
+    end
+
+    def capture?
+      capture
+    end
+
+    def ==(other) #:nodoc:
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      other.is_a?(self.class) &&
+        self.expression == other.expression &&
+        self.quantifier == other.quantifier &&
+        self.capture == other.capture &&
+        self.index == other.index &&
+        self.name == other.name
+    end
+
+    def freeze #:nodoc:
+      expression.freeze if expression
+      super
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb
new file mode 100644
index 0000000000..03ba29d9a5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/options.rb
@@ -0,0 +1,55 @@
+module Regin
+  class Options
+    def self.from_int(flags)
+      multiline  = flags & Regexp::MULTILINE != 0
+      ignorecase = flags & Regexp::IGNORECASE != 0
+      extended   = flags & Regexp::EXTENDED != 0
+
+      new(multiline, ignorecase, extended)
+    end
+
+    attr_reader :multiline, :ignorecase, :extended
+
+    def initialize(*args)
+      if args.first.is_a?(Hash)
+        @multiline  = args[0][:multiline]
+        @ignorecase = args[0][:ignorecase]
+        @extended   = args[0][:extended]
+      else
+        @multiline  = args[0]
+        @ignorecase = args[1]
+        @extended   = args[2]
+      end
+    end
+
+    def any?(explicit = false)
+      if explicit
+        !multiline.nil? || !ignorecase.nil? || !extended.nil?
+      else
+        multiline || ignorecase || extended
+      end
+    end
+
+    def to_h(explicit = false)
+      if explicit
+        options = {}
+        options[:multiline]  = multiline  unless multiline.nil?
+        options[:ignorecase] = ignorecase unless ignorecase.nil?
+        options[:extended]   = extended   unless extended.nil?
+        options
+      else
+        { :multiline => multiline,
+          :ignorecase => ignorecase,
+          :extended => extended }
+      end
+    end
+
+    def to_i
+      flag = 0
+      flag |= Regexp::MULTILINE if multiline
+      flag |= Regexp::IGNORECASE if ignorecase
+      flag |= Regexp::EXTENDED if extended
+      flag
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb
new file mode 100644
index 0000000000..0bb9b87e9c
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/parser.rb
@@ -0,0 +1,415 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+module Regin
+  class Parser < Racc::Parser #:nodoc: all
+
+def self.parse_regexp(regexp)
+  options = Options.from_int(regexp.options)
+
+  parser = new
+  parser.options_stack << options.to_h
+
+  expression = parser.scan_str(regexp.source)
+  expression = expression.dup(options.to_h) if options.any?
+  expression
+end
+
+attr_accessor :options_stack
+
+def initialize
+  @capture_index = 0
+  @capture_index_stack = []
+  @options_stack = []
+end
+
+##### State transition tables begin ###
+
+racc_action_table = [
+     2,    18,    19,    19,     8,    10,    11,    13,    48,    19,
+     2,    45,     3,     5,     8,    10,    11,    13,    64,    47,
+     2,    55,     3,     5,     8,    10,    11,    13,    29,    19,
+     2,    16,     3,     5,     8,    10,    11,    13,    61,    19,
+     2,    63,     3,     5,     8,    10,    11,    13,    60,    36,
+     2,    34,     3,     5,     8,    10,    11,    13,    28,    49,
+     2,   nil,     3,     5,     8,    10,    11,    13,   nil,   nil,
+     2,   nil,     3,     5,     8,    10,    11,    13,   nil,    26,
+    42,    43,     3,     5,    37,    38,    40,    21,    44,    37,
+    38,    40,    22,    23,    24,    14,   nil,    15,    31,    32,
+    16,   nil,    33,    46,    32,   nil,   nil,    33,    51,    37,
+    38,    40,    58,    37,    38,    40,    37,    38,    40,    37,
+    38,    40,    37,    38,    40,    37,    38,    40,    37,    38,
+    40 ]
+
+racc_action_check = [
+     0,     4,    27,     4,     0,     0,     0,     0,    36,    56,
+    49,    27,     0,     0,    49,    49,    49,    49,    56,    36,
+    43,    48,    49,    49,    43,    43,    43,    43,    15,    53,
+     6,    15,    43,    43,     6,     6,     6,     6,    53,    52,
+    42,    55,     6,     6,    42,    42,    42,    42,    52,    24,
+    35,    18,    42,    42,    35,    35,    35,    35,    14,    39,
+    19,   nil,    35,    35,    19,    19,    19,    19,   nil,   nil,
+    13,   nil,    19,    19,    13,    13,    13,    13,   nil,    13,
+    26,    26,    13,    13,    54,    54,    54,     9,    26,    26,
+    26,    26,     9,     9,     9,     2,   nil,     2,    17,    17,
+     2,   nil,    17,    30,    30,   nil,   nil,    30,    41,    41,
+    41,    41,    50,    50,    50,    50,    44,    44,    44,    59,
+    59,    59,    58,    58,    58,    51,    51,    51,    62,    62,
+    62 ]
+
+racc_action_pointer = [
+    -3,   nil,    91,   nil,     1,   nil,    27,   nil,   nil,    75,
+   nil,   nil,   nil,    67,    53,    22,   nil,    93,    51,    57,
+   nil,   nil,   nil,   nil,    40,   nil,    67,     0,   nil,   nil,
+    98,   nil,   nil,   nil,   nil,    47,    -1,   nil,   nil,    46,
+   nil,    87,    37,    17,    94,   nil,   nil,   nil,    12,     7,
+    91,   103,    37,    27,    62,    21,     7,   nil,   100,    97,
+   nil,   nil,   106,   nil,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -37,   -13,   -37,   -19,   -37,   -20,    -2,    -4,   -11,    -6,
+   -12,   -14,    -7,   -37,   -37,   -29,   -28,   -37,   -37,   -37,
+    -3,   -23,   -21,   -22,   -37,    -5,   -37,   -37,    -8,   -29,
+   -37,    -9,   -27,   -26,    68,    -1,   -37,   -34,   -35,   -37,
+   -36,   -37,   -37,   -37,   -37,   -15,   -10,   -25,   -37,   -37,
+   -37,   -37,   -37,   -37,   -37,   -37,   -37,   -33,   -37,   -37,
+   -17,   -18,   -37,   -24,   -16,   -32,   -31,   -30 ]
+
+racc_goto_table = [
+     4,    41,    20,    35,    17,    39,    25,   nil,   nil,   nil,
+   nil,   nil,   nil,    27,   nil,   nil,    50,    30,   nil,    54,
+   nil,   nil,   nil,   nil,   nil,    57,    59,   nil,   nil,    62,
+   nil,    20,   nil,    65,    66,   nil,   nil,    67,   nil,   nil,
+   nil,   nil,    52,    53,   nil,   nil,   nil,   nil,   nil,    56 ]
+
+racc_goto_check = [
+     1,    10,     3,     2,     7,     9,     5,   nil,   nil,   nil,
+   nil,   nil,   nil,     1,   nil,   nil,    10,     7,   nil,    10,
+   nil,   nil,   nil,   nil,   nil,    10,    10,   nil,   nil,    10,
+   nil,     3,   nil,    10,    10,   nil,   nil,    10,   nil,   nil,
+   nil,   nil,     1,     1,   nil,   nil,   nil,   nil,   nil,     1 ]
+
+racc_goto_pointer = [
+   nil,     0,   -16,    -4,   nil,    -3,   nil,     2,   nil,   -21,
+   -25 ]
+
+racc_goto_default = [
+   nil,   nil,     6,     7,     9,   nil,    12,   nil,     1,   nil,
+   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 26, :_reduce_1,
+  1, 26, :_reduce_2,
+  2, 27, :_reduce_3,
+  1, 27, :_reduce_4,
+  2, 28, :_reduce_5,
+  1, 28, :_reduce_none,
+  1, 29, :_reduce_none,
+  3, 29, :_reduce_8,
+  3, 29, :_reduce_9,
+  4, 29, :_reduce_10,
+  1, 29, :_reduce_11,
+  1, 29, :_reduce_12,
+  1, 29, :_reduce_13,
+  1, 29, :_reduce_14,
+  3, 31, :_reduce_15,
+  6, 31, :_reduce_16,
+  5, 31, :_reduce_17,
+  5, 31, :_reduce_18,
+  1, 33, :_reduce_none,
+  1, 33, :_reduce_none,
+  1, 30, :_reduce_none,
+  1, 30, :_reduce_none,
+  1, 30, :_reduce_none,
+  5, 30, :_reduce_24,
+  3, 30, :_reduce_25,
+  2, 32, :_reduce_26,
+  2, 32, :_reduce_27,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  4, 34, :_reduce_30,
+  4, 34, :_reduce_31,
+  4, 34, :_reduce_32,
+  3, 34, :_reduce_33,
+  1, 35, :_reduce_34,
+  1, 35, :_reduce_35,
+  1, 35, :_reduce_36 ]
+
+racc_reduce_n = 37
+
+racc_shift_n = 68
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :BAR => 2,
+  :LBRACK => 3,
+  :CTYPE => 4,
+  :RBRACK => 5,
+  :NEGATE => 6,
+  :CCLASS => 7,
+  :DOT => 8,
+  :CHAR => 9,
+  :LPAREN => 10,
+  :RPAREN => 11,
+  :QMARK => 12,
+  :COLON => 13,
+  :NAME => 14,
+  :L_ANCHOR => 15,
+  :R_ANCHOR => 16,
+  :STAR => 17,
+  :PLUS => 18,
+  :LCURLY => 19,
+  :RCURLY => 20,
+  :MINUS => 21,
+  :MULTILINE => 22,
+  :IGNORECASE => 23,
+  :EXTENDED => 24 }
+
+racc_nt_base = 25
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "BAR",
+  "LBRACK",
+  "CTYPE",
+  "RBRACK",
+  "NEGATE",
+  "CCLASS",
+  "DOT",
+  "CHAR",
+  "LPAREN",
+  "RPAREN",
+  "QMARK",
+  "COLON",
+  "NAME",
+  "L_ANCHOR",
+  "R_ANCHOR",
+  "STAR",
+  "PLUS",
+  "LCURLY",
+  "RCURLY",
+  "MINUS",
+  "MULTILINE",
+  "IGNORECASE",
+  "EXTENDED",
+  "$start",
+  "expression",
+  "subexpression",
+  "quantified_atom",
+  "atom",
+  "quantifier",
+  "group",
+  "bracket_expression",
+  "anchor",
+  "options",
+  "modifier" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+                # TODO remove this conditional by breaking
+                # it into another production
+                if val[0][0].is_a?(Regin::Alternation)
+                  alt = val[0][0] + [Expression.new(val[2])]
+                else
+                  alt = Alternation.new(val[0], Expression.new(val[2]))
+                end
+                result = Expression.new(alt)
+
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = Expression.new(val[0])
+    result
+end
+
+def _reduce_3(val, _values, result)
+ result = val[0] + [val[1]]
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = [val[0]]
+    result
+end
+
+def _reduce_5(val, _values, result)
+ result = val[0].dup(:quantifier => val[1])
+    result
+end
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+def _reduce_8(val, _values, result)
+ result = CharacterClass.new(val[1])
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = CharacterClass.new(val[1])
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = CharacterClass.new(val[2], :negate => true)
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = CharacterClass.new(val[0])
+    result
+end
+
+def _reduce_12(val, _values, result)
+ result = CharacterClass.new('.')
+    result
+end
+
+def _reduce_13(val, _values, result)
+ result = Anchor.new(val[0])
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = Character.new(val[0])
+    result
+end
+
+def _reduce_15(val, _values, result)
+          result = Group.new(val[1], :index => @capture_index_stack.pop)
+
+    result
+end
+
+def _reduce_16(val, _values, result)
+          result = Group.new(val[4], val[2].merge(:capture => false))
+          @options_stack.pop
+
+    result
+end
+
+def _reduce_17(val, _values, result)
+          result = Group.new(val[3], :capture => false);
+
+    result
+end
+
+def _reduce_18(val, _values, result)
+          result = Group.new(val[3], :name => val[2], :index => @capture_index_stack.pop);
+
+    result
+end
+
+# reduce 19 omitted
+
+# reduce 20 omitted
+
+# reduce 21 omitted
+
+# reduce 22 omitted
+
+# reduce 23 omitted
+
+def _reduce_24(val, _values, result)
+ result = val.join
+    result
+end
+
+def _reduce_25(val, _values, result)
+ result = val.join
+    result
+end
+
+def _reduce_26(val, _values, result)
+ result = val.join
+    result
+end
+
+def _reduce_27(val, _values, result)
+ result = val.join
+    result
+end
+
+# reduce 28 omitted
+
+# reduce 29 omitted
+
+def _reduce_30(val, _values, result)
+            @options_stack << result = { val[1] => false, val[2] => false, val[3] => false }
+
+    result
+end
+
+def _reduce_31(val, _values, result)
+            @options_stack << result = { val[0] => true, val[2] => false, val[3] => false }
+
+    result
+end
+
+def _reduce_32(val, _values, result)
+            @options_stack << result = { val[0] => true, val[1] => true, val[3] => false }
+
+    result
+end
+
+def _reduce_33(val, _values, result)
+            @options_stack << result = { val[0] => true, val[1] => true, val[2] => true }
+
+    result
+end
+
+def _reduce_34(val, _values, result)
+ result = :multiline
+    result
+end
+
+def _reduce_35(val, _values, result)
+ result = :ignorecase
+    result
+end
+
+def _reduce_36(val, _values, result)
+ result = :extended
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+end   # module Regin
+
+require 'regin/tokenizer'
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb
new file mode 100644
index 0000000000..59e4ffb611
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/tokenizer.rb
@@ -0,0 +1,213 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5.beta1
+# from lexical definition file "lib/regin/tokenizer.rex".
+#++
+
+require 'racc/parser'
+class Regin::Parser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\\[dDsSwW]/))
+         action { [:CCLASS, text] }
+
+      when (text = @ss.scan(/\^|\\A/))
+         action { [:L_ANCHOR, text] }
+
+      when (text = @ss.scan(/\$|\\Z/))
+         action { [:R_ANCHOR, text] }
+
+      when (text = @ss.scan(/<(\w+)>/))
+         action { [:NAME, @ss[1]] }
+
+      when (text = @ss.scan(/\(/))
+         action {
+    @capture_index_stack << @capture_index
+    @capture_index += 1
+    @state = :OPTIONS if @ss.peek(1) == '?';
+    [:LPAREN, text]
+  }
+
+
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN,  text] }
+
+      when (text = @ss.scan(/\[/))
+         action { @state = :CCLASS; [:LBRACK,  text] }
+
+      when (text = @ss.scan(/\{/))
+         action { [:LCURLY,  text] }
+
+      when (text = @ss.scan(/\}/))
+         action { [:RCURLY,  text] }
+
+      when (text = @ss.scan(/\|/))
+         action { [:BAR, text]   }
+
+      when (text = @ss.scan(/\./))
+         action { [:DOT, text]   }
+
+      when (text = @ss.scan(/\?/))
+         action { [:QMARK, text] }
+
+      when (text = @ss.scan(/\+(?:\?)/))
+         action { [:PLUS,  text] }
+
+      when (text = @ss.scan(/\*(?:\?)/))
+         action { [:STAR,  text] }
+
+      when (text = @ss.scan(/\#/))
+         action {
+    if @options_stack[-1][:extended]
+      @state = :COMMENT;
+      next_token
+    else
+      [:CHAR, text]
+    end
+  }
+
+
+      when (text = @ss.scan(/\s|\n/))
+         action {
+    if @options_stack[-1][:extended]
+      next_token
+    else
+      [:CHAR, text]
+    end
+  }
+
+
+      when (text = @ss.scan(/\\(.)/))
+         action { [:CHAR, @ss[1]] }
+
+      when (text = @ss.scan(/./))
+         action { [:CHAR, text] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    when :CCLASS
+      case
+      when (text = @ss.scan(/\]/))
+         action { @state = nil; [:RBRACK, text] }
+
+      when (text = @ss.scan(/\^/))
+         action { [:NEGATE, text] }
+
+      when (text = @ss.scan(/:(alnum|alpha|ascii|blank|cntrl|digit|graph|lower|print|punct|space|upper|word|xdigit):/))
+         action { [:CTYPE, text] }
+
+      when (text = @ss.scan(/\\-/))
+         action { [:CHAR, text] }
+
+      when (text = @ss.scan(/\\(.)/))
+         action { [:CHAR, @ss[1]] }
+
+      when (text = @ss.scan(/./))
+         action { [:CHAR, text] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    when :OPTIONS
+      case
+      when (text = @ss.scan(/\?/))
+         action {
+    @state = nil unless @ss.peek(1) =~ /-|m|i|x|:/
+    [:QMARK, text]
+  }
+
+
+      when (text = @ss.scan(/\-/))
+         action { [:MINUS, text] }
+
+      when (text = @ss.scan(/m/))
+         action { [:MULTILINE, text] }
+
+      when (text = @ss.scan(/i/))
+         action { [:IGNORECASE, text] }
+
+      when (text = @ss.scan(/x/))
+         action { [:EXTENDED, text] }
+
+      when (text = @ss.scan(/\:/))
+         action {
+    @capture_index_stack.pop
+    @capture_index -= 1
+    @state = nil;
+    [:COLON, text]
+  }
+
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    when :COMMENT
+      case
+      when (text = @ss.scan(/\n/))
+         action { @state = nil; next_token }
+
+      when (text = @ss.scan(/./))
+         action { next_token }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
+
+end # class
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb
new file mode 100644
index 0000000000..7ad2a5a25e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/vendor/regin/regin/version.rb
@@ -0,0 +1,3 @@
+module Regin
+  Version = '0.3.3'
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb
new file mode 100644
index 0000000000..a3688b102e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-mount-0.6.6.pre/rack/mount/version.rb
@@ -0,0 +1,5 @@
+module Rack
+  module Mount
+    Version = '0.6.6.pre'
+  end
+end