actionpack 4.2.8 → 5.2.4.2

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -1,4 +1,4 @@
-require 'action_controller/model_naming'
+# frozen_string_literal: true
 
 module ActionDispatch
   module Routing
@@ -6,7 +6,7 @@ module ActionDispatch
     # given an Active Record model instance. They are to be used in combination with
     # ActionController::Resources.
     #
-    # These methods are useful when you want to generate correct URL or path to a RESTful
+    # These methods are useful when you want to generate the correct URL or path to a RESTful
     # resource without having to know the exact type of the record in question.
     #
     # Nested resources and/or namespaces are also supported, as illustrated in the example:
@@ -42,7 +42,7 @@ module ActionDispatch
     #
     # Example usage:
     #
-    #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
+    #   edit_polymorphic_path(@post)           # => "/posts/1/edit"
     #   polymorphic_path(@post, format: :pdf)  # => "/posts/1.pdf"
     #
     # == Usage with mounted engines
@@ -55,8 +55,6 @@ module ActionDispatch
     #   form_for([blog, @post])         # => "/blog/posts/1"
     #
     module PolymorphicRoutes
-      include ActionController::ModelNaming
-
       # Constructs a call to a named RESTful route for the given record and returns the
       # resulting URL string. For example:
       #
@@ -83,7 +81,7 @@ module ActionDispatch
       #   polymorphic_url([blog, post], anchor: 'my_anchor', script_name: "/my_app")
       #     # => "http://example.com/my_app/blogs/1/posts/1#my_anchor"
       #
-      # For all of these options, see the documentation for <tt>url_for</tt>.
+      # For all of these options, see the documentation for {url_for}[rdoc-ref:ActionDispatch::Routing::UrlFor].
       #
       # ==== Functionality
       #
@@ -107,6 +105,10 @@ module ActionDispatch
           return polymorphic_url record, options
         end
 
+        if mapping = polymorphic_mapping(record_or_hash_or_array)
+          return mapping.call(self, [record_or_hash_or_array, options], false)
+        end
+
         opts   = options.dup
         action = opts.delete :action
         type   = opts.delete(:routing_type) || :url
@@ -127,6 +129,10 @@ module ActionDispatch
           return polymorphic_path record, options
         end
 
+        if mapping = polymorphic_mapping(record_or_hash_or_array)
+          return mapping.call(self, [record_or_hash_or_array, options], true)
+        end
+
         opts   = options.dup
         action = opts.delete :action
         type   = :path
@@ -138,7 +144,6 @@ module ActionDispatch
                                                opts
       end
 
-
       %w(edit new).each do |action|
         module_eval <<-EOT, __FILE__, __LINE__ + 1
           def #{action}_polymorphic_url(record_or_hash, options = {})
@@ -153,178 +158,195 @@ module ActionDispatch
 
       private
 
-      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 }
+        def polymorphic_url_for_action(action, record_or_hash, options)
+          polymorphic_url(record_or_hash, options.merge(action: action))
         end
 
-        def self.url;  CACHE['url'.freeze][nil]; end
-        def self.path; CACHE['path'.freeze][nil]; end
+        def polymorphic_path_for_action(action, record_or_hash, options)
+          polymorphic_path(record_or_hash, options.merge(action: action))
+        end
 
-        def self.build(action, type)
-          prefix = action ? "#{action}_" : ""
-          suffix = type
-          if action.to_s == 'new'
-            HelperMethodBuilder.singular prefix, suffix
+        def polymorphic_mapping(record)
+          if record.respond_to?(:to_model)
+            _routes.polymorphic_mappings[record.to_model.model_name.name]
           else
-            HelperMethodBuilder.plural prefix, suffix
+            _routes.polymorphic_mappings[record.class.name]
           end
         end
 
-        def self.singular(prefix, suffix)
-          new(->(name) { name.singular_route_key }, prefix, suffix)
-        end
+        class HelperMethodBuilder # :nodoc:
+          CACHE = { "path" => {}, "url" => {} }
 
-        def self.plural(prefix, suffix)
-          new(->(name) { name.route_key }, prefix, suffix)
-        end
+          def self.get(action, type)
+            type = type.to_s
+            CACHE[type].fetch(action) { build action, type }
+          end
 
-        def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options)
-          builder = get action, type
+          def self.url;  CACHE["url".freeze][nil]; end
+          def self.path; CACHE["path".freeze][nil]; end
 
-          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
+          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
-
-            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
 
+          def self.singular(prefix, suffix)
+            new(->(name) { name.singular_route_key }, prefix, suffix)
+          end
 
-          if options.empty?
-            recipient.send(method, *args)
-          else
-            recipient.send(method, *args, options)
+          def self.plural(prefix, suffix)
+            new(->(name) { name.route_key }, prefix, suffix)
           end
-        end
 
