actionpack 4.1.7 → 4.2.11

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -101,118 +101,230 @@ module ActionDispatch
       #   polymorphic_url(Comment) # same as comments_url()
       #
       def polymorphic_url(record_or_hash_or_array, options = {})
-        if record_or_hash_or_array.kind_of?(Array)
-          record_or_hash_or_array = record_or_hash_or_array.compact
-          if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
-            proxy = record_or_hash_or_array.shift
-          end
-          record_or_hash_or_array = record_or_hash_or_array[0] if record_or_hash_or_array.size == 1
-        end
-
-        record = extract_record(record_or_hash_or_array)
-        record = convert_to_model(record)
-
-        args = Array === record_or_hash_or_array ?
-          record_or_hash_or_array.dup :
-          [ record_or_hash_or_array ]
-
-        inflection = if options[:action] && options[:action].to_s == "new"
-          args.pop
-          :singular
-        elsif (record.respond_to?(:persisted?) && !record.persisted?)
-          args.pop
-          :plural
-        elsif record.is_a?(Class)
-          args.pop
-          :plural
-        else
-          :singular
+        if Hash === record_or_hash_or_array
+          options = record_or_hash_or_array.merge(options)
+          record  = options.delete :id
+          return polymorphic_url record, options
         end
 
-        args.delete_if {|arg| arg.is_a?(Symbol) || arg.is_a?(String)}
-        named_route = build_named_route_call(record_or_hash_or_array, inflection, options)
+        opts   = options.dup
+        action = opts.delete :action
+        type   = opts.delete(:routing_type) || :url
 
-        url_options = options.except(:action, :routing_type)
-        unless url_options.empty?
-          args.last.kind_of?(Hash) ? args.last.merge!(url_options) : args << url_options
-        end
-
-        args.collect! { |a| convert_to_model(a) }
-
-        (proxy || self).send(named_route, *args)
+        HelperMethodBuilder.polymorphic_method self,
+                                               record_or_hash_or_array,
+                                               action,
+                                               type,
+                                               opts
       end
 
       # Returns the path component of a URL for the given record. It uses
       # <tt>polymorphic_url</tt> with <tt>routing_type: :path</tt>.
       def polymorphic_path(record_or_hash_or_array, options = {})
-        polymorphic_url(record_or_hash_or_array, options.merge(:routing_type => :path))
+        if Hash === record_or_hash_or_array
+          options = record_or_hash_or_array.merge(options)
+          record  = options.delete :id
+          return polymorphic_path record, options
+        end
+
+        opts   = options.dup
+        action = opts.delete :action
+        type   = :path
+
+        HelperMethodBuilder.polymorphic_method self,
+                                               record_or_hash_or_array,
+                                               action,
+                                               type,
+                                               opts
       end
 
+
       %w(edit new).each do |action|
         module_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{action}_polymorphic_url(record_or_hash, options = {})         # def edit_polymorphic_url(record_or_hash, options = {})
-            polymorphic_url(                                                  #   polymorphic_url(
-              record_or_hash,                                                 #     record_or_hash,
-              options.merge(:action => "#{action}"))                          #     options.merge(:action => "edit"))
-          end                                                                 # end
-                                                                              #
-          def #{action}_polymorphic_path(record_or_hash, options = {})        # def edit_polymorphic_path(record_or_hash, options = {})
-            polymorphic_url(                                                  #   polymorphic_url(
-              record_or_hash,                                                 #     record_or_hash,
-              options.merge(:action => "#{action}", :routing_type => :path))  #     options.merge(:action => "edit", :routing_type => :path))
-          end                                                                 # end
+          def #{action}_polymorphic_url(record_or_hash, options = {})
+            polymorphic_url_for_action("#{action}", record_or_hash, options)
+          end
+
+          def #{action}_polymorphic_path(record_or_hash, options = {})
+            polymorphic_path_for_action("#{action}", record_or_hash, options)
+          end
         EOT
       end
 
       private
