7 files changed, 979 insertions, 579 deletions

diff --git a/actionpack/lib/action_dispatch/routing/endpoint.rb b/actionpack/lib/action_dispatch/routing/endpoint.rb
new file mode 100644
index 0000000000..88aa13c3e8
--- /dev/null
+++ b/actionpack/lib/action_dispatch/routing/endpoint.rb
@@ -0,0 +1,10 @@
+module ActionDispatch
+  module Routing
+    class Endpoint # :nodoc:
+      def dispatcher?;   false; end
+      def redirect?;     false; end
+      def matches?(req); true;  end
+      def app;           self;  end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/routing/inspector.rb b/actionpack/lib/action_dispatch/routing/inspector.rb
index f612e91aef..cfe2237512 100644
--- a/actionpack/lib/action_dispatch/routing/inspector.rb
+++ b/actionpack/lib/action_dispatch/routing/inspector.rb
@@ -5,22 +5,15 @@ module ActionDispatch
   module Routing
     class RouteWrapper < SimpleDelegator
       def endpoint
-        rack_app ? rack_app.inspect : "#{controller}##{action}"
+        app.dispatcher? ? "#{controller}##{action}" : rack_app.inspect
       end
 
       def constraints
         requirements.except(:controller, :action)
       end
 
-      def rack_app(app = self.app)
-        @rack_app ||= begin
-          class_name = app.class.name.to_s
-          if class_name == "ActionDispatch::Routing::Mapper::Constraints"
-            rack_app(app.app)
-          elsif ActionDispatch::Routing::Redirect === app || class_name !~ /^ActionDispatch::Routing/
-            app
-          end
-        end
+      def rack_app
+        app.app
       end
 
       def verb
@@ -55,7 +48,7 @@ module ActionDispatch
       def reqs
         @reqs ||= begin
           reqs = endpoint
-          reqs += " #{constraints.to_s}" unless constraints.empty?
+          reqs += " #{constraints}" unless constraints.empty?
           reqs
         end
       end
@@ -73,7 +66,7 @@ module ActionDispatch
       end
 
       def engine?
-        rack_app && rack_app.respond_to?(:routes)
+        rack_app.respond_to?(:routes)
       end
     end
 
@@ -194,9 +187,9 @@ module ActionDispatch
         end
 
         def widths(routes)
-          [routes.map { |r| r[:name].length }.max,
-           routes.map { |r| r[:verb].length }.max,
-           routes.map { |r| r[:path].length }.max]
+          [routes.map { |r| r[:name].length }.max || 0,
+           routes.map { |r| r[:verb].length }.max || 0,
+           routes.map { |r| r[:path].length }.max || 0]
         end
     end
 
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index 18f37dc732..ac03ecb2c8 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -4,132 +4,201 @@ require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/string/filters'
 require 'active_support/inflector'
 require 'action_dispatch/routing/redirection'
+require 'action_dispatch/routing/endpoint'
+require 'active_support/deprecation'
 
 module ActionDispatch
   module Routing
     class Mapper
       URL_OPTIONS = [:protocol, :subdomain, :domain, :host, :port]
-      SCOPE_OPTIONS = [:path, :shallow_path, :as, :shallow_prefix, :module,
-                       :controller, :action, :path_names, :constraints,
-                       :shallow, :blocks, :defaults, :options]
-
-      class Constraints #:nodoc:
-        def self.new(app, constraints, request = Rack::Request)
-          if constraints.any?
-            super(app, constraints, request)
-          else
-            app
-          end
-        end
 
+      class Constraints < Endpoint #:nodoc:
         attr_reader :app, :constraints
 
-        def initialize(app, constraints, request)
-          @app, @constraints, @request = app, constraints, request
+        def initialize(app, constraints, dispatcher_p)
+          # Unwrap Constraints objects.  I don't actually think it's possible
+          # to pass a Constraints object to this constructor, but there were
+          # multiple places that kept testing children of this object.  I
+          # *think* they were just being defensive, but I have no idea.
+          if app.is_a?(self.class)
+            constraints += app.constraints
+            app = app.app
+          end
+
+          @dispatcher = dispatcher_p
+
+          @app, @constraints, = app, constraints
         end
 
-        def matches?(env)
-          req = @request.new(env)
+        def dispatcher?; @dispatcher; end
 
+        def matches?(req)
           @constraints.all? do |constraint|
             (constraint.respond_to?(:matches?) && constraint.matches?(req)) ||
               (constraint.respond_to?(:call) && constraint.call(*constraint_args(constraint, req)))
           end
-        ensure
-          req.reset_parameters
         end
 
-        def call(env)
-          matches?(env) ? @app.call(env) : [ 404, {'X-Cascade' => 'pass'}, [] ]
+        def serve(req)
+          return [ 404, {'X-Cascade' => 'pass'}, [] ] unless matches?(req)
+
+          if dispatcher?
+            @app.serve req
+          else
+            @app.call req.env
+          end
         end
 
         private
           def constraint_args(constraint, request)
-            constraint.arity == 1 ? [request] : [request.symbolized_path_parameters, request]
+            constraint.arity == 1 ? [request] : [request.path_parameters, request]
           end
       end
 
       class Mapping #:nodoc:
-        IGNORE_OPTIONS = [:to, :as, :via, :on, :constraints, :defaults, :only, :except, :anchor, :shallow, :shallow_path, :shallow_prefix, :format]
         ANCHOR_CHARACTERS_REGEX = %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
-        WILDCARD_PATH = %r{\*([^/\)]+)\)?$}
 