-        attr_reader :suffix, :prefix
+          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
 
-        def initialize(key_strategy, prefix, suffix)
-          @key_strategy = key_strategy
-          @prefix       = prefix
-          @suffix       = suffix
-        end
+            when nil
+              raise ArgumentError, "Nil location provided. Can't build URI."
+            else
+              method, args = builder.handle_model record_or_hash_or_array
+            end
 
-        def handle_string(record)
-          [get_method_for_string(record), []]
-        end
+            if options.empty?
+              recipient.send(method, *args)
+            else
+              recipient.send(method, *args, options)
+            end
+          end
 
-        def handle_string_call(target, str)
-          target.send get_method_for_string str
-        end
+          attr_reader :suffix, :prefix
 
-        def handle_class(klass)
-          [get_method_for_class(klass), []]
-        end
+          def initialize(key_strategy, prefix, suffix)
+            @key_strategy = key_strategy
+            @prefix       = prefix
+            @suffix       = suffix
+          end
 
-        def handle_class_call(target, klass)
-          target.send get_method_for_class klass
-        end
+          def handle_string(record)
+            [get_method_for_string(record), []]
+          end
 
-        def handle_model(record)
-          args  = []
+          def handle_string_call(target, str)
+            target.send get_method_for_string str
+          end
 
-          model = record.to_model
-          name = if model.persisted?
-                   args << model
-                   model.model_name.singular_route_key
-                 else
-                   @key_strategy.call model.model_name
-                 end
+          def handle_class(klass)
+            [get_method_for_class(klass), []]
+          end
 
-          named_route = prefix + "#{name}_#{suffix}"
+          def handle_class_call(target, klass)
+            target.send get_method_for_class klass
+          end
 
-          [named_route, args]
-        end
+          def handle_model(record)
+            args  = []
 
-        def handle_model_call(target, model)
-          method, args = handle_model model
-          target.send(method, *args)
-        end
+            model = record.to_model
+            named_route = if model.persisted?
+              args << model
+              get_method_for_string model.model_name.singular_route_key
+            else
+              get_method_for_class model
+            end
 
-        def handle_list(list)
-          record_list = list.dup
-          record      = record_list.pop
+            [named_route, args]
+          end
 
-          args = []
+          def handle_model_call(target, record)
+            if mapping = polymorphic_mapping(target, record)
+              mapping.call(target, [record], suffix == "path")
+            else
+              method, args = handle_model(record)
+              target.send(method, *args)
+            end
+          end
 
-          route  = record_list.map { |parent|
-            case parent
+          def handle_list(list)
+            record_list = list.dup
+            record      = record_list.pop
+
+            args = []
+
+            route = record_list.map { |parent|
+              case parent
+              when Symbol, String
+                parent.to_s
+              when Class
+                args << parent
+                parent.model_name.singular_route_key
+              else
+                args << parent.to_model
+                parent.to_model.model_name.singular_route_key
+              end
+            }
+
+            route <<
+            case record
             when Symbol, String
-              parent.to_s
+              record.to_s
             when Class
-              args << parent
-              parent.model_name.singular_route_key
+              @key_strategy.call record.model_name
             else
-              args << parent.to_model
-              parent.to_model.model_name.singular_route_key
+              model = record.to_model
+              if model.persisted?
+                args << model
+                model.model_name.singular_route_key
+              else
+                @key_strategy.call model.model_name
+              end
             end
-          }
-
-          route <<
-          case record
-          when Symbol, String
-            record.to_s
-          when Class
-            @key_strategy.call record.model_name
-          else
-            model = record.to_model
-            if model.persisted?
-              args << model
-              model.model_name.singular_route_key
-            else
-              @key_strategy.call model.model_name
-            end
-          end
 
-          route << suffix
+            route << suffix
 
-          named_route = prefix + route.join("_")
-          [named_route, args]
-        end
+            named_route = prefix + route.join("_")
+            [named_route, args]
+          end
 
-        private
+          private
 
-        def get_method_for_class(klass)
-          name   = @key_strategy.call klass.model_name
-          prefix + "#{name}_#{suffix}"
-        end
+            def polymorphic_mapping(target, record)
+              if record.respond_to?(:to_model)
+                target._routes.polymorphic_mappings[record.to_model.model_name.name]
+              else
+                target._routes.polymorphic_mappings[record.class.name]
+              end
+            end
 
-        def get_method_for_string(str)
-          prefix + "#{str}_#{suffix}"
-        end
+            def get_method_for_class(klass)
+              name = @key_strategy.call klass.model_name
+              get_method_for_string name
+            end
 
-        [nil, 'new', 'edit'].each do |action|
-          CACHE['url'][action]  = build action, 'url'
-          CACHE['path'][action] = build action, 'path'
+            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
 end

data/lib/action_dispatch/routing/redirection.rb

