actionpack 4.2.11.3 → 5.0.7.2

data/lib/action_dispatch/routing/route_set.rb

@@ -1,11 +1,9 @@
 require 'action_dispatch/journey'
-require 'forwardable'
 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'
@@ -20,67 +18,48 @@ module ActionDispatch
       # alias inspect to to_s.
       alias inspect to_s
 
-      mattr_accessor :relative_url_root
-
       class Dispatcher < Routing::Endpoint
-        def initialize(defaults)
-          @defaults = defaults
+        def initialize(raise_on_name_error)
+          @raise_on_name_error = raise_on_name_error
         end
 
         def dispatcher?; true; end
 
         def serve(req)
-          req.check_path_parameters!
-          params = req.path_parameters
-
-          prepare_params!(params)
-
-          # Just raise undefined constant errors if a controller was specified as default.
-          unless controller = controller(params, @defaults.key?(:controller))
+          params     = req.path_parameters
+          controller = controller req
+          res        = controller.make_response! req
+          dispatch(controller, params[:action], req, res)
+        rescue ActionController::RoutingError
+          if @raise_on_name_error
+            raise
+          else
             return [404, {'X-Cascade' => 'pass'}, []]
           end
-
-          dispatch(controller, params[:action], req.env)
         end
 
-        def prepare_params!(params)
-          normalize_controller!(params)
-          merge_default_action!(params)
-        end
+      private
 
-        # If this is a default_controller (i.e. a controller specified by the user)
-        # we should raise an error in case it's not found, because it usually means
-        # a user error. However, if the controller was retrieved through a dynamic
-        # segment, as in :controller(/:action), we should simply return nil and
-        # delegate the control back to Rack cascade. Besides, if this is not a default
-        # controller, it means we should respect the @scope[:module] parameter.
-        def controller(params, default_controller=true)
-          if params && params.key?(:controller)
-            controller_param = params[:controller]
-            controller_reference(controller_param)
-          end
+        def controller(req)
+          req.controller_class
         rescue NameError => e
-          raise ActionController::RoutingError, e.message, e.backtrace if default_controller
+          raise ActionController::RoutingError, e.message, e.backtrace
         end
 
-      private
-
-        def controller_reference(controller_param)
-          const_name = "#{controller_param.camelize}Controller"
-          ActiveSupport::Dependencies.constantize(const_name)
+        def dispatch(controller, action, req, res)
+          controller.dispatch(action, req, res)
         end
+      end
 
-        def dispatch(controller, action, env)
-          controller.action(action).call(env)
+      class StaticDispatcher < Dispatcher
+        def initialize(controller_class)
+          super(false)
+          @controller_class = controller_class
         end
 
-        def normalize_controller!(params)
-          params[:controller] = params[:controller].underscore if params.key?(:controller)
-        end
+        private
 
-        def merge_default_action!(params)
-          params[:action] ||= 'index'
-        end
+        def controller(_); @controller_class; end
       end
 
       # A NamedRouteCollection instance is a collection of named routes, and also
@@ -88,7 +67,8 @@ module ActionDispatch
       # named routes.
       class NamedRouteCollection
         include Enumerable
-        attr_reader :routes, :url_helpers_module
+        attr_reader :routes, :url_helpers_module, :path_helpers_module
+        private :routes
 
         def initialize
           @routes  = {}
@@ -103,14 +83,6 @@ module ActionDispatch
           @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
           @path_helpers.map(&:to_s) + @url_helpers.map(&:to_s)
         end
@@ -139,7 +111,7 @@ module ActionDispatch
             @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 @path_helpers_module, route, path_name, route.defaults, name, PATH
           define_url_helper @url_helpers_module,  route, url_name,  route.defaults, name, UNKNOWN
 
           @path_helpers << path_name
@@ -151,6 +123,7 @@ module ActionDispatch
         end
 
         def key?(name)
+          return unless name
           routes.key? name.to_sym
         end
 