-        attr_reader :scope, :path, :options, :requirements, :conditions, :defaults
+        attr_reader :requirements, :conditions, :defaults
+        attr_reader :to, :default_controller, :default_action, :as, :anchor
+
+        def self.build(scope, set, path, as, options)
+          options = scope[:options].merge(options) if scope[:options]
+
+          options.delete :only
+          options.delete :except
+          options.delete :shallow_path
+          options.delete :shallow_prefix
+          options.delete :shallow
+
+          defaults = (scope[:defaults] || {}).merge options.delete(:defaults) || {}
+
+          new scope, set, path, defaults, as, options
+        end
+
+        def initialize(scope, set, path, defaults, as, options)
+          @requirements, @conditions = {}, {}
+          @defaults = defaults
+          @set = set
+
+          @to                 = options.delete :to
+          @default_controller = options.delete(:controller) || scope[:controller]
+          @default_action     = options.delete(:action) || scope[:action]
+          @as                 = as
+          @anchor             = options.delete :anchor
+
+          formatted = options.delete :format
+          via = Array(options.delete(:via) { [] })
+          options_constraints = options.delete :constraints
+
+          path = normalize_path! path, formatted
+          ast  = path_ast path
+          path_params = path_params ast
+
+          options = normalize_options!(options, formatted, path_params, ast, scope[:module])
+
+
+          split_constraints(path_params, scope[:constraints]) if scope[:constraints]
+          constraints = constraints(options, path_params)
+
+          split_constraints path_params, constraints
+
+          @blocks = blocks(options_constraints, scope[:blocks])
+
+          if options_constraints.is_a?(Hash)
+            split_constraints path_params, options_constraints
+            options_constraints.each do |key, default|
+              if URL_OPTIONS.include?(key) && (String === default || Fixnum === default)
+                @defaults[key] ||= default
+              end
+            end
+          end
+
+          normalize_format!(formatted)
 
-        def initialize(set, scope, path, options)
-          @set, @scope, @path, @options = set, scope, path, options
-          @requirements, @conditions, @defaults = {}, {}, {}
+          @conditions[:path_info] = path
+          @conditions[:parsed_path_info] = ast
 
-          normalize_options!
-          normalize_path!
-          normalize_requirements!
-          normalize_conditions!
-          normalize_defaults!
+          add_request_method(via, @conditions)
+          normalize_defaults!(options)
         end
 
         def to_route
-          [ app, conditions, requirements, defaults, options[:as], options[:anchor] ]
+          [ app(@blocks), conditions, requirements, defaults, as, anchor ]
         end
 
         private
 
-          def normalize_path!
-            raise ArgumentError, "path is required" if @path.blank?
-            @path = Mapper.normalize_path(@path)
+          def normalize_path!(path, format)
+            path = Mapper.normalize_path(path)
 
-            if required_format?
-              @path = "#{@path}.:format"
-            elsif optional_format?
-              @path = "#{@path}(.:format)"
+            if format == true
+              "#{path}.:format"
+            elsif optional_format?(path, format)
+              "#{path}(.:format)"
+            else
+              path
             end
           end
 
-          def required_format?
-            options[:format] == true
-          end
-
-          def optional_format?
-            options[:format] != false && !path.include?(':format') && !path.end_with?('/')
+          def optional_format?(path, format)
+            format != false && !path.include?(':format') && !path.end_with?('/')
           end
 
-          def normalize_options!
-            @options.reverse_merge!(scope[:options]) if scope[:options]
-            path_without_format = path.sub(/\(\.:format\)$/, '')
-
+          def normalize_options!(options, formatted, path_params, path_ast, modyoule)
             # Add a constraint for wildcard route to make it non-greedy and match the
             # optional format part of the route by default
-            if path_without_format.match(WILDCARD_PATH) && @options[:format] != false
-              @options[$1.to_sym] ||= /.+?/
+            if formatted != false
+              path_ast.grep(Journey::Nodes::Star) do |node|
+                options[node.name.to_sym] ||= /.+?/
+              end
             end
 
-            if path_without_format.match(':controller')
-              raise ArgumentError, ":controller segment is not allowed within a namespace block" if scope[:module]
+            if path_params.include?(:controller)
+              raise ArgumentError, ":controller segment is not allowed within a namespace block" if modyoule
 
               # Add a default constraint for :controller path segments that matches namespaced
               # controllers with default routes like :controller/:action/:id(.:format), e.g:
               # GET /admin/products/show/1
               # => { controller: 'admin/products', action: 'show', id: '1' }
-              @options[:controller] ||= /.+?/
+              options[:controller] ||= /.+?/
             end
 
-            @options.merge!(default_controller_and_action)
+            if to.respond_to? :call
+              options
+            else
+              to_endpoint = split_to to
+              controller  = to_endpoint[0] || default_controller
+              action      = to_endpoint[1] || default_action
+
+              controller = add_controller_module(controller, modyoule)
+
+              options.merge! check_controller_and_action(path_params, controller, action)
+            end
           end
 
-          def normalize_requirements!
-            constraints.each do |key, requirement|
-              next unless segment_keys.include?(key) || key == :controller
-              verify_regexp_requirement(requirement) if requirement.is_a?(Regexp)
-              @requirements[key] = requirement
+          def split_constraints(path_params, constraints)
+            constraints.each_pair do |key, requirement|
+              if path_params.include?(key) || key == :controller
+                verify_regexp_requirement(requirement) if requirement.is_a?(Regexp)
+                @requirements[key] = requirement
+              else
+                @conditions[key] = requirement
+              end
             end
+          end
 
-            if options[:format] == true
+          def normalize_format!(formatted)
+            if formatted == true
               @requirements[:format] ||= /.+/
-            elsif Regexp === options[:format]
-              @requirements[:format] = options[:format]
-            elsif String === options[:format]
-              @requirements[:format] = Regexp.compile(options[:format])
+            elsif Regexp === formatted
+              @requirements[:format] = formatted
+              @defaults[:format] = nil
+            elsif String === formatted
+              @requirements[:format] = Regexp.compile(formatted)
+              @defaults[:format] = formatted
             end
           end
 
@@ -143,169 +212,149 @@ module ActionDispatch
             end
           end
 
-          def normalize_defaults!
-            @defaults.merge!(scope[:defaults]) if scope[:defaults]
-            @defaults.merge!(options[:defaults]) if options[:defaults]
-
-            options.each do |key, default|
-              unless Regexp === default || IGNORE_OPTIONS.include?(key)
+          def normalize_defaults!(options)
+            options.each_pair do |key, default|
+              unless Regexp === default
                 @defaults[key] = default
               end
             end
-
-            if options[:constraints].is_a?(Hash)
-              options[:constraints].each do |key, default|
-                if URL_OPTIONS.include?(key) && (String === default || Fixnum === default)
-                  @defaults[key] ||= default
-                end
-              end
-            end
-
-            if Regexp === options[:format]
-              @defaults[:format] = nil
-            elsif String === options[:format]
-              @defaults[:format] = options[:format]
-            end
           end
 
-          def normalize_conditions!
-            @conditions[:path_info] = path
-
-            constraints.each do |key, condition|
-              unless segment_keys.include?(key) || key == :controller
-                @conditions[key] = condition
-              end
+          def verify_callable_constraint(callable_constraint)
+            unless callable_constraint.respond_to?(:call) || callable_constraint.respond_to?(:matches?)
+              raise ArgumentError, "Invalid constraint: #{callable_constraint.inspect} must respond to :call or :matches?"
             end