@@ -1,9 +1,11 @@
-require 'action_dispatch/http/request'
-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'
+# frozen_string_literal: true
+
+require "action_dispatch/http/request"
+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
@@ -22,9 +24,8 @@ module ActionDispatch
       end
 
       def serve(req)
-        req.check_path_parameters!
         uri = URI.parse(path(req.path_parameters, req))
-        
+
         unless uri.host
           if relative_path?(uri.path)
             uri.path = "#{req.script_name}/#{uri.path}"
@@ -32,17 +33,19 @@ module ActionDispatch
             uri.path = req.script_name.empty? ? "/" : req.script_name
           end
         end
-          
+
         uri.scheme ||= req.scheme
         uri.host   ||= req.host
         uri.port   ||= req.port unless req.standard_port?
 
+        req.commit_flash
+
         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,
-          'Content-Type' => 'text/html',
-          'Content-Length' => body.length.to_s
+          "Location" => uri.to_s,
+          "Content-Type" => "text/html",
+          "Content-Length" => body.length.to_s
         }
 
         [ status, headers, [body] ]
@@ -58,19 +61,19 @@ module ActionDispatch
 
       private
         def relative_path?(path)
-          path && !path.empty? && path[0] != '/'
+          path && !path.empty? && path[0] != "/"
         end
 
         def escape(params)
-          Hash[params.map{ |k,v| [k, Rack::Utils.escape(v)] }]
+          Hash[params.map { |k, v| [k, Rack::Utils.escape(v)] }]
         end
 
         def escape_fragment(params)
-          Hash[params.map{ |k,v| [k, Journey::Router::Utils.escape_fragment(v)] }]
+          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_fragment(v)] }]
         end
 
         def escape_path(params)
-          Hash[params.map{ |k,v| [k, Journey::Router::Utils.escape_path(v)] }]
+          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_path(v)] }]
         end
     end
 
@@ -104,11 +107,11 @@ module ActionDispatch
 
       def path(params, request)
         url_options = {
-          :protocol => request.protocol,
-          :host     => request.host,
-          :port     => request.optional_port,
-          :path     => request.path,
-          :params   => request.query_parameters
+          protocol: request.protocol,
+          host: request.host,
+          port: request.optional_port,
+          path: request.path,
+          params: request.query_parameters
         }.merge! options
 
         if !params.empty? && url_options[:path].match(/%\{\w*\}/)
@@ -124,26 +127,28 @@ module ActionDispatch
             url_options[:script_name] = request.script_name
           end
         end
-        
+
         ActionDispatch::Http::URL.url_for url_options
       end
 
       def inspect
-        "redirect(#{status}, #{options.map{ |k,v| "#{k}: #{v}" }.join(', ')})"
+        "redirect(#{status}, #{options.map { |k, v| "#{k}: #{v}" }.join(', ')})"
       end
     end
 
     module Redirection
-
       # Redirect any path to another path:
       #
       #   get "/stories" => redirect("/posts")
       #
+      # This will redirect the user, while ignoring certain parts of the request, including query string, etc.
+      # <tt>/stories</tt>, <tt>/stories?foo=bar</tt>, etc all redirect to <tt>/posts</tt>.
+      #
       # You can also use interpolation in the supplied redirect argument:
       #
       #   get 'docs/:article', to: redirect('/wiki/%{article}')
       #
-      # Note that if you return a path without a leading slash then the url is prefixed with the
+      # Note that if you return a path without a leading slash then the URL is prefixed with the
       # current SCRIPT_NAME environment variable. This is typically '/' but may be different in
       # a mounted engine or where the application is deployed to a subdirectory of a website.
       #
@@ -162,11 +167,16 @@ module ActionDispatch
       # Note that the +do end+ syntax for the redirect block wouldn't work, as Ruby would pass
       # the block to +get+ instead of +redirect+. Use <tt>{ ... }</tt> instead.
       #
-      # The options version of redirect allows you to supply only the parts of the url which need
+      # The options version of redirect allows you to supply only the parts of the URL which need
       # to change, it also supports interpolation of the path similar to the first example.
       #
       #   get 'stores/:name',       to: redirect(subdomain: 'stores', path: '/%{name}')
       #   get 'stores/:name(*all)', to: redirect(subdomain: 'stores', path: '/%{name}%{all}')
+      #   get '/stories', to: redirect(path: '/posts')
+      #
+      # This will redirect the user, while changing only the specified parts of the request,
+      # for example the +path+ option in the last example.
+      # <tt>/stories</tt>, <tt>/stories?foo=bar</tt>, redirect to <tt>/posts</tt> and <tt>/posts?foo=bar</tt> respectively.
       #
       # Finally, an object which responds to call can be supplied to redirect, allowing you to reuse
       # common redirect routes. The call method must accept two arguments, params and request, and return