@@ -171,25 +144,6 @@ 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
           def self.create(route, options, route_name, url_strategy)
             if optimize_helper?(route)
@@ -227,11 +181,8 @@ module ActionDispatch
             private
 
             def optimized_helper(args)
-              params = parameterize_args(args)
-              missing_keys = missing_keys(params)
-
-              unless missing_keys.empty?
-                raise_generation_error(params, missing_keys)
+              params = parameterize_args(args) do
+                raise_generation_error(args)
               end
 
               @route.format params
@@ -243,16 +194,21 @@ module ActionDispatch
 
             def parameterize_args(args)
               params = {}
-              @required_parts.zip(args.map(&:to_param)) { |k,v| params[k] = v }
+              @arg_size.times { |i|
+                key = @required_parts[i]
+                value = args[i].to_param
+                yield key if value.nil? || value.empty?
+                params[key] = value
+              }
               params
             end
 
-            def missing_keys(args)
-              args.select{ |part, arg| arg.nil? || arg.empty? }.keys
-            end
-
-            def raise_generation_error(args, missing_keys)
-              constraints = Hash[@route.requirements.merge(args).sort_by{|k,v| k.to_s}]
+            def raise_generation_error(args)
+              missing_keys = []
+              params = parameterize_args(args) { |missing_key|
+                missing_keys << missing_key
+              }
+              constraints = Hash[@route.requirements.merge(params).sort_by{|k,v| k.to_s}]
               message = "No route matches #{constraints.inspect}"
               message << " missing required keys: #{missing_keys.sort.inspect}"
 
@@ -272,7 +228,7 @@ module ActionDispatch
             controller_options = t.url_options
             options = controller_options.merge @options
             hash = handle_positional_args(controller_options,
-                                          deprecate_string_options(inner_options) || {},
+                                          inner_options || {},
                                           args,
                                           options,
                                           @segment_keys)
@@ -292,34 +248,21 @@ module ActionDispatch
               if args.size < path_params_size
                 path_params -= controller_options.keys
                 path_params -= result.keys
+              else
+                path_params = path_params.dup
+              end
+              inner_options.each_key do |key|
+                path_params.delete(key)
               end
-              path_params.each { |param|
-                value = inner_options.fetch(param) { args.shift }
 
-                unless param == :format && value.nil?
-                  result[param] = value
-                end
-              }
+              args.each_with_index do |arg, index|
+                param = path_params[index]
+                result[param] = arg if param
+              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
@@ -340,8 +283,17 @@ module ActionDispatch
           helper = UrlHelper.create(route, opts, route_key, url_strategy)
           mod.module_eval do
             define_method(name) do |*args|
-              options = nil
-              options = args.pop if args.last.is_a? Hash
+              last = args.last
+              options = case last
+                        when Hash
+                          args.pop
+                        when ActionController::Parameters
+                          if last.permitted?
+                            args.pop.to_h
+                          else
+                            raise ArgumentError, ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE
+                          end
+                        end
               helper.call self, args, options
             end
           end
@@ -350,38 +302,12 @@ module ActionDispatch
 
       # 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
-      }
 
       attr_accessor :formatter, :set, :named_routes, :default_scope, :router
       attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options, :request_class
+      attr_accessor :default_url_options
+      attr_reader :env_key
 
       alias :routes :set
 
@@ -389,22 +315,59 @@ module ActionDispatch
         { :new => 'new', :edit => 'edit' }
       end
 
-      def initialize(request_class = ActionDispatch::Request)
+      def self.new_with_config(config)
+        route_set_config = DEFAULT_CONFIG
+
+        # engines apparently don't have this set
+        if config.respond_to? :relative_url_root
+          route_set_config.relative_url_root = config.relative_url_root
+        end
+
+        if config.respond_to? :api_only
+          route_set_config.api_only = config.api_only
+        end
+
+        new route_set_config
+      end
+
+      Config = Struct.new :relative_url_root, :api_only
+
+      DEFAULT_CONFIG = Config.new(nil, false)
+
+      def initialize(config = DEFAULT_CONFIG)
         self.named_routes = NamedRouteCollection.new
         self.resources_path_names = self.class.default_resources_path_names
         self.default_url_options = {}