+          end
 
-            required_defaults = []
-            options.each do |key, required_default|
-              unless segment_keys.include?(key) || IGNORE_OPTIONS.include?(key) || Regexp === required_default
-                required_defaults << key
-              end
-            end
-            @conditions[:required_defaults] = required_defaults
-
-            via_all = options.delete(:via) if options[:via] == :all
+          def add_request_method(via, conditions)
+            return if via == [:all]
 
-            if !via_all && options[:via].blank?
+            if via.empty?
               msg = "You should not use the `match` method in your router without specifying an HTTP method.\n" \
                     "If you want to expose your action to both GET and POST, add `via: [:get, :post]` option.\n" \
                     "If you want to expose your action to GET, use `get` in the router:\n" \
                     "  Instead of: match \"controller#action\"\n" \
                     "  Do: get \"controller#action\""
-              raise msg
-            end
-
-            if via = options[:via]
-              @conditions[:request_method] = Array(via).map { |m| m.to_s.dasherize.upcase }
+              raise ArgumentError, msg
             end
-          end
 
-          def app
-            Constraints.new(endpoint, blocks, @set.request_class)
+            conditions[:request_method] = via.map { |m| m.to_s.dasherize.upcase }
           end
 
-          def default_controller_and_action
+          def app(blocks)
             if to.respond_to?(:call)
-              { }
+              Constraints.new(to, blocks, false)
             else
-              if to.is_a?(String)
-                controller, action = to.split('#')
-              elsif to.is_a?(Symbol)
-                action = to.to_s
-              end
-
-              controller ||= default_controller
-              action     ||= default_action
-
-              if @scope[:module] && !controller.is_a?(Regexp)
-                if controller =~ %r{\A/}
-                  controller = controller[1..-1]
-                else
-                  controller = [@scope[:module], controller].compact.join("/").presence
-                end
-              end
-
-              if controller.is_a?(String) && controller =~ %r{\A/}
-                raise ArgumentError, "controller name should not start with a slash"
+              if blocks.any?
+                Constraints.new(dispatcher(defaults), blocks, true)
+              else
+                dispatcher(defaults)
               end
+            end
+          end
 
-              controller = controller.to_s unless controller.is_a?(Regexp)
-              action     = action.to_s     unless action.is_a?(Regexp)
+          def check_controller_and_action(path_params, controller, action)
+            hash = check_part(:controller, controller, path_params, {}) do |part|
+              translate_controller(part) {
+                message = "'#{part}' is not a supported controller name. This can lead to potential routing problems."
+                message << " See http://guides.rubyonrails.org/routing.html#specifying-a-controller-to-use"
 
-              if controller.blank? && segment_keys.exclude?(:controller)
-                message = "Missing :controller key on routes definition, please check your routes."
                 raise ArgumentError, message
-              end
+              }
+            end
 
-              if action.blank? && segment_keys.exclude?(:action)
-                message = "Missing :action key on routes definition, please check your routes."
-                raise ArgumentError, message
-              end
+            check_part(:action, action, path_params, hash) { |part|
+              part.is_a?(Regexp) ? part : part.to_s
+            }
+          end
 
-              if controller.is_a?(String) && controller !~ /\A[a-z_0-9\/]*\z/
-                message = "'#{controller}' is not a supported controller name. This can lead to potential routing problems."
-                message << " See http://guides.rubyonrails.org/routing.html#specifying-a-controller-to-use"
+          def check_part(name, part, path_params, hash)
+            if part
+              hash[name] = yield(part)
+            else
+              unless path_params.include?(name)
+                message = "Missing :#{name} key on routes definition, please check your routes."
                 raise ArgumentError, message
               end
-
-              hash = {}
-              hash[:controller] = controller unless controller.blank?
-              hash[:action]     = action unless action.blank?
-              hash
             end
-          end
-
-          def blocks
-            if options[:constraints].present? && !options[:constraints].is_a?(Hash)
-              [options[:constraints]]
+            hash
+          end
+
+          def split_to(to)
+            case to
+            when Symbol
+              ActiveSupport::Deprecation.warn(<<-MSG.squish)
+                Defining a route where `to` is a symbol is deprecated.
+                Please change `to: :#{to}` to `action: :#{to}`.
+              MSG
+
+              [nil, to.to_s]
+            when /#/    then to.split('#')
+            when String
+              ActiveSupport::Deprecation.warn(<<-MSG.squish)
+                Defining a route where `to` is a controller without an action is deprecated.
+                Please change `to: :#{to}` to `controller: :#{to}`.
+              MSG
+
+              [to, nil]
             else
-              scope[:blocks] || []
+              []
             end
           end
 
-          def constraints
-            @constraints ||= {}.tap do |constraints|
-              constraints.merge!(scope[:constraints]) if scope[:constraints]
-
-              options.except(*IGNORE_OPTIONS).each do |key, option|
-                constraints[key] = option if Regexp === option
+          def add_controller_module(controller, modyoule)
+            if modyoule && !controller.is_a?(Regexp)
+              if controller =~ %r{\A/}
+                controller[1..-1]
+              else
+                [modyoule, controller].compact.join("/")
               end
-
-              constraints.merge!(options[:constraints]) if options[:constraints].is_a?(Hash)
+            else
+              controller
             end
           end
 
-          def segment_keys
-            @segment_keys ||= path_pattern.names.map{ |s| s.to_sym }
-          end
+          def translate_controller(controller)
+            return controller if Regexp === controller
+            return controller.to_s if controller =~ /\A[a-z_0-9][a-z_0-9\/]*\z/
 
-          def path_pattern
-            Journey::Path::Pattern.new(strexp)
-          end
-
-          def strexp
-            Journey::Router::Strexp.compile(path, requirements, SEPARATORS)
+            yield
           end
 
-          def endpoint
-            to.respond_to?(:call) ? to : dispatcher
+          def blocks(options_constraints, scope_blocks)
+            if options_constraints && !options_constraints.is_a?(Hash)
+              verify_callable_constraint(options_constraints)
+              [options_constraints]
+            else
+              scope_blocks || []
+            end
           end
 
-          def dispatcher
-            Routing::RouteSet::Dispatcher.new(:defaults => defaults)
+          def constraints(options, path_params)
+            constraints = {}
+            required_defaults = []
+            options.each_pair do |key, option|
+              if Regexp === option
+                constraints[key] = option
+              else
+                required_defaults << key unless path_params.include?(key)
+              end
+            end
+            @conditions[:required_defaults] = required_defaults
+            constraints
           end
 