-        def action_prefix(options)
-          options[:action] ? "#{options[:action]}_" : ''
+
+      def polymorphic_url_for_action(action, record_or_hash, options)
+        polymorphic_url(record_or_hash, options.merge(:action => action))
+      end
+
+      def polymorphic_path_for_action(action, record_or_hash, options)
+        polymorphic_path(record_or_hash, options.merge(:action => action))
+      end
+
+      class HelperMethodBuilder # :nodoc:
+        CACHE = { 'path' => {}, 'url' => {} }
+
+        def self.get(action, type)
+          type   = type.to_s
+          CACHE[type].fetch(action) { build action, type }
+        end
+
+        def self.url;  CACHE['url'.freeze][nil]; end
+        def self.path; CACHE['path'.freeze][nil]; end
+
+        def self.build(action, type)
+          prefix = action ? "#{action}_" : ""
+          suffix = type
+          if action.to_s == 'new'
+            HelperMethodBuilder.singular prefix, suffix
+          else
+            HelperMethodBuilder.plural prefix, suffix
+          end
+        end
+
+        def self.singular(prefix, suffix)
+          new(->(name) { name.singular_route_key }, prefix, suffix)
         end
 
-        def routing_type(options)
-          options[:routing_type] || :url
+        def self.plural(prefix, suffix)
+          new(->(name) { name.route_key }, prefix, suffix)
         end
 
-        def build_named_route_call(records, inflection, options = {})
-          if records.is_a?(Array)
-            record = records.pop
-            route = records.map do |parent|
-              if parent.is_a?(Symbol) || parent.is_a?(String)
-                parent
-              else
-                model_name_from_record_or_class(parent).singular_route_key
-              end
+        def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options)
+          builder = get action, type
+
+          case record_or_hash_or_array
+          when Array
+            record_or_hash_or_array = record_or_hash_or_array.compact
+            if record_or_hash_or_array.empty?
+              raise ArgumentError, "Nil location provided. Can't build URI."
             end
+            if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
+              recipient = record_or_hash_or_array.shift
+            end
+
+            method, args = builder.handle_list record_or_hash_or_array
+          when String, Symbol
+            method, args = builder.handle_string record_or_hash_or_array
+          when Class
+            method, args = builder.handle_class record_or_hash_or_array
+
+          when nil
+            raise ArgumentError, "Nil location provided. Can't build URI."
+          else
+            method, args = builder.handle_model record_or_hash_or_array
+          end
+
+
+          if options.empty?
+            recipient.send(method, *args)
           else
-            record = extract_record(records)
-            route  = []
+            recipient.send(method, *args, options)
           end
+        end
+
+        attr_reader :suffix, :prefix
+
+        def initialize(key_strategy, prefix, suffix)
+          @key_strategy = key_strategy
+          @prefix       = prefix
+          @suffix       = suffix
+        end
+
+        def handle_string(record)
+          [get_method_for_string(record), []]
+        end
+
+        def handle_string_call(target, str)
+          target.send get_method_for_string str
+        end
+
+        def handle_class(klass)
+          [get_method_for_class(klass), []]
+        end
+
+        def handle_class_call(target, klass)
+          target.send get_method_for_class klass
+        end
+
+        def handle_model(record)
+          args  = []
+
+          model = record.to_model
+          name = if model.persisted?
+                   args << model
+                   model.model_name.singular_route_key
+                 else
+                   @key_strategy.call model.model_name
+                 end
+
+          named_route = prefix + "#{name}_#{suffix}"
+
+          [named_route, args]
+        end
+
+        def handle_model_call(target, model)
+          method, args = handle_model model
+          target.send(method, *args)
+        end
+
+        def handle_list(list)
+          record_list = list.dup
+          record      = record_list.pop
+
+          args = []
 
-          if record.is_a?(Symbol) || record.is_a?(String)
-            route << record
-          elsif record
-            if inflection == :singular
-              route << model_name_from_record_or_class(record).singular_route_key
+          route  = record_list.map { |parent|
+            case parent
+            when Symbol, String
+              parent.to_s
+            when Class
+              args << parent
+              parent.model_name.singular_route_key
             else
-              route << model_name_from_record_or_class(record).route_key
+              args << parent.to_model
+              parent.to_model.model_name.singular_route_key
             end
+          }
+
+          route <<
+          case record
+          when Symbol, String
+            record.to_s
+          when Class
+            @key_strategy.call record.model_name
           else
-            raise ArgumentError, "Nil location provided. Can't build URI."
+            model = record.to_model
+            if model.persisted?
+              args << model
+              model.model_name.singular_route_key
+            else
+              @key_strategy.call model.model_name
+            end
           end
 
-          route << routing_type(options)
+          route << suffix
 
-          action_prefix(options) + route.join("_")
+          named_route = prefix + route.join("_")
+          [named_route, args]
         end
 