-        self.request_class = request_class
 
+        @config                     = config
         @append                     = []
         @prepend                    = []
         @disable_clear_and_finalize = false
         @finalized                  = false
+        @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME".freeze
 
         @set    = Journey::Routes.new
         @router = Journey::Router.new @set
-        @formatter = Journey::Formatter.new @set
+        @formatter = Journey::Formatter.new self
+      end
+
+      def relative_url_root
+        @config.relative_url_root
       end
 
+      def api_only?
+        @config.api_only
+      end
+
+      def request_class
+        ActionDispatch::Request
+      end
+
+      def make_request(env)
+        request_class.new env
+      end
+      private :make_request
+
       def draw(&block)
         clear! unless @disable_clear_and_finalize
         eval_block(block)
@@ -421,10 +384,6 @@ module ActionDispatch
       end
 
       def eval_block(block)
-        if block.arity == 1
-          raise "You are using the old router DSL which has been removed in Rails 3.1. " <<
-            "Please check how to update your routes file at: http://www.engineyard.com/blog/2010/the-lowdown-on-routes-in-rails-3/"
-        end
         mapper = Mapper.new(self)
         if default_scope
           mapper.with_default_scope(default_scope, &block)
@@ -448,10 +407,6 @@ module ActionDispatch
         @prepend.each { |blk| eval_block(blk) }
       end
 
-      def dispatcher(defaults)
-        Routing::RouteSet::Dispatcher.new(defaults)
-      end
-
       module MountedHelpers
         extend ActiveSupport::Concern
         include UrlFor
@@ -495,7 +450,14 @@ module ActionDispatch
           # Rails.application.routes.url_helpers.url_for(args)
           @_routes = routes
           class << self
-            delegate :url_for, :optimize_routes_generation?, to: '@_routes'
+            def url_for(options)
+              @_routes.url_for(options)
+            end
+
+            def optimize_routes_generation?
+              @_routes.optimize_routes_generation?
+            end
+
             attr_reader :_routes
             def url_options; {}; end
           end
@@ -513,12 +475,10 @@ module ActionDispatch
 
           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
+            include path_helpers
+            extend path_helpers
+          end
 
           # plus a singleton class method called _routes ...
           included do
@@ -542,7 +502,7 @@ module ActionDispatch
         routes.empty?
       end
 
-      def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
+      def add_route(mapping, path_ast, name, anchor)
         raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
 
         if name && named_routes[name]
@@ -553,74 +513,32 @@ module ActionDispatch
             "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
         end
 
-        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)
+        route = @set.add_route(name, mapping)
         named_routes[name] = route if name
-        route
-      end
-
-      def build_path(path, ast, requirements, anchor)
-        strexp = Journey::Router::Strexp.new(
-            ast,
-            path,
-            requirements,
-            SEPARATORS,
-            anchor)
-
-        pattern = Journey::Path::Pattern.new(strexp)
 