-          def to
-            options[:to]
+          def path_params(ast)
+            ast.grep(Journey::Nodes::Symbol).map { |n| n.name.to_sym }
           end
 
-          def default_controller
-            options[:controller] || scope[:controller]
+          def path_ast(path)
+            parser = Journey::Parser.new
+            parser.parse path
           end
 
-          def default_action
-            options[:action] || scope[:action]
+          def dispatcher(defaults)
+            @set.dispatcher defaults
           end
       end
 
@@ -340,41 +389,61 @@ module ActionDispatch
           match '/', { :as => :root, :via => :get }.merge!(options)
         end
 
-        # Matches a url pattern to one or more routes. Any symbols in a pattern
-        # are interpreted as url query parameters and thus available as +params+
-        # in an action:
+        # Matches a url pattern to one or more routes.
+        #
+        # You should not use the `match` method in your router
+        # without specifying an HTTP method.
+        #
+        # If you want to expose your action to both GET and POST, use:
         #
         #   # sets :controller, :action and :id in params
-        #   match ':controller/:action/:id'
+        #   match ':controller/:action/:id', via: [:get, :post]
+        #
+        # Note that +:controller+, +:action+ and +:id+ are interpreted as url
+        # query parameters and thus available through +params+ in an action.
+        #
+        # If you want to expose your action to GET, use `get` in the router:
+        #
+        # Instead of:
+        #
+        #   match ":controller/:action/:id"
+        #
+        # Do:
+        #
+        #   get ":controller/:action/:id"
         #
         # Two of these symbols are special, +:controller+ maps to the controller
         # and +:action+ to the controller's action. A pattern can also map
         # wildcard segments (globs) to params:
         #
-        #   match 'songs/*category/:title', to: 'songs#show'
+        #   get 'songs/*category/:title', to: 'songs#show'
         #
         #   # 'songs/rock/classic/stairway-to-heaven' sets
         #   #  params[:category] = 'rock/classic'
         #   #  params[:title] = 'stairway-to-heaven'
         #
+        # To match a wildcard parameter, it must have a name assigned to it.
+        # Without a variable name to attach the glob parameter to, the route
+        # can't be parsed.
+        #
         # When a pattern points to an internal route, the route's +:action+ and
         # +:controller+ should be set in options or hash shorthand. Examples:
         #
-        #   match 'photos/:id' => 'photos#show'
-        #   match 'photos/:id', to: 'photos#show'
-        #   match 'photos/:id', controller: 'photos', action: 'show'
+        #   match 'photos/:id' => 'photos#show', via: :get
+        #   match 'photos/:id', to: 'photos#show', via: :get
+        #   match 'photos/:id', controller: 'photos', action: 'show', via: :get
         #
         # A pattern can also point to a +Rack+ endpoint i.e. anything that
         # responds to +call+:
         #
-        #   match 'photos/:id', to: lambda {|hash| [200, {}, ["Coming soon"]] }
-        #   match 'photos/:id', to: PhotoRackApp
+        #   match 'photos/:id', to: lambda {|hash| [200, {}, ["Coming soon"]] }, via: :get
+        #   match 'photos/:id', to: PhotoRackApp, via: :get
         #   # Yes, controller actions are just rack endpoints
-        #   match 'photos/:id', to: PhotosController.action(:show)
+        #   match 'photos/:id', to: PhotosController.action(:show), via: :get
         #
         # Because requesting various HTTP verbs with a single action has security
         # implications, you must either specify the actions in
-        # the via options or use one of the HtttpHelpers[rdoc-ref:HttpHelpers]
+        # the via options or use one of the HttpHelpers[rdoc-ref:HttpHelpers]
         # instead +match+
         #
         # === Options
@@ -387,13 +456,19 @@ module ActionDispatch
         # [:action]
         #   The route's action.
         #
+        # [:param]
+        #   Overrides the default resource identifier `:id` (name of the
+        #   dynamic segment used to generate the routes).
+        #   You can access that segment from your controller using
+        #   <tt>params[<:param>]</tt>.
+        #
         # [:path]
         #   The path prefix for the routes.
         #
         # [:module]
         #   The namespace for :controller.
         #
-        #     match 'path', to: 'c#a', module: 'sekret', controller: 'posts'
+        #     match 'path', to: 'c#a', module: 'sekret', controller: 'posts', via: :get
         #     # => Sekret::PostsController
         #
         #   See <tt>Scoping#namespace</tt> for its scope equivalent.
@@ -412,9 +487,9 @@ module ActionDispatch
         #   Points to a +Rack+ endpoint. Can be an object that responds to
         #   +call+ or a string representing a controller's action.
         #
-        #      match 'path', to: 'controller#action'
-        #      match 'path', to: lambda { |env| [200, {}, ["Success!"]] }
-        #      match 'path', to: RackApp
+        #      match 'path', to: 'controller#action', via: :get
+        #      match 'path', to: lambda { |env| [200, {}, ["Success!"]] }, via: :get
+        #      match 'path', to: RackApp, via: :get
         #
         # [:on]
         #   Shorthand for wrapping routes in a specific RESTful context. Valid
@@ -439,14 +514,14 @@ module ActionDispatch
         #   other than path can also be specified with any object
         #   that responds to <tt>===</tt> (eg. String, Array, Range, etc.).
         #
-        #     match 'path/:id', constraints: { id: /[A-Z]\d{5}/ }
+        #     match 'path/:id', constraints: { id: /[A-Z]\d{5}/ }, via: :get
         #
-        #     match 'json_only', constraints: { format: 'json' }
+        #     match 'json_only', constraints: { format: 'json' }, via: :get
         #
         #     class Whitelist
         #       def matches?(request) request.remote_ip == '1.2.3.4' end
         #     end
-        #     match 'path', to: 'c#a', constraints: Whitelist.new
+        #     match 'path', to: 'c#a', constraints: Whitelist.new, via: :get
         #
         #   See <tt>Scoping#constraints</tt> for more examples with its scope
         #   equivalent.
@@ -455,7 +530,7 @@ module ActionDispatch
         #   Sets defaults for parameters
         #
         #     # Sets params[:format] to 'jpg' by default