-        def extract_record(record_or_hash_or_array)
-          case record_or_hash_or_array
-            when Array; record_or_hash_or_array.last
-            when Hash;  record_or_hash_or_array[:id]
-            else        record_or_hash_or_array
-          end
+        private
+
+        def get_method_for_class(klass)
+          name   = @key_strategy.call klass.model_name
+          prefix + "#{name}_#{suffix}"
+        end
+
+        def get_method_for_string(str)
+          prefix + "#{str}_#{suffix}"
         end
+
+        [nil, 'new', 'edit'].each do |action|
+          CACHE['url'][action]  = build action, 'url'
+          CACHE['path'][action] = build action, 'path'
+        end
+      end
     end
   end
 end
-

data/lib/action_dispatch/routing/redirection.rb

@@ -3,10 +3,11 @@ require 'active_support/core_ext/uri'
 require 'active_support/core_ext/array/extract_options'
 require 'rack/utils'
 require 'action_controller/metal/exceptions'
+require 'action_dispatch/routing/endpoint'
 
 module ActionDispatch
   module Routing
-    class Redirect # :nodoc:
+    class Redirect < Endpoint # :nodoc:
       attr_reader :status, :block
 
       def initialize(status, block)
@@ -14,18 +15,15 @@ module ActionDispatch
         @block  = block
       end
 
-      def call(env)
-        req = Request.new(env)
+      def redirect?; true; end
 
-        # If any of the path parameters has an invalid encoding then
-        # raise since it's likely to trigger errors further on.
-        req.symbolized_path_parameters.each do |key, value|
-          unless value.valid_encoding?
-            raise ActionController::BadRequest, "Invalid parameter: #{key} => #{value}"
-          end
-        end
+      def call(env)
+        serve Request.new env
+      end
 
-        uri = URI.parse(path(req.symbolized_path_parameters, req))
+      def serve(req)
+        req.check_path_parameters!
+        uri = URI.parse(path(req.path_parameters, req))
         
         unless uri.host
           if relative_path?(uri.path)
@@ -39,7 +37,7 @@ module ActionDispatch
         uri.host   ||= req.host
         uri.port   ||= req.port unless req.standard_port?
 