-        builder = Journey::GTG::Builder.new pattern.spec
-
-        # Get all the symbol nodes followed by literals that are not the
-        # dummy node.
-        symbols = pattern.spec.grep(Journey::Nodes::Symbol).find_all { |n|
-          builder.followpos(n).first.literal?
-        }
-
-        # Get all the symbol nodes preceded by literals.
-        symbols.concat pattern.spec.find_all(&:literal?).map { |n|
-          builder.followpos(n).first
-        }.find_all(&:symbol?)
-
-        symbols.each { |x|
-          x.regexp = /(?:#{Regexp.union(x.regexp, '-')})+/
-        }
-
-        pattern
-      end
-      private :build_path
-
-      def build_conditions(current_conditions, path_values)
-        conditions = current_conditions.dup
-
-        # Rack-Mount requires that :request_method be a regular expression.
-        # :request_method represents the HTTP verb that matches this route.
-        #
-        # Here we munge values before they get sent on to rack-mount.
-        verbs = conditions[:request_method] || []
-        unless verbs.empty?
-          conditions[:request_method] = %r[^#{verbs.join('|')}$]
+        if route.segment_keys.include?(:controller)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Using a dynamic :controller segment in a route is deprecated and
+            will be removed in Rails 5.2.
+          MSG
         end
 
-        conditions.keep_if do |k, _|
-          k == :action || k == :controller || k == :required_defaults ||
-            @request_class.public_method_defined?(k) || path_values.include?(k)
+        if route.segment_keys.include?(:action)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Using a dynamic :action segment in a route is deprecated and
+            will be removed in Rails 5.2.
+          MSG
         end
+
+        route
       end
-      private :build_conditions
 
       class Generator
         PARAMETERIZE = lambda do |name, value|
           if name == :controller
             value
-          elsif value.is_a?(Array)
-            value.map { |v| v.to_param }.join('/')
-          elsif param = value.to_param
-            param
+          else
+            value.to_param
           end
         end
 
@@ -628,16 +546,14 @@ module ActionDispatch
 
         def initialize(named_route, options, recall, set)
           @named_route = named_route
-          @options     = options.dup
-          @recall      = recall.dup
+          @options     = options
+          @recall      = recall
           @set         = set
 
-          normalize_recall!
           normalize_options!
           normalize_controller_action_id!
           use_relative_controller!
           normalize_controller!
-          normalize_action!
         end
 
         def controller
@@ -651,16 +567,11 @@ module ActionDispatch
         def use_recall_for(key)
           if @recall[key] && (!@options.key?(key) || @options[key] == @recall[key])
             if !named_route_exists? || segment_keys.include?(key)
-              @options[key] = @recall.delete(key)
+              @options[key] = @recall[key]
             end
           end
         end
 
-        # Set 'index' as default action for recall
-        def normalize_recall!
-          @recall[:action] ||= 'index'
-        end
-
         def normalize_options!
           # If an explicit :controller was given, always make :action explicit
           # too, so that action expiry works as expected for things like
@@ -705,13 +616,12 @@ module ActionDispatch
 
         # Remove leading slashes from controllers
         def normalize_controller!
-          @options[:controller] = controller.sub(%r{^/}, '') if controller
-        end
-
-        # Move 'index' action from options to recall
-        def normalize_action!
-          if @options[:action] == 'index'
-            @recall[:action] = @options.delete(:action)
+          if controller
+            if controller.start_with?("/".freeze)
+              @options[:controller] = controller[1..-1]
+            else
+              @options[:controller] = controller
+            end
           end
         end
 
@@ -812,7 +722,7 @@ module ActionDispatch
       end
 
       def call(env)
-        req = request_class.new(env)
+        req = make_request(env)
         req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
         @router.serve(req)
       end
@@ -828,7 +738,7 @@ module ActionDispatch
           raise ActionController::RoutingError, e.message
         end
 
-        req = request_class.new(env)
+        req = make_request(env)
         @router.recognize(req) do |route, params|
           params.merge!(extras)
           params.each do |key, value|
@@ -837,18 +747,16 @@ module ActionDispatch
               params[key] = URI.parser.unescape(value)
             end
           end
-          old_params = req.path_parameters
-          req.path_parameters = old_params.merge params
+          req.path_parameters = params
           app = route.app
           if app.matches?(req) && app.dispatcher?
-            dispatcher = app.app
-
-            if dispatcher.controller(params, false)
-              dispatcher.prepare_params!(params)
-              return params
-            else
+            begin
+              req.controller_class
+            rescue NameError
               raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
             end
+
+            return req.path_parameters
           end
         end