-        #     match 'path', to: 'c#a', defaults: { format: 'jpg' }
+        #     match 'path', to: 'c#a', defaults: { format: 'jpg' }, via: :get
         #
         #   See <tt>Scoping#defaults</tt> for its scope equivalent.
         #
@@ -464,7 +539,7 @@ module ActionDispatch
         #   false, the pattern matches any request prefixed with the given path.
         #
         #     # Matches any request starting with 'path'
-        #     match 'path', to: 'c#a', anchor: false
+        #     match 'path', to: 'c#a', anchor: false, via: :get
         #
         # [:format]
         #   Allows you to specify the default value for optional +format+
@@ -506,13 +581,21 @@ module ActionDispatch
 
           raise "A rack application must be specified" unless path
 
-          options[:as]  ||= app_name(app)
+          rails_app = rails_app? app
+
+          if rails_app
+            options[:as]  ||= app.railtie_name
+          else
+            # non rails apps can't have an :as
+            options[:as]  = nil
+          end
+
           target_as       = name_for_action(options[:as], path)
           options[:via] ||= :all
 
           match(path, options.merge(:to => app, :anchor => false, :format => false))
 
-          define_generate_prefix(app, target_as)
+          define_generate_prefix(app, target_as) if rails_app
           self
         end
 
@@ -533,35 +616,27 @@ module ActionDispatch
         end
 
         private
-          def app_name(app)
-            return unless app.respond_to?(:routes)
-
-            if app.respond_to?(:railtie_name)
-              app.railtie_name
-            else
-              class_name = app.class.is_a?(Class) ? app.name : app.class.name
-              ActiveSupport::Inflector.underscore(class_name).tr("/", "_")
-            end
+          def rails_app?(app)
+            app.is_a?(Class) && app < Rails::Railtie
           end
 
           def define_generate_prefix(app, name)
-            return unless app.respond_to?(:routes) && app.routes.respond_to?(:define_mounted_helper)
-
-            _route = @set.named_routes.routes[name.to_sym]
+            _route = @set.named_routes.get name
             _routes = @set
             app.routes.define_mounted_helper(name)
-            app.routes.singleton_class.class_eval do
-              redefine_method :mounted? do
-                true
-              end
-
-              redefine_method :_generate_prefix do |options|
-                prefix_options = options.slice(*_route.segment_keys)
-                # we must actually delete prefix segment keys to avoid passing them to next url_for
-                _route.segment_keys.each { |k| options.delete(k) }
-                _routes.url_helpers.send("#{name}_path", prefix_options)
+            app.routes.extend Module.new {
+              def optimize_routes_generation?; false; end
+              define_method :find_script_name do |options|
+                if options.key? :script_name
+                  super(options)
+                else
+                  prefix_options = options.slice(*_route.segment_keys)
+                  # we must actually delete prefix segment keys to avoid passing them to next url_for
+                  _route.segment_keys.each { |k| options.delete(k) }
+                  _routes.url_helpers.send("#{name}_path", prefix_options)
+                end
               end
-            end
+            }
           end
       end
 
@@ -648,7 +723,7 @@ module ActionDispatch
       #   resources :posts, module: "admin"
       #
       # If you want to route /admin/posts to +PostsController+
-      # (without the Admin:: module prefix), you could use
+      # (without the <tt>Admin::</tt> module prefix), you could use
       #
       #   scope "/admin" do
       #     resources :posts
@@ -702,11 +777,16 @@ module ActionDispatch
         #   end
         def scope(*args)
           options = args.extract_options!.dup
-          recover = {}
+          scope = {}
 
           options[:path] = args.flatten.join('/') if args.any?
           options[:constraints] ||= {}
 
+          unless nested_scope?
+            options[:shallow_path] ||= options[:path] if options.key?(:path)
+            options[:shallow_prefix] ||= options[:as] if options.key?(:as)
+          end
+
           if options[:constraints].is_a?(Hash)
             defaults = options[:constraints].select do
               |k, v| URL_OPTIONS.include?(k) && (v.is_a?(String) || v.is_a?(Fixnum))
@@ -717,7 +797,7 @@ module ActionDispatch
             block, options[:constraints] = options[:constraints], {}
           end
 
-          SCOPE_OPTIONS.each do |option|
+          @scope.options.each do |option|
             if option == :blocks
               value = block
             elsif option == :options
@@ -727,15 +807,15 @@ module ActionDispatch
             end
 
             if value
-              recover[option] = @scope[option]
-              @scope[option]  = send("merge_#{option}_scope", @scope[option], value)
+              scope[option] = send("merge_#{option}_scope", @scope[option], value)
             end
           end
 
+          @scope = @scope.new scope
           yield
           self
         ensure
-          @scope.merge!(recover)
+          @scope = @scope.parent
         end
 
         # Scopes routes to a specific controller
@@ -788,9 +868,16 @@ module ActionDispatch
         #   end
         def namespace(path, options = {})
           path = path.to_s
-          options = { :path => path, :as => path, :module => path,
-                      :shallow_path => path, :shallow_prefix => path }.merge!(options)
-          scope(options) { yield }
+
+          defaults = {
+            module:         path,
+            path:           options.fetch(:path, path),
+            as:             options.fetch(:as, path),
+            shallow_path:   options.fetch(:path, path),
+            shallow_prefix: options.fetch(:as, path)
+          }
+
+          scope(defaults.merge!(options)) { yield }
         end
 
         # === Parameter Restriction
@@ -966,8 +1053,6 @@ module ActionDispatch
         VALID_ON_OPTIONS  = [:new, :collection, :member]
         RESOURCE_OPTIONS  = [:as, :controller, :path, :only, :except, :param, :concerns]
         CANONICAL_ACTIONS = %w(index create new show update destroy)
-        RESOURCE_METHOD_SCOPES = [:collection, :member, :new]
-        RESOURCE_SCOPES = [:resource, :resources]
 
         class Resource #:nodoc:
           attr_reader :controller, :path, :options, :param
@@ -979,6 +1064,7 @@ module ActionDispatch
             @as         = options[:as]
             @param      = (options[:param] || :id).to_sym
             @options    = options
+            @shallow    = false
           end
 
           def default_actions
@@ -1039,6 +1125,13 @@ module ActionDispatch
             "#{path}/:#{nested_param}"
           end
 
+          def shallow=(value)
+            @shallow = value
+          end
+
+          def shallow?
+            @shallow
+          end
         end
 
         class SingletonResource < Resource #:nodoc:
@@ -1319,8 +1412,10 @@ module ActionDispatch
           end
 
           with_scope_level(:member) do
