halorgium-actionpack 3.0.pre

data/lib/action_dispatch/routing/mapper.rb

@@ -0,0 +1,327 @@
+module ActionDispatch
+  module Routing
+    class Mapper
+      module Resources
+        def resource(*resources, &block)
+          options = resources.last.is_a?(Hash) ? resources.pop : {}
+
+          if resources.length > 1
+            raise ArgumentError if block_given?
+            resources.each { |r| resource(r, options) }
+            return self
+          end
+
+          resource = resources.pop
+
+          if @scope[:scope_level] == :resources
+            member do
+              resource(resource, options, &block)
+            end
+            return self
+          end
+
+          singular = resource.to_s
+          plural   = singular.pluralize
+
+          controller(plural) do
+            namespace(resource) do
+              with_scope_level(:resource) do
+                yield if block_given?
+
+                get "", :to => :show, :as => "#{singular}"
+                post "", :to => :create
+                put "", :to => :update
+                delete "", :to => :destroy
+                get "new", :to => :new, :as => "new_#{singular}"
+                get "edit", :to => :edit, :as => "edit_#{singular}"
+              end
+            end
+          end
+
+          self
+        end
+
+        def resources(*resources, &block)
+          options = resources.last.is_a?(Hash) ? resources.pop : {}
+
+          if resources.length > 1
+            raise ArgumentError if block_given?
+            resources.each { |r| resources(r, options) }
+            return self
+          end
+
+          resource = resources.pop
+
+          if @scope[:scope_level] == :resources
+            member do
+              resources(resource, options, &block)
+            end
+            return self
+          end
+
+          plural   = resource.to_s
+          singular = plural.singularize
+
+          controller(resource) do
+            namespace(resource) do
+              with_scope_level(:resources) do
+                yield if block_given?
+
+                member do
+                  get "", :to => :show, :as => "#{singular}"
+                  put "", :to => :update
+                  delete "", :to => :destroy
+                  get "edit", :to => :edit, :as => "edit_#{singular}"
+                end
+
+                collection do
+                  get "", :to => :index, :as => "#{plural}"
+                  post "", :to => :create
+                  get "new", :to => :new, :as => "new_#{singular}"
+                end
+              end
+            end
+          end
+
+          self
+        end
+
+        def collection
+          unless @scope[:scope_level] == :resources
+            raise ArgumentError, "can't use collection outside resources scope"
+          end
+
+          with_scope_level(:collection) do
+            yield
+          end
+        end
+
+        def member
+          unless @scope[:scope_level] == :resources
+            raise ArgumentError, "can't use member outside resources scope"
+          end
+
+          with_scope_level(:member) do
+            scope(":id") do
+              yield
+            end
+          end
+        end
+
+        def match(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          args.push(options)
+
+          case options.delete(:on)
+          when :collection
+            return collection { match(*args) }
+          when :member
+            return member { match(*args) }
+          end
+
+          if @scope[:scope_level] == :resources
+            raise ArgumentError, "can't define route directly in resources scope"
+          end
+
+          super
+        end
+
+        private
+          def with_scope_level(kind)
+            old, @scope[:scope_level] = @scope[:scope_level], kind
+            yield
+          ensure
+            @scope[:scope_level] = old
+          end
+      end
+
+      module Scoping
+        def scope(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+
+          constraints = options.delete(:constraints) || {}
+          unless constraints.is_a?(Hash)
+            block, constraints = constraints, {}
+          end
+          constraints, @scope[:constraints] = @scope[:constraints], (@scope[:constraints] || {}).merge(constraints)
+          blocks, @scope[:blocks] = @scope[:blocks], (@scope[:blocks] || []) + [block]
+
+          options, @scope[:options] = @scope[:options], (@scope[:options] || {}).merge(options)
+
+          path_set = controller_set = false
+
+          case args.first
+          when String
+            path_set = true
+            path = args.first
+            path, @scope[:path] = @scope[:path], "#{@scope[:path]}#{Rack::Mount::Utils.normalize_path(path)}"
+          when Symbol
+            controller_set = true
+            controller = args.first
+            controller, @scope[:controller] = @scope[:controller], controller
+          end
+
+          yield
+
+          self
+        ensure
+          @scope[:path] = path if path_set
+          @scope[:controller] = controller if controller_set
+          @scope[:options] = options
+          @scope[:blocks] = blocks
+          @scope[:constraints] = constraints
+        end
+
+        def controller(controller)
+          scope(controller.to_sym) { yield }
+        end
+
+        def namespace(path)
+          scope(path.to_s) { yield }
+        end
+
+        def constraints(constraints = {})
+          scope(:constraints => constraints) { yield }
+        end
+      end
+
+      class Constraints
+        def initialize(app, constraints = [])
+          @app, @constraints = app, constraints
+        end
+
+        def call(env)
+          req = Rack::Request.new(env)
+
+          @constraints.each { |constraint|
+            if constraint.respond_to?(:matches?) && !constraint.matches?(req)
+              return Rack::Mount::Const::EXPECTATION_FAILED_RESPONSE
+            elsif constraint.respond_to?(:call) && !constraint.call(req)
+              return Rack::Mount::Const::EXPECTATION_FAILED_RESPONSE
+            end
+          }
+
+          @app.call(env)
+        end
+      end
+
+      def initialize(set)
+        @set = set
+        @scope = {}
+
+        extend Scoping
+        extend Resources
+      end
+
+      def get(*args, &block)
+        map_method(:get, *args, &block)
+      end
+
+      def post(*args, &block)
+        map_method(:post, *args, &block)
+      end
+
+      def put(*args, &block)
+        map_method(:put, *args, &block)
+      end
+
+      def delete(*args, &block)
+        map_method(:delete, *args, &block)
+      end
+
+      def root(options = {})
+        match '/', options.merge(:as => :root)
+      end
+
+      def match(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+
+        if args.length > 1
+          args.each { |path| match(path, options) }
+          return self
+        end
+
+        if args.first.is_a?(Symbol)
+          return match(args.first.to_s, options.merge(:to => args.first.to_sym))
+        end
+
+        path = args.first
+
+        options = (@scope[:options] || {}).merge(options)
+        conditions, defaults = {}, {}
+
+        path = nil if path == ""
+        path = Rack::Mount::Utils.normalize_path(path) if path
+        path = "#{@scope[:path]}#{path}" if @scope[:path]
+
+        raise ArgumentError, "path is required" unless path
+
+        constraints = options[:constraints] || {}
+        unless constraints.is_a?(Hash)
+          block, constraints = constraints, {}
+        end
+        blocks = ((@scope[:blocks] || []) + [block]).compact
+        constraints = (@scope[:constraints] || {}).merge(constraints)
+        options.each { |k, v| constraints[k] = v if v.is_a?(Regexp) }
+
+        conditions[:path_info] = path
+        requirements = constraints.dup
+
+        path_regexp = Rack::Mount::Strexp.compile(path, constraints, SEPARATORS)
+        segment_keys = Rack::Mount::RegexpWithNamedGroups.new(path_regexp).names
+        constraints.reject! { |k, v| segment_keys.include?(k.to_s) }
+        conditions.merge!(constraints)
+
+        if via = options[:via]
+          via = Array(via).map { |m| m.to_s.upcase }
+          conditions[:request_method] = Regexp.union(*via)
+        end
+
+        defaults[:controller] = @scope[:controller].to_s if @scope[:controller]
+
+        if options[:to].respond_to?(:call)
+          app = options[:to]
+          defaults.delete(:controller)
+          defaults.delete(:action)
+        elsif options[:to].is_a?(String)
+          defaults[:controller], defaults[:action] = options[:to].split('#')
+        elsif options[:to].is_a?(Symbol)
+          defaults[:action] = options[:to].to_s
+        end
+        app ||= Routing::RouteSet::Dispatcher.new(:defaults => defaults)
+
+        if app.is_a?(Routing::RouteSet::Dispatcher)
+          unless defaults.include?(:controller) || segment_keys.include?("controller")
+            raise ArgumentError, "missing :controller"
+          end
+          unless defaults.include?(:action) || segment_keys.include?("action")
+            raise ArgumentError, "missing :action"
+          end
+        end
+
+        app = Constraints.new(app, blocks) if blocks.any?
+        @set.add_route(app, conditions, requirements, defaults, options[:as])
+
+        self
+      end
+
+      def redirect(path, options = {})
+        status = options[:status] || 301
+        lambda { |env|
+          req = Rack::Request.new(env)
+          url = req.scheme + '://' + req.host + path
+          [status, {'Location' => url, 'Content-Type' => 'text/html'}, ['Moved Permanently']]
+        }
+      end
+
+      private
+        def map_method(method, *args, &block)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          options[:via] = method
+          args.push(options)
+          match(*args, &block)
+          self
+        end
+    end
+  end
+end

data/lib/action_dispatch/routing/route.rb

@@ -0,0 +1,49 @@
+module ActionDispatch
+  module Routing
+    class Route #:nodoc:
+      attr_reader :app, :conditions, :defaults, :name
+      attr_reader :path, :requirements
+
+      def initialize(app, conditions = {}, requirements = {}, defaults = {}, name = nil)
+        @app = app
+        @defaults = defaults
+        @name = name
+
+        @requirements = requirements.merge(defaults)
+        @requirements.delete(:controller) if @requirements[:controller].is_a?(Regexp)
+        @requirements.delete_if { |k, v|
+          v == Regexp.compile("[^#{SEPARATORS.join}]+")
+        }
+
+        if path = conditions[:path_info]
+          @path = path
+          conditions[:path_info] = ::Rack::Mount::Strexp.compile(path, requirements, SEPARATORS)
+        end
+
+        @conditions = conditions.inject({}) { |h, (k, v)|
+          h[k] = Rack::Mount::RegexpWithNamedGroups.new(v)
+          h
+        }
+      end
+
+      def verb
+        if method = conditions[:request_method]
+          case method
+          when Regexp
+            method.source.upcase
+          else
+            method.to_s.upcase
+          end
+        end
+      end
+
+      def segment_keys
+        @segment_keys ||= conditions[:path_info].names.compact.map { |key| key.to_sym }
+      end
+
+      def to_a
+        [@app, @conditions, @defaults, @name]
+      end
+    end
+  end
+end

data/lib/action_dispatch/routing/route_set.rb

@@ -0,0 +1,497 @@
+require 'rack/mount'
+require 'forwardable'
+
+module ActionDispatch
+  module Routing
+    class RouteSet #:nodoc:
+      NotFound = lambda { |env|
+        raise ActionController::RoutingError, "No route matches #{env[::Rack::Mount::Const::PATH_INFO].inspect} with #{env.inspect}"
+      }
+
+      PARAMETERS_KEY = 'action_dispatch.request.path_parameters'
+
+      class Dispatcher
+        def initialize(options = {})
+          defaults = options[:defaults]
+          @glob_param = options.delete(:glob)
+        end
+
+        def call(env)
+          params = env[PARAMETERS_KEY]
+          merge_default_action!(params)
+          split_glob_param!(params) if @glob_param
+          params.each do |key, value|
+            if value.is_a?(String)
+              value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
+              params[key] = URI.unescape(value)
+            end
+          end
+
+          if env['action_controller.recognize']
+            [200, {}, params]
+          else
+            controller = controller(params)
+            controller.action(params[:action]).call(env)
+          end
+        end
+
+        private
+          def controller(params)
+            if params && params.has_key?(:controller)
+              controller = "#{params[:controller].camelize}Controller"
+              ActiveSupport::Inflector.constantize(controller)
+            end
+          end
+
+          def merge_default_action!(params)
+            params[:action] ||= 'index'
+          end
+
+          def split_glob_param!(params)
+            params[@glob_param] = params[@glob_param].split('/').map { |v| URI.unescape(v) }
+          end
+      end
+
+
+      # A NamedRouteCollection instance is a collection of named routes, and also
+      # maintains an anonymous module that can be used to install helpers for the
+      # named routes.
+      class NamedRouteCollection #:nodoc:
+        include Enumerable
+        attr_reader :routes, :helpers
+
+        def initialize
+          clear!
+        end
+
+        def clear!
+          @routes = {}
+          @helpers = []
+
+          @module ||= Module.new
+          @module.instance_methods.each do |selector|
+            @module.class_eval { remove_method selector }
+          end
+        end
+
+        def add(name, route)
+          routes[name.to_sym] = route
+          define_named_route_methods(name, route)
+        end
+
+        def get(name)
+          routes[name.to_sym]
+        end
+
+        alias []=   add
+        alias []    get
+        alias clear clear!
+
+        def each
+          routes.each { |name, route| yield name, route }
+          self
+        end
+
+        def names
+          routes.keys
+        end
+
+        def length
+          routes.length
+        end
+
+        def reset!
+          old_routes = routes.dup
+          clear!
+          old_routes.each do |name, route|
+            add(name, route)
+          end
+        end
+
+        def install(destinations = [ActionController::Base, ActionView::Base], regenerate = false)
+          reset! if regenerate
+          Array(destinations).each do |dest|
+            dest.__send__(:include, @module)
+          end
+        end
+
+        private
+          def url_helper_name(name, kind = :url)
+            :"#{name}_#{kind}"
+          end
+
+          def hash_access_name(name, kind = :url)
+            :"hash_for_#{name}_#{kind}"
+          end
+
+          def define_named_route_methods(name, route)
+            {:url => {:only_path => false}, :path => {:only_path => true}}.each do |kind, opts|
+              hash = route.defaults.merge(:use_route => name).merge(opts)
+              define_hash_access route, name, kind, hash
+              define_url_helper route, name, kind, hash
+            end
+          end
+
+          def named_helper_module_eval(code, *args)
+            @module.module_eval(code, *args)
+          end
+
+          def define_hash_access(route, name, kind, options)
+            selector = hash_access_name(name, kind)
+            named_helper_module_eval <<-end_eval # We use module_eval to avoid leaks
+              def #{selector}(options = nil)                                      # def hash_for_users_url(options = nil)
+                options ? #{options.inspect}.merge(options) : #{options.inspect}  #   options ? {:only_path=>false}.merge(options) : {:only_path=>false}
+              end                                                                 # end
+              protected :#{selector}                                              # protected :hash_for_users_url
+            end_eval
+            helpers << selector
+          end
+
+          def define_url_helper(route, name, kind, options)
+            selector = url_helper_name(name, kind)
+            # The segment keys used for positional parameters
+
+            hash_access_method = hash_access_name(name, kind)
+
+            # allow ordered parameters to be associated with corresponding
+            # dynamic segments, so you can do
+            #
+            #   foo_url(bar, baz, bang)
+            #
+            # instead of
+            #
+            #   foo_url(:bar => bar, :baz => baz, :bang => bang)
+            #
+            # Also allow options hash, so you can do
+            #
+            #   foo_url(bar, baz, bang, :sort_by => 'baz')
+            #
+            named_helper_module_eval <<-end_eval # We use module_eval to avoid leaks
+              def #{selector}(*args)                                                        # def users_url(*args)
+                                                                                            #
+                opts = if args.empty? || Hash === args.first                                #   opts = if args.empty? || Hash === args.first
+                  args.first || {}                                                          #     args.first || {}
+                else                                                                        #   else
+                  options = args.extract_options!                                           #     options = args.extract_options!
+                  args = args.zip(#{route.segment_keys.inspect}).inject({}) do |h, (v, k)|  #     args = args.zip([]).inject({}) do |h, (v, k)|
+                    h[k] = v                                                                #       h[k] = v
+                    h                                                                       #       h
+                  end                                                                       #     end
+                  options.merge(args)                                                       #     options.merge(args)
+                end                                                                         #   end
+                                                                                            #
+                url_for(#{hash_access_method}(opts))                                        #   url_for(hash_for_users_url(opts))
+                                                                                            #
+              end                                                                           # end
+              #Add an alias to support the now deprecated formatted_* URL.                  # #Add an alias to support the now deprecated formatted_* URL.
+              def formatted_#{selector}(*args)                                              # def formatted_users_url(*args)
+                ActiveSupport::Deprecation.warn(                                            #   ActiveSupport::Deprecation.warn(
+                  "formatted_#{selector}() has been deprecated. " +                         #     "formatted_users_url() has been deprecated. " +
+                  "Please pass format to the standard " +                                   #     "Please pass format to the standard " +
+                  "#{selector} method instead.", caller)                                    #     "users_url method instead.", caller)
+                #{selector}(*args)                                                          #   users_url(*args)
+              end                                                                           # end
+              protected :#{selector}                                                        # protected :users_url
+            end_eval
+            helpers << selector
+          end
+      end
+
+      attr_accessor :routes, :named_routes, :configuration_files
+
+      def initialize
+        self.configuration_files = []
+
+        self.routes = []
+        self.named_routes = NamedRouteCollection.new
+
+        clear!
+      end
+
+      def draw(&block)
+        clear!
+        Mapper.new(self).instance_exec(DeprecatedMapper.new(self), &block)
+        @set.add_route(NotFound)
+        install_helpers
+        @set.freeze
+      end
+
+      def clear!
+        routes.clear
+        named_routes.clear
+        @set = ::Rack::Mount::RouteSet.new(:parameters_key => PARAMETERS_KEY)
+      end
+
+      def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)
+        Array(destinations).each { |d| d.module_eval { include Helpers } }
+        named_routes.install(destinations, regenerate_code)
+      end
+
+      def empty?
+        routes.empty?
+      end
+
+      def add_configuration_file(path)
+        self.configuration_files << path
+      end
+
+      # Deprecated accessor
+      def configuration_file=(path)
+        add_configuration_file(path)
+      end
+
+      # Deprecated accessor
+      def configuration_file
+        configuration_files
+      end
+
+      def load!
+        Routing.use_controllers!(nil) # Clear the controller cache so we may discover new ones
+        load_routes!
+      end
+
+      # reload! will always force a reload whereas load checks the timestamp first
+      alias reload! load!
+
+      def reload
+        if configuration_files.any? && @routes_last_modified
+          if routes_changed_at == @routes_last_modified
+            return # routes didn't change, don't reload
+          else
+            @routes_last_modified = routes_changed_at
+          end
+        end
+
+        load!
+      end
+
+      def load_routes!
+        if configuration_files.any?
+          configuration_files.each { |config| load(config) }
+          @routes_last_modified = routes_changed_at
+        else
+          draw do |map|
+            map.connect ":controller/:action/:id"
+          end
+        end
+      end
+
+      def routes_changed_at
+        routes_changed_at = nil
+
+        configuration_files.each do |config|
+          config_changed_at = File.stat(config).mtime
+
+          if routes_changed_at.nil? || config_changed_at > routes_changed_at
+            routes_changed_at = config_changed_at
+          end
+        end
+
+        routes_changed_at
+      end
+
+      def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil)
+        route = Route.new(app, conditions, requirements, defaults, name)
+        @set.add_route(*route)
+        named_routes[name] = route if name
+        routes << route
+        route
+      end
+
+      def options_as_params(options)
+        # If an explicit :controller was given, always make :action explicit
+        # too, so that action expiry works as expected for things like
+        #
+        #   generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
+        #
+        # (the above is from the unit tests). In the above case, because the
+        # controller was explicitly given, but no action, the action is implied to
+        # be "index", not the recalled action of "show".
+        #
+        # great fun, eh?
+
+        options_as_params = options.clone
+        options_as_params[:action] ||= 'index' if options[:controller]
+        options_as_params[:action] = options_as_params[:action].to_s if options_as_params[:action]
+        options_as_params
+      end
+
+      def build_expiry(options, recall)
+        recall.inject({}) do |expiry, (key, recalled_value)|
+          expiry[key] = (options.key?(key) && options[key].to_param != recalled_value.to_param)
+          expiry
+        end
+      end
+
+      # Generate the path indicated by the arguments, and return an array of
+      # the keys that were not used to generate it.
+      def extra_keys(options, recall={})
+        generate_extras(options, recall).last
+      end
+
+      def generate_extras(options, recall={})
+        generate(options, recall, :generate_extras)
+      end
+
+      def generate(options, recall = {}, method = :generate)
+        options, recall = options.dup, recall.dup
+        named_route = options.delete(:use_route)
+
+        options = options_as_params(options)
+        expire_on = build_expiry(options, recall)
+
+        recall[:action] ||= 'index' if options[:controller] || recall[:controller]
+
+        if recall[:controller] && (!options.has_key?(:controller) || options[:controller] == recall[:controller])
+          options[:controller] = recall.delete(:controller)
+
+          if recall[:action] && (!options.has_key?(:action) || options[:action] == recall[:action])
+            options[:action] = recall.delete(:action)
+
+            if recall[:id] && (!options.has_key?(:id) || options[:id] == recall[:id])
+              options[:id] = recall.delete(:id)
+            end
+          end
+        end
+
+        options[:controller] = options[:controller].to_s if options[:controller]
+
+        if !named_route && expire_on[:controller] && options[:controller] && options[:controller][0] != ?/
+          old_parts = recall[:controller].split('/')
+          new_parts = options[:controller].split('/')
+          parts = old_parts[0..-(new_parts.length + 1)] + new_parts
+          options[:controller] = parts.join('/')
+        end
+
+        options[:controller] = options[:controller][1..-1] if options[:controller] && options[:controller][0] == ?/
+
+        merged = options.merge(recall)
+        if options.has_key?(:action) && options[:action].nil?
+          options.delete(:action)
+          recall[:action] = 'index'
+        end
+        recall[:action] = options.delete(:action) if options[:action] == 'index'
+
+        path = _uri(named_route, options, recall)
+        if path && method == :generate_extras
+          uri = URI(path)
+          extras = uri.query ?
+            Rack::Utils.parse_nested_query(uri.query).keys.map { |k| k.to_sym } :
+            []
+          [uri.path, extras]
+        elsif path
+          path
+        else
+          raise ActionController::RoutingError, "No route matches #{options.inspect}"
+        end
+      rescue Rack::Mount::RoutingError
+        raise ActionController::RoutingError, "No route matches #{options.inspect}"
+      end
+
+      def call(env)
+        @set.call(env)
+      rescue ActionController::RoutingError => e
+        raise e if env['action_controller.rescue_error'] == false
+
+        method, path = env['REQUEST_METHOD'].downcase.to_sym, env['PATH_INFO']
+
+        # Route was not recognized. Try to find out why (maybe wrong verb).
+        allows = HTTP_METHODS.select { |verb|
+          begin
+            recognize_path(path, {:method => verb}, false)
+          rescue ActionController::RoutingError
+            nil
+          end
+        }
+
+        if !HTTP_METHODS.include?(method)
+          raise ActionController::NotImplemented.new(*allows)
+        elsif !allows.empty?
+          raise ActionController::MethodNotAllowed.new(*allows)
+        else
+          raise e
+        end
+      end
+
+      def recognize(request)
+        params = recognize_path(request.path, extract_request_environment(request))
+        request.path_parameters = params.with_indifferent_access
+        "#{params[:controller].to_s.camelize}Controller".constantize
+      end
+
+      def recognize_path(path, environment = {}, rescue_error = true)
+        method = (environment[:method] || "GET").to_s.upcase
+
+        begin
+          env = Rack::MockRequest.env_for(path, {:method => method})
+        rescue URI::InvalidURIError => e
+          raise ActionController::RoutingError, e.message
+        end
+
+        env['action_controller.recognize'] = true
+        env['action_controller.rescue_error'] = rescue_error
+        status, headers, body = call(env)
+        body
+      end
+
+      # Subclasses and plugins may override this method to extract further attributes
+      # from the request, for use by route conditions and such.
+      def extract_request_environment(request)
+        { :method => request.method }
+      end
+
+      private
+        def _uri(named_route, params, recall)
+          params = URISegment.wrap_values(params)
+          recall = URISegment.wrap_values(recall)
+
+          unless result = @set.generate(:path_info, named_route, params, recall)
+            return
+          end
+
+          uri, params = result
+          params.each do |k, v|
+            if v._value
+              params[k] = v._value
+            else
+              params.delete(k)
+            end
+          end
+
+          uri << "?#{Rack::Mount::Utils.build_nested_query(params)}" if uri && params.any?
+          uri
+        end
+
+        class URISegment < Struct.new(:_value, :_escape)
+          EXCLUDED = [:controller]
+
+          def self.wrap_values(hash)
+            hash.inject({}) { |h, (k, v)|
+              h[k] = new(v, !EXCLUDED.include?(k.to_sym))
+              h
+            }
+          end
+
+          extend Forwardable
+          def_delegators :_value, :==, :eql?, :hash
+
+          def to_param
+            @to_param ||= begin
+              if _value.is_a?(Array)
+                _value.map { |v| _escaped(v) }.join('/')
+              else
+                _escaped(_value)
+              end
+            end
+          end
+          alias_method :to_s, :to_param
+
+          private
+            def _escaped(value)
+              v = value.respond_to?(:to_param) ? value.to_param : value
+              _escape ? Rack::Mount::Utils.escape_uri(v) : v.to_s
+            end
+        end
+    end
+  end
+end