-        body = %(<html><body>You are being <a href="#{ERB::Util.h(uri.to_s)}">redirected</a>.</body></html>)
+        body = %(<html><body>You are being <a href="#{ERB::Util.unwrapped_html_escape(uri.to_s)}">redirected</a>.</body></html>)
 
         headers = {
           'Location' => uri.to_s,

data/lib/action_dispatch/routing/route_set.rb

@@ -1,44 +1,37 @@
 require 'action_dispatch/journey'
 require 'forwardable'
-require 'thread_safe'
 require 'active_support/concern'
 require 'active_support/core_ext/object/to_query'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/module/remove_method'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/string/filters'
 require 'action_controller/metal/exceptions'
 require 'action_dispatch/http/request'
+require 'action_dispatch/routing/endpoint'
 
 module ActionDispatch
   module Routing
-    class RouteSet #:nodoc:
+    # :stopdoc:
+    class RouteSet
       # Since the router holds references to many parts of the system
       # like engines, controllers and the application itself, inspecting
       # the route set can actually be really slow, therefore we default
       # alias inspect to to_s.
       alias inspect to_s
 
-      PARAMETERS_KEY = 'action_dispatch.request.path_parameters'
+      mattr_accessor :relative_url_root
 
-      class Dispatcher #:nodoc:
-        def initialize(options={})
-          @defaults = options[:defaults]
-          @glob_param = options.delete(:glob)
-          @controller_class_names = ThreadSafe::Cache.new
+      class Dispatcher < Routing::Endpoint
+        def initialize(defaults)
+          @defaults = defaults
         end
 
-        def call(env)
-          params = env[PARAMETERS_KEY]
+        def dispatcher?; true; end
 
-          # If any of the path parameters has an invalid encoding then
-          # raise since it's likely to trigger errors further on.
-          params.each do |key, value|
-            next unless value.respond_to?(:valid_encoding?)
-
-            unless value.valid_encoding?
-              raise ActionController::BadRequest, "Invalid parameter: #{key} => #{value}"
-            end
-          end
+        def serve(req)
+          req.check_path_parameters!
+          params = req.path_parameters
 
           prepare_params!(params)
 
@@ -47,13 +40,12 @@ module ActionDispatch
             return [404, {'X-Cascade' => 'pass'}, []]
           end
 
-          dispatch(controller, params[:action], env)
+          dispatch(controller, params[:action], req.env)
         end
 
         def prepare_params!(params)
           normalize_controller!(params)
           merge_default_action!(params)
-          split_glob_param!(params) if @glob_param
         end
 
         # If this is a default_controller (i.e. a controller specified by the user)
@@ -74,7 +66,7 @@ module ActionDispatch
       private
 
         def controller_reference(controller_param)
-          const_name = @controller_class_names[controller_param] ||= "#{controller_param.camelize}Controller"
+          const_name = "#{controller_param.camelize}Controller"
           ActiveSupport::Dependencies.constantize(const_name)
         end
 
@@ -89,47 +81,79 @@ module ActionDispatch
         def merge_default_action!(params)
           params[:action] ||= 'index'
         end
-
-        def split_glob_param!(params)
-          params[@glob_param] = params[@glob_param].split('/').map { |v| URI.parser.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:
+      class NamedRouteCollection
         include Enumerable
-        attr_reader :routes, :helpers, :module
+        attr_reader :routes, :url_helpers_module
 
         def initialize
           @routes  = {}
-          @helpers = []
-          @module  = Module.new
+          @path_helpers = Set.new
+          @url_helpers = Set.new
+          @url_helpers_module  = Module.new
+          @path_helpers_module = Module.new
+        end
+
+        def route_defined?(name)
+          key = name.to_sym
+          @path_helpers.include?(key) || @url_helpers.include?(key)
+        end
+
+        def helpers
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            `named_routes.helpers` is deprecated, please use `route_defined?(route_name)`
+            to see if a named route was defined.
+          MSG
+          @path_helpers + @url_helpers
         end
 
         def helper_names
-          @helpers.map(&:to_s)
+          @path_helpers.map(&:to_s) + @url_helpers.map(&:to_s)
         end
 
         def clear!
-          @helpers.each do |helper|
-            @module.remove_possible_method helper
+          @path_helpers.each do |helper|
+            @path_helpers_module.send :undef_method, helper
+          end
+
+          @url_helpers.each do |helper|
+            @url_helpers_module.send  :undef_method, helper
           end
 
           @routes.clear
-          @helpers.clear
+          @path_helpers.clear
+          @url_helpers.clear
         end
 
         def add(name, route)
-          routes[name.to_sym] = route
-          define_named_route_methods(name, route)
+          key       = name.to_sym
+          path_name = :"#{name}_path"
+          url_name  = :"#{name}_url"
+
+          if routes.key? key
+            @path_helpers_module.send :undef_method, path_name
+            @url_helpers_module.send  :undef_method, url_name
+          end
+          routes[key] = route
+          define_url_helper @path_helpers_module, route, path_name, route.defaults, name, LEGACY
+          define_url_helper @url_helpers_module,  route, url_name,  route.defaults, name, UNKNOWN
+
+          @path_helpers << path_name
+          @url_helpers << url_name
         end
 
         def get(name)
           routes[name.to_sym]
         end
 
+        def key?(name)
+          routes.key? name.to_sym
+        end
+
         alias []=   add
         alias []    get
         alias clear clear!
@@ -147,36 +171,54 @@ module ActionDispatch
           routes.length
         end
 
-        class UrlHelper # :nodoc:
-          def self.create(route, options)
+        def path_helpers_module(warn = false)
+          if warn
+            mod = @path_helpers_module
+            helpers = @path_helpers
+            Module.new do
+              include mod
+
+              helpers.each do |meth|
+                define_method(meth) do |*args, &block|
+                  ActiveSupport::Deprecation.warn("The method `#{meth}` cannot be used here as a full URL is required. Use `#{meth.to_s.sub(/_path$/, '_url')}` instead")
+                  super(*args, &block)
+                end
+              end
+            end
+          else
+            @path_helpers_module
+          end
+        end
+
+        class UrlHelper
+          def self.create(route, options, route_name, url_strategy)
             if optimize_helper?(route)
-              OptimizedUrlHelper.new(route, options)
+              OptimizedUrlHelper.new(route, options, route_name, url_strategy)
             else
-              new route, options
+              new route, options, route_name, url_strategy
             end
           end
 
           def self.optimize_helper?(route)
-            !route.glob? && route.requirements.except(:controller, :action).empty?
+            !route.glob? && route.path.requirements.empty?
           end
 
-          class OptimizedUrlHelper < UrlHelper # :nodoc:
+          attr_reader :url_strategy, :route_name
+
+          class OptimizedUrlHelper < UrlHelper
             attr_reader :arg_size
 
-            def initialize(route, options)
+            def initialize(route, options, route_name, url_strategy)
               super
-              @klass          = Journey::Router::Utils
               @required_parts = @route.required_parts
               @arg_size       = @required_parts.size
-              @optimized_path = @route.optimized_path
             end
 
-            def call(t, args)
-              if args.size == arg_size && !args.last.is_a?(Hash) && optimize_routes_generation?(t)
-                options = @options.dup
-                options.merge!(t.url_options) if t.respond_to?(:url_options)
+            def call(t, args, inner_options)
+              if args.size == arg_size && !inner_options && optimize_routes_generation?(t)
+                options = t.url_options.merge @options
                 options[:path] = optimized_helper(args)
-                ActionDispatch::Http::URL.url_for(options)
+                url_strategy.call options
               else
                 super
               end
@@ -185,18 +227,14 @@ module ActionDispatch
             private
 
             def optimized_helper(args)
-              params = Hash[parameterize_args(args)]
+              params = parameterize_args(args)
               missing_keys = missing_keys(params)
 
               unless missing_keys.empty?
                 raise_generation_error(params, missing_keys)
               end
 
-              @optimized_path.map{ |segment| replace_segment(params, segment) }.join
-            end
-
-            def replace_segment(params, segment)
-              Symbol === segment ? @klass.escape_segment(params[segment]) : segment
+              @route.format params
             end
 
             def optimize_routes_generation?(t)
@@ -204,7 +242,9 @@ module ActionDispatch
             end
 
             def parameterize_args(args)
-              @required_parts.zip(args.map(&:to_param))
+              params = {}
+              @required_parts.zip(args.map(&:to_param)) { |k,v| params[k] = v }
+              params
             end
 
             def missing_keys(args)
@@ -212,7 +252,7 @@ module ActionDispatch
             end
 
             def raise_generation_error(args, missing_keys)
-              constraints = Hash[@route.requirements.merge(args).sort]
+              constraints = Hash[@route.requirements.merge(args).sort_by{|k,v| k.to_s}]
               message = "No route matches #{constraints.inspect}"
               message << " missing required keys: #{missing_keys.sort.inspect}"
 
@@ -220,31 +260,66 @@ module ActionDispatch
             end
           end
 
-          def initialize(route, options)
+          def initialize(route, options, route_name, url_strategy)
             @options      = options
             @segment_keys = route.segment_keys.uniq
             @route        = route
+            @url_strategy = url_strategy
+            @route_name   = route_name
           end
 
-          def call(t, args)
-            t.url_for(handle_positional_args(t, args, @options, @segment_keys))
-          end
+          def call(t, args, inner_options)
+            controller_options = t.url_options
+            options = controller_options.merge @options
+            hash = handle_positional_args(controller_options,
+                                          deprecate_string_options(inner_options) || {},
+                                          args,
+                                          options,
+                                          @segment_keys)
 
-          def handle_positional_args(t, args, options, keys)
-            inner_options = args.extract_options!
-            result = options.dup
+            t._routes.url_for(hash, route_name, url_strategy)
+          end
 
+          def handle_positional_args(controller_options, inner_options, args, result, path_params)
             if args.size > 0
-              if args.size < keys.size - 1 # take format into account
-                keys -= t.url_options.keys if t.respond_to?(:url_options)
-                keys -= options.keys
+              # take format into account
+              if path_params.include?(:format)
+                path_params_size = path_params.size - 1
+              else
+                path_params_size = path_params.size
               end
-              keys -= inner_options.keys
-              result.merge!(Hash[keys.zip(args)])
+
+              if args.size < path_params_size
+                path_params -= controller_options.keys
+                path_params -= result.keys
+              end
+              path_params.each { |param|
+                value = inner_options.fetch(param) { args.shift }
+
+                unless param == :format && value.nil?
+                  result[param] = value
+                end
+              }
             end
 
             result.merge!(inner_options)
           end
+
+          DEPRECATED_STRING_OPTIONS = %w[controller action]
+
+          def deprecate_string_options(options)
+            options ||= {}
+            deprecated_string_options = options.keys & DEPRECATED_STRING_OPTIONS
+            if deprecated_string_options.any?
+              msg = "Calling URL helpers with string keys #{deprecated_string_options.join(", ")} is deprecated. Use symbols instead."
+              ActiveSupport::Deprecation.warn(msg)
+              deprecated_string_options.each do |option|
+                value = options.delete(option)
+                options[option.to_sym] = value
+              end
+            end
+            options
+          end
         end
 
         private
@@ -261,26 +336,48 @@ module ActionDispatch
         #
         #   foo_url(bar, baz, bang, sort_by: 'baz')
         #
-        def define_url_helper(route, name, options)
-          helper = UrlHelper.create(route, options.dup)
-
-          @module.remove_possible_method name
-          @module.module_eval do
+        def define_url_helper(mod, route, name, opts, route_key, url_strategy)
+          helper = UrlHelper.create(route, opts, route_key, url_strategy)
+          mod.module_eval do
             define_method(name) do |*args|
-              helper.call self, args
+              options = nil
+              options = args.pop if args.last.is_a? Hash
+              helper.call self, args, options
             end
           end
-
-          helpers << name
         end
+      end
 
-        def define_named_route_methods(name, route)
-          define_url_helper route, :"#{name}_path",
-            route.defaults.merge(:use_route => name, :only_path => true)
-          define_url_helper route, :"#{name}_url",
-            route.defaults.merge(:use_route => name, :only_path => false)
+      # strategy for building urls to send to the client
+      PATH    = ->(options) { ActionDispatch::Http::URL.path_for(options) }
+      FULL    = ->(options) { ActionDispatch::Http::URL.full_url_for(options) }
+      UNKNOWN = ->(options) { ActionDispatch::Http::URL.url_for(options) }
+      LEGACY  = ->(options) {
+        if options.key?(:only_path)
+          if options[:only_path]
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You are calling a `*_path` helper with the `only_path` option
+              explicitly set to `true`. This option will stop working on
+              path helpers in Rails 5. Simply remove the `only_path: true`
+              argument from your call as it is redundant when applied to a
+              path helper.
+            MSG
+
+            PATH.call(options)
+          else
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You are calling a `*_path` helper with the `only_path` option
+              explicitly set to `false`. This option will stop working on
+              path helpers in Rails 5. Use the corresponding `*_url` helper
+              instead.
+            MSG
+
+            FULL.call(options)
+          end
+        else
+          PATH.call(options)
         end
-      end
+      }
 
       attr_accessor :formatter, :set, :named_routes, :default_scope, :router
       attr_accessor :disable_clear_and_finalize, :resources_path_names
@@ -294,7 +391,7 @@ module ActionDispatch
 
       def initialize(request_class = ActionDispatch::Request)
         self.named_routes = NamedRouteCollection.new
-        self.resources_path_names = self.class.default_resources_path_names.dup
+        self.resources_path_names = self.class.default_resources_path_names
         self.default_url_options = {}
         self.request_class = request_class
 
@@ -304,9 +401,7 @@ module ActionDispatch
         @finalized                  = false
 
         @set    = Journey::Routes.new
-        @router = Journey::Router.new(@set, {
-          :parameters_key => PARAMETERS_KEY,
-          :request_class  => request_class})
+        @router = Journey::Router.new @set
         @formatter = Journey::Formatter.new @set
       end
 
@@ -337,6 +432,7 @@ module ActionDispatch
           mapper.instance_exec(&block)
         end
       end
+      private :eval_block
 
       def finalize!
         return if @finalized
@@ -352,7 +448,11 @@ module ActionDispatch
         @prepend.each { |blk| eval_block(blk) }
       end
 
-      module MountedHelpers #:nodoc:
+      def dispatcher(defaults)
+        Routing::RouteSet::Dispatcher.new(defaults)
+      end
+
+      module MountedHelpers
         extend ActiveSupport::Concern
         include UrlFor
       end
@@ -369,9 +469,11 @@ module ActionDispatch
         return if MountedHelpers.method_defined?(name)
 
         routes = self
+        helpers = routes.url_helpers
+
         MountedHelpers.class_eval do
           define_method "_#{name}" do
-            RoutesProxy.new(routes, _routes_context)
+            RoutesProxy.new(routes, _routes_context, helpers)
           end
         end
 
@@ -382,40 +484,57 @@ module ActionDispatch
         RUBY
       end
 
-      def url_helpers
-        @url_helpers ||= begin
-          routes = self
+      def url_helpers(supports_path = true)
+        routes = self
 
-          Module.new do
-            extend ActiveSupport::Concern
-            include UrlFor
+        Module.new do
+          extend ActiveSupport::Concern
+          include UrlFor
+
+          # Define url_for in the singleton level so one can do:
+          # Rails.application.routes.url_helpers.url_for(args)
+          @_routes = routes
+          class << self
+            delegate :url_for, :optimize_routes_generation?, to: '@_routes'
+            attr_reader :_routes
+            def url_options; {}; end
+          end
 
-            # Define url_for in the singleton level so one can do:
-            # Rails.application.routes.url_helpers.url_for(args)
-            @_routes = routes
-            class << self
-              delegate :url_for, :optimize_routes_generation?, :to => '@_routes'
-            end
+          url_helpers = routes.named_routes.url_helpers_module
 
-            # Make named_routes available in the module singleton
-            # as well, so one can do:
-            # Rails.application.routes.url_helpers.posts_path
-            extend routes.named_routes.module
+          # Make named_routes available in the module singleton
+          # as well, so one can do:
+          # Rails.application.routes.url_helpers.posts_path
+          extend url_helpers
 
-            # Any class that includes this module will get all
-            # named routes...
-            include routes.named_routes.module
+          # Any class that includes this module will get all
+          # named routes...
+          include url_helpers
 
-            # plus a singleton class method called _routes ...
-            included do
-              singleton_class.send(:redefine_method, :_routes) { routes }
-            end
+          if supports_path
+            path_helpers = routes.named_routes.path_helpers_module
+          else
+            path_helpers = routes.named_routes.path_helpers_module(true)
+          end
+
+          include path_helpers
+          extend path_helpers
 
-            # And an instance method _routes. Note that
-            # UrlFor (included in this module) add extra
-            # conveniences for working with @_routes.
-            define_method(:_routes) { @_routes || routes }
+          # plus a singleton class method called _routes ...
+          included do
+            singleton_class.send(:redefine_method, :_routes) { routes }
           end
+
+          # And an instance method _routes. Note that
+          # UrlFor (included in this module) add extra
+          # conveniences for working with @_routes.
+          define_method(:_routes) { @_routes || routes }
+
+          define_method(:_generate_paths_by_default) do
+            supports_path
+          end
+
+          private :_generate_paths_by_default
         end
       end
 
@@ -434,7 +553,9 @@ module ActionDispatch
             "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
         end
 
-        path = build_path(conditions.delete(:path_info), requirements, SEPARATORS, anchor)
+        path = conditions.delete :path_info
+        ast  = conditions.delete :parsed_path_info
+        path = build_path(path, ast, requirements, anchor)
         conditions = build_conditions(conditions, path.names.map { |x| x.to_sym })
 
         route = @set.add_route(app, path, conditions, defaults, name)
@@ -442,8 +563,9 @@ module ActionDispatch
         route
       end
 
-      def build_path(path, requirements, separators, anchor)
+      def build_path(path, ast, requirements, anchor)
         strexp = Journey::Router::Strexp.new(
+            ast,
             path,
             requirements,
             SEPARATORS,
@@ -491,7 +613,7 @@ module ActionDispatch
       end
       private :build_conditions
 
-      class Generator #:nodoc:
+      class Generator
         PARAMETERIZE = lambda do |name, value|
           if name == :controller
             value
@@ -504,8 +626,8 @@ module ActionDispatch
 
         attr_reader :options, :recall, :set, :named_route
 
-        def initialize(options, recall, set)
-          @named_route = options.delete(:use_route)
+        def initialize(named_route, options, recall, set)
+          @named_route = named_route
           @options     = options.dup
           @recall      = recall.dup
           @set         = set
@@ -596,7 +718,7 @@ module ActionDispatch
         # Generates a path from routes, returns [path, params].
         # If no route is generated the formatter will raise ActionController::UrlGenerationError
         def generate
-          @set.formatter.generate(:path_info, named_route, options, recall, PARAMETERIZE)
+          @set.formatter.generate(named_route, options, recall, PARAMETERIZE)
         end
 
         def different_controller?
@@ -621,61 +743,78 @@ module ActionDispatch
       end
 
       def generate_extras(options, recall={})
-        path, params = generate(options, recall)
+        route_key = options.delete :use_route
+        path, params = generate(route_key, options, recall)
         return path, params.keys
       end
 
-      def generate(options, recall = {})
-        Generator.new(options, recall, self).generate
+      def generate(route_key, options, recall = {})
+        Generator.new(route_key, options, recall, self).generate
       end
+      private :generate
 
       RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
                           :trailing_slash, :anchor, :params, :only_path, :script_name,
-                          :original_script_name]
+                          :original_script_name, :relative_url_root]
 
-      def mounted?
-        false
+      def optimize_routes_generation?
+        default_url_options.empty?
       end
 
-      def optimize_routes_generation?
-        !mounted? && default_url_options.empty?
+      def find_script_name(options)
+        options.delete(:script_name) || find_relative_url_root(options) || ''
       end
 
-      def _generate_prefix(options = {})
-        nil
+      def find_relative_url_root(options)
+        options.delete(:relative_url_root) || relative_url_root
+      end
+
+      def path_for(options, route_name = nil)
+        url_for(options, route_name, PATH)
       end
 
-      # The +options+ argument must be +nil+ or a hash whose keys are *symbols*.
-      def url_for(options)
-        options = default_url_options.merge(options || {})
+      # The +options+ argument must be a hash whose keys are *symbols*.
+      def url_for(options, route_name = nil, url_strategy = UNKNOWN)
+        options = default_url_options.merge options
 
-        user, password = extract_authentication(options)
-        recall  = options.delete(:_recall)
+        user = password = nil
 
-        original_script_name = options.delete(:original_script_name).presence
-        script_name = options.delete(:script_name).presence || _generate_prefix(options)
+        if options[:user] && options[:password]
+          user     = options.delete :user
+          password = options.delete :password
+        end
+
+        recall  = options.delete(:_recall) { {} }
+
+        original_script_name = options.delete(:original_script_name)
+        script_name = find_script_name options
 
-        if script_name && original_script_name
+        if original_script_name
           script_name = original_script_name + script_name
         end
 
-        path_options = options.except(*RESERVED_OPTIONS)
-        path_options = yield(path_options) if block_given?
+        path_options = options.dup
+        RESERVED_OPTIONS.each { |ro| path_options.delete ro }
 
-        path, params = generate(path_options, recall || {})
-        params.merge!(options[:params] || {})
+        path, params = generate(route_name, path_options, recall)
+
+        if options.key? :params
+          params.merge! options[:params]
+        end
 
-        ActionDispatch::Http::URL.url_for(options.merge!({
-          :path => path,
-          :script_name => script_name,
-          :params => params,
-          :user => user,
-          :password => password
-        }))
+        options[:path]        = path
+        options[:script_name] = script_name
+        options[:params]      = params
+        options[:user]        = user
+        options[:password]    = password
+
+        url_strategy.call options
       end
 
       def call(env)
-        @router.call(env)
+        req = request_class.new(env)
+        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
+        @router.serve(req)
       end
 
       def recognize_path(path, environment = {})
@@ -689,8 +828,8 @@ module ActionDispatch
           raise ActionController::RoutingError, e.message
         end
 
-        req = @request_class.new(env)
-        @router.recognize(req) do |route, _matches, params|
+        req = request_class.new(env)
+        @router.recognize(req) do |route, params|
           params.merge!(extras)
           params.each do |key, value|
             if value.is_a?(String)
@@ -698,14 +837,12 @@ module ActionDispatch
               params[key] = URI.parser.unescape(value)
             end
           end
-          old_params = env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
-          env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY] = (old_params || {}).merge(params)
-          dispatcher = route.app
-          while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
-            dispatcher = dispatcher.app
-          end
+          old_params = req.path_parameters
+          req.path_parameters = old_params.merge params
+          app = route.app
+          if app.matches?(req) && app.dispatcher?
+            dispatcher = app.app
 
-          if dispatcher.is_a?(Dispatcher)
             if dispatcher.controller(params, false)
               dispatcher.prepare_params!(params)
               return params
@@ -717,17 +854,7 @@ module ActionDispatch
 
         raise ActionController::RoutingError, "No route matches #{path.inspect}"
       end
-
-      private
-
-        def extract_authentication(options)
-          if options[:user] && options[:password]
-            [options.delete(:user), options.delete(:password)]
-          else
-            nil
-          end
-        end
-
     end
+    # :startdoc:
   end
 end