-            scope(parent_resource.member_scope) do
-              yield
+            if shallow?
+              shallow_scope(parent_resource.member_scope) { yield }
+            else
+              scope(parent_resource.member_scope) { yield }
             end
           end
         end
@@ -1343,16 +1438,8 @@ module ActionDispatch
           end
 
           with_scope_level(:nested) do
-            if shallow?
-              with_exclusive_scope do
-                if @scope[:shallow_path].blank?
-                  scope(parent_resource.nested_scope, nested_options) { yield }
-                else
-                  scope(@scope[:shallow_path], :as => @scope[:shallow_prefix]) do
-                    scope(parent_resource.nested_scope, nested_options) { yield }
-                  end
-                end
-              end
+            if shallow? && shallow_nesting_depth >= 1
+              shallow_scope(parent_resource.nested_scope, nested_options) { yield }
             else
               scope(parent_resource.nested_scope, nested_options) { yield }
             end
@@ -1369,7 +1456,7 @@ module ActionDispatch
         end
 
         def shallow
-          scope(:shallow => true, :shallow_path => @scope[:path]) do
+          scope(:shallow => true) do
             yield
           end
         end
@@ -1385,7 +1472,20 @@ module ActionDispatch
           if rest.empty? && Hash === path
             options  = path
             path, to = options.find { |name, _value| name.is_a?(String) }
-            options[:to] = to
+
+            case to
+            when Symbol
+              options[:action] = to
+            when String
+              if to =~ /#/
+                options[:to] = to
+              else
+                options[:controller] = to
+              end
+            else
+              options[:to] = to
+            end
+
             options.delete(path)
             paths = [path]
           else
@@ -1410,6 +1510,7 @@ module ActionDispatch
             path_without_format = _path.to_s.sub(/\(\.:format\)$/, '')
             if using_match_shorthand?(path_without_format, route_options)
               route_options[:to] ||= path_without_format.gsub(%r{^/}, "").sub(%r{/([^/]*)$}, '#\1')
+              route_options[:to].tr!("-", "_")
             end
 
             decomposed_match(_path, route_options)
@@ -1425,7 +1526,7 @@ module ActionDispatch
           if on = options.delete(:on)
             send(on) { decomposed_match(path, options) }
           else
-            case @scope[:scope_level]
+            case @scope.scope_level
             when :resources
               nested { decomposed_match(path, options) }
             when :resource
@@ -1438,21 +1539,23 @@ module ActionDispatch
 
         def add_route(action, options) # :nodoc:
           path = path_for_action(action, options.delete(:path))
+          raise ArgumentError, "path is required" if path.blank?
+
           action = action.to_s.dup
 
-          if action =~ /^[\w\/]+$/
-            options[:action] ||= action unless action.include?("/")
+          if action =~ /^[\w\-\/]+$/
+            options[:action] ||= action.tr('-', '_') unless action.include?("/")
           else
             action = nil
           end
 
-          if !options.fetch(:as, true)
-            options.delete(:as)
-          else
-            options[:as] = name_for_action(options[:as], action)
-          end
+          as = if !options.fetch(:as, true) # if it's set to nil or false
+                 options.delete(:as)
+               else
+                 name_for_action(options.delete(:as), action)
+               end
 
-          mapping = Mapping.new(@set, @scope, URI.parser.escape(path), options)
+          mapping = Mapping.build(@scope, @set, URI.parser.escape(path), as, options)
           app, conditions, requirements, defaults, as, anchor = mapping.to_route
           @set.add_route(app, conditions, requirements, defaults, as, anchor)
         end
@@ -1466,7 +1569,7 @@ module ActionDispatch
             raise ArgumentError, "must be called with a path and/or options"
           end
 
-          if @scope[:scope_level] == :resources
+          if @scope.resources?
             with_scope_level(:root) do
               scope(parent_resource.path) do
                 super(options)
@@ -1489,6 +1592,13 @@ module ActionDispatch
               return true
             end
 
+            if options.delete(:shallow)
+              shallow do
+                send(method, resources.pop, options, &block)
+              end
+              return true
+            end
+
             if resource_scope?
               nested { send(method, resources.pop, options, &block) }
               return true
@@ -1526,41 +1636,47 @@ module ActionDispatch
           end
 
           def resource_scope? #:nodoc:
-            RESOURCE_SCOPES.include? @scope[:scope_level]
+            @scope.resource_scope?
           end
 
           def resource_method_scope? #:nodoc:
-            RESOURCE_METHOD_SCOPES.include? @scope[:scope_level]
+            @scope.resource_method_scope?
+          end
+
+          def nested_scope? #:nodoc:
+            @scope.nested?
           end
 
           def with_exclusive_scope
             begin
-              old_name_prefix, old_path = @scope[:as], @scope[:path]
-              @scope[:as], @scope[:path] = nil, nil
+              @scope = @scope.new(:as => nil, :path => nil)
 
               with_scope_level(:exclusive) do
                 yield
               end
             ensure
-              @scope[:as], @scope[:path] = old_name_prefix, old_path
+              @scope = @scope.parent
             end
           end
 
-          def with_scope_level(kind, resource = parent_resource)
-            old, @scope[:scope_level] = @scope[:scope_level], kind
-            old_resource, @scope[:scope_level_resource] = @scope[:scope_level_resource], resource
+          def with_scope_level(kind)
+            @scope = @scope.new_level(kind)
             yield
           ensure
-            @scope[:scope_level] = old
-            @scope[:scope_level_resource] = old_resource
+            @scope = @scope.parent
           end
 
           def resource_scope(kind, resource) #:nodoc:
-            with_scope_level(kind, resource) do
-              scope(parent_resource.resource_scope) do
-                yield
-              end
+            resource.shallow = @scope[:shallow]
+            @scope = @scope.new(:scope_level_resource => resource)
+            @nesting.push(resource)
+
+            with_scope_level(kind) do
+              scope(parent_resource.resource_scope) { yield }
             end
+          ensure
+            @nesting.pop
+            @scope = @scope.parent
           end
 
           def nested_options #:nodoc:
@@ -1572,6 +1688,14 @@ module ActionDispatch
             options
           end
 
+          def nesting_depth #:nodoc:
+            @nesting.size
+          end
+
+          def shallow_nesting_depth #:nodoc:
+            @nesting.select(&:shallow?).size
+          end
+
           def param_constraint? #:nodoc:
             @scope[:constraints] && @scope[:constraints][parent_resource.param].is_a?(Regexp)
           end
@@ -1580,22 +1704,25 @@ module ActionDispatch
             @scope[:constraints][parent_resource.param]
           end
 
-          def canonical_action?(action, flag) #:nodoc:
-            flag && resource_method_scope? && CANONICAL_ACTIONS.include?(action.to_s)
+          def canonical_action?(action) #:nodoc:
+            resource_method_scope? && CANONICAL_ACTIONS.include?(action.to_s)
           end
 
-          def shallow_scoping? #:nodoc:
-            shallow? && @scope[:scope_level] == :member
+          def shallow_scope(path, options = {}) #:nodoc:
+            scope = { :as   => @scope[:shallow_prefix],
+                      :path => @scope[:shallow_path] }
+            @scope = @scope.new scope
+
+            scope(path, options) { yield }
+          ensure
+            @scope = @scope.parent
           end
 
           def path_for_action(action, path) #:nodoc:
-            prefix = shallow_scoping? ?
-              "#{@scope[:shallow_path]}/#{parent_resource.shallow_scope}" : @scope[:path]
-
-            if canonical_action?(action, path.blank?)
-              prefix.to_s
+            if path.blank? && canonical_action?(action)
+              @scope[:path].to_s
             else
-              "#{prefix}/#{action_path(action, path)}"
+              "#{@scope[:path]}/#{action_path(action, path)}"
             end
           end
 
@@ -1606,15 +1733,18 @@ module ActionDispatch
 
           def prefix_name_for_action(as, action) #:nodoc:
             if as
-              as.to_s
-            elsif !canonical_action?(action, @scope[:scope_level])
-              action.to_s
+              prefix = as
+            elsif !canonical_action?(action)
+              prefix = action
+            end
+
+            if prefix && prefix != '/' && !prefix.empty?
+              Mapper.normalize_name prefix.to_s.tr('-', '_')
             end
           end
 
           def name_for_action(as, action) #:nodoc:
             prefix = prefix_name_for_action(as, action)
-            prefix = Mapper.normalize_name(prefix) if prefix
             name_prefix = @scope[:as]
 
             if parent_resource
@@ -1624,27 +1754,14 @@ module ActionDispatch
               member_name = parent_resource.member_name
             end
 
-            name = case @scope[:scope_level]
-            when :nested
-              [name_prefix, prefix]
-            when :collection
-              [prefix, name_prefix, collection_name]
-            when :new
-              [prefix, :new, name_prefix, member_name]
-            when :member
-              [prefix, shallow_scoping? ? @scope[:shallow_prefix] : name_prefix, member_name]
-            when :root
-              [name_prefix, collection_name, prefix]
-            else
-              [name_prefix, member_name, prefix]
-            end
+            name = @scope.action_name(name_prefix, prefix, collection_name, member_name)
 
-            if candidate = name.select(&:present?).join("_").presence
+            if candidate = name.compact.join("_").presence
               # If a name was not explicitly given, we check if it is valid
               # and return nil in case it isn't. Otherwise, we pass the invalid name
               # forward so the underlying router engine treats it and raises an exception.
               if as.nil?
-                candidate unless @set.routes.find { |r| r.name == candidate } || candidate !~ /\A[_a-z]/i
+                candidate unless candidate !~ /\A[_a-z]/i || @set.named_routes.key?(candidate)
               else
                 candidate
               end
@@ -1769,10 +1886,85 @@ module ActionDispatch
         end
       end
 
+      class Scope # :nodoc:
+        OPTIONS = [:path, :shallow_path, :as, :shallow_prefix, :module,
+                   :controller, :action, :path_names, :constraints,
+                   :shallow, :blocks, :defaults, :options]
+
+        RESOURCE_SCOPES = [:resource, :resources]
+        RESOURCE_METHOD_SCOPES = [:collection, :member, :new]
+
+        attr_reader :parent, :scope_level
+
+        def initialize(hash, parent = {}, scope_level = nil)
+          @hash = hash
+          @parent = parent
+          @scope_level = scope_level
+        end
+
+        def nested?
+          scope_level == :nested
+        end
+
+        def resources?
+          scope_level == :resources
+        end
+
+        def resource_method_scope?
+          RESOURCE_METHOD_SCOPES.include? scope_level
+        end
+
+        def action_name(name_prefix, prefix, collection_name, member_name)
+          case scope_level
+          when :nested
+            [name_prefix, prefix]
+          when :collection
+            [prefix, name_prefix, collection_name]
+          when :new
+            [prefix, :new, name_prefix, member_name]
+          when :member
+            [prefix, name_prefix, member_name]
+          when :root
+            [name_prefix, collection_name, prefix]
+          else
+            [name_prefix, member_name, prefix]
+          end
+        end
+
+        def resource_scope?
+          RESOURCE_SCOPES.include? scope_level
+        end
+
+        def options
+          OPTIONS
+        end
+
+        def new(hash)
+          self.class.new hash, self, scope_level
+        end
+
+        def new_level(level)
+          self.class.new(self, self, level)
+        end
+
+        def fetch(key, &block)
+          @hash.fetch(key, &block)
+        end
+
+        def [](key)
+          @hash.fetch(key) { @parent[key] }
+        end
+
+        def []=(k,v)
+          @hash[k] = v
+        end
+      end
+
       def initialize(set) #:nodoc:
         @set = set
-        @scope = { :path_names => @set.resources_path_names }
+        @scope = Scope.new({ :path_names => @set.resources_path_names })
         @concerns = {}
+        @nesting = []
       end
 
       include Base
diff --git a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
index 2fb03f2712..0847842fa2 100644
--- a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
+++ b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
@@ -101,118 +101,229 @@ 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 record.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."
+            if record.persisted?
+              args << record.to_model
+              record.to_model.model_name.singular_route_key
+            else
+              @key_strategy.call record.to_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
-
diff --git a/actionpack/lib/action_dispatch/routing/redirection.rb b/actionpack/lib/action_dispatch/routing/redirection.rb
index b08e62543b..3c1c4fadf6 100644
--- a/actionpack/lib/action_dispatch/routing/redirection.rb
+++ b/actionpack/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,
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index a03fb4cee7..a641ea3ea9 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -1,11 +1,15 @@
 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
@@ -16,27 +20,17 @@ module ActionDispatch
       # alias inspect to to_s.
       alias inspect to_s
 
-      PARAMETERS_KEY = 'action_dispatch.request.path_parameters'
-
-      class Dispatcher #:nodoc:
-        def initialize(options={})
-          @defaults = options[:defaults]
-          @glob_param = options.delete(:glob)
+      class Dispatcher < Routing::Endpoint #:nodoc:
+        def initialize(defaults)
+          @defaults = defaults
           @controller_class_names = ThreadSafe::Cache.new
         end
 
-        def call(env)
-          params = env[PARAMETERS_KEY]
-
-          # 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?)
+        def dispatcher?; true; end
 
-            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)
 
@@ -45,13 +39,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)
@@ -87,10 +80,6 @@ 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
@@ -98,36 +87,72 @@ module ActionDispatch
       # named routes.
       class NamedRouteCollection #:nodoc:
         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!
@@ -145,36 +170,54 @@ module ActionDispatch
           routes.length
         end
 
+        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 # :nodoc:
-          def self.create(route, options)
+          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.requirements.except(:controller, :action).empty?
+            !route.glob? && route.path.requirements.empty?
           end
 
+          attr_reader :url_strategy, :route_name
+
           class OptimizedUrlHelper < UrlHelper # :nodoc:
             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
@@ -183,18 +226,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_fragment(params[segment]) : segment
+              @route.format params
             end
 
             def optimize_routes_generation?(t)
@@ -202,7 +241,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)
@@ -218,27 +259,36 @@ 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))
+          def call(t, args, inner_options)
+            controller_options = t.url_options
+            options = controller_options.merge @options
+            hash = handle_positional_args(controller_options,
+                                          inner_options || {},
+                                          args,
+                                          options,
+                                          @segment_keys)
+
+            t._routes.url_for(hash, route_name, url_strategy)
           end
 
-          def handle_positional_args(t, args, options, keys)
-            inner_options = args.extract_options!
-            result = options.dup
+          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
+              if args.size < path_params.size - 1 # take format into account
+                path_params -= controller_options.keys
+                path_params -= result.keys
               end
-              keys -= inner_options.keys
-              result.merge!(Hash[keys.zip(args)])
+              path_params.each { |param|
+                result[param] = inner_options[param] || args.shift
+              }
             end
 
             result.merge!(inner_options)
@@ -259,26 +309,50 @@ 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)
+      # :stopdoc:
+      # 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
+      }
+      # :startdoc:
 
       attr_accessor :formatter, :set, :named_routes, :default_scope, :router
       attr_accessor :disable_clear_and_finalize, :resources_path_names
@@ -292,7 +366,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
 
@@ -302,9 +376,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
 
@@ -335,6 +407,7 @@ module ActionDispatch
           mapper.instance_exec(&block)
         end
       end
+      private :eval_block
 
       def finalize!
         return if @finalized
@@ -350,6 +423,10 @@ module ActionDispatch
         @prepend.each { |blk| eval_block(blk) }
       end
 
+      def dispatcher(defaults)
+        Routing::RouteSet::Dispatcher.new(defaults)
+      end
+
       module MountedHelpers #:nodoc:
         extend ActiveSupport::Concern
         include UrlFor
@@ -380,40 +457,51 @@ module ActionDispatch
         RUBY
       end
 
-      def url_helpers
-        @url_helpers ||= begin
-          routes = self
+      def url_helpers(include_path_helpers = true)
+        routes = self
+
+        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
 
-          Module.new do
-            extend ActiveSupport::Concern
-            include UrlFor
+          url_helpers = routes.named_routes.url_helpers_module
 
-            # 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
+          # Make named_routes available in the module singleton
+          # as well, so one can do:
+          # Rails.application.routes.url_helpers.posts_path
+          extend url_helpers
 
-            # 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
+          # Any class that includes this module will get all
+          # named routes...
+          include url_helpers
 
-            # Any class that includes this module will get all
-            # named routes...
-            include routes.named_routes.module
+          if include_path_helpers
+            path_helpers = routes.named_routes.path_helpers_module
+          else
+            path_helpers = routes.named_routes.path_helpers_module(true)
+          end
 
-            # plus a singleton class method called _routes ...
-            included do
-              singleton_class.send(:redefine_method, :_routes) { routes }
-            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 }
         end
       end
 
@@ -432,7 +520,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)
@@ -440,8 +530,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,
@@ -502,8 +593,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
@@ -594,7 +685,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?
@@ -619,61 +710,74 @@ 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]
 
-      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) { '' }
       end
 
-      def _generate_prefix(options = {})
-        nil
+      def path_for(options, route_name = nil) # :nodoc:
+        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 = nil
+
+        if options[:user] && options[:password]
+          user     = options.delete :user
+          password = options.delete :password
+        end
 
-        user, password = extract_authentication(options)
-        recall  = options.delete(:_recall)
+        recall  = options.delete(:_recall) { {} }
 
-        original_script_name = options.delete(:original_script_name).presence
-        script_name = options.delete(:script_name).presence || _generate_prefix(options)
+        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)
 
-        ActionDispatch::Http::URL.url_for(options.merge!({
-          :path => path,
-          :script_name => script_name,
-          :params => params,
-          :user => user,
-          :password => password
-        }))
+        if options.key? :params
+          params.merge! options[:params]
+        end
+
+        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 = {})
@@ -687,8 +791,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)
@@ -696,14 +800,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
@@ -715,17 +817,6 @@ 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
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/url_for.rb b/actionpack/lib/action_dispatch/routing/url_for.rb
index 4a0ef40873..eb554ec383 100644
--- a/actionpack/lib/action_dispatch/routing/url_for.rb
+++ b/actionpack/lib/action_dispatch/routing/url_for.rb
@@ -152,21 +152,26 @@ module ActionDispatch
         when nil
           _routes.url_for(url_options.symbolize_keys)
         when Hash
-          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options))
+          route_name = options.delete :use_route
+          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options),
+                         route_name)
         when String
           options
+        when Symbol
+          HelperMethodBuilder.url.handle_string_call self, options
         when Array
           polymorphic_url(options, options.extract_options!)
+        when Class
+          HelperMethodBuilder.url.handle_class_call self, options
         else
-          polymorphic_url(options)
+          HelperMethodBuilder.url.handle_model_call self, options
         end
       end
 
       protected
 
       def optimize_routes_generation?
-        return @_optimized_routes if defined?(@_optimized_routes)
-        @_optimized_routes = _routes.optimize_routes_generation? && default_url_options.empty?
+        _routes.optimize_routes_generation? && default_url_options.empty?
       end
 
       def _with_routes(routes)