actionpack 3.2.22.5 → 5.2.4

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   module Routing
     # Polymorphic URL helpers are methods for smart resolution to a named route call when
     # 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:
@@ -32,7 +34,7 @@ module ActionDispatch
     # == Prefixed polymorphic helpers
     #
     # In addition to <tt>polymorphic_url</tt> and <tt>polymorphic_path</tt> methods, a
-    # number of prefixed helpers are available as a shorthand to <tt>:action => "..."</tt>
+    # number of prefixed helpers are available as a shorthand to <tt>action: "..."</tt>
     # in options. Those are:
     #
     # * <tt>edit_polymorphic_url</tt>, <tt>edit_polymorphic_path</tt>
@@ -40,19 +42,17 @@ module ActionDispatch
     #
     # Example usage:
     #
-    #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
-    #   polymorphic_path(@post, :format => :pdf)  # => "/posts/1.pdf"
-    #
-    # == Using with mounted engines
+    #   edit_polymorphic_path(@post)           # => "/posts/1/edit"
+    #   polymorphic_path(@post, format: :pdf)  # => "/posts/1.pdf"
     #
-    # If you use mounted engine, there is a possibility that you will need to use
-    # polymorphic_url pointing at engine's routes. To do that, just pass proxy used
-    # to reach engine's routes as a first argument:
+    # == Usage with mounted engines
     #
-    # For example:
+    # If you are using a mounted engine and you need to use a polymorphic_url
+    # pointing at the engine's routes, pass in the engine's route proxy as the first
+    # argument to the method. For example:
     #
-    # polymorphic_url([blog, @post])  # it will call blog.post_path(@post)
-    # form_for([blog, @post])         # => "/blog/posts/1
+    #   polymorphic_url([blog, @post])  # calls blog.post_path(@post)
+    #   form_for([blog, @post])         # => "/blog/posts/1"
     #
     module PolymorphicRoutes
       # Constructs a call to a named RESTful route for the given record and returns the
@@ -72,7 +72,18 @@ module ActionDispatch
       # * <tt>:routing_type</tt> - Allowed values are <tt>:path</tt> or <tt>:url</tt>.
       #   Default is <tt>:url</tt>.
       #
-      # ==== Examples
+      # Also includes all the options from <tt>url_for</tt>. These include such
+      # things as <tt>:anchor</tt> or <tt>:trailing_slash</tt>. Example usage
+      # is given below:
+      #
+      #   polymorphic_url([blog, post], anchor: 'my_anchor')
+      #     # => "http://example.com/blogs/1/posts/1#my_anchor"
+      #   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 {url_for}[rdoc-ref:ActionDispatch::Routing::UrlFor].
+      #
+      # ==== Functionality
       #
       #   # an Article record
       #   polymorphic_url(record)  # same as article_url(record)
@@ -88,122 +99,254 @@ 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
+        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
 
-        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 mapping = polymorphic_mapping(record_or_hash_or_array)
+          return mapping.call(self, [record_or_hash_or_array, options], false)
         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>.
+      # <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
+
+        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
+
+        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 convert_to_model(object)
-          object.respond_to?(:to_model) ? object.to_model : object
+        def polymorphic_path_for_action(action, record_or_hash, options)
+          polymorphic_path(record_or_hash, options.merge(action: action))
         end
 
-        def routing_type(options)
-          options[:routing_type] || :url
+        def polymorphic_mapping(record)
+          if record.respond_to?(:to_model)
+            _routes.polymorphic_mappings[record.to_model.model_name.name]
+          else
+            _routes.polymorphic_mappings[record.class.name]
+          end
         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
-                ActiveModel::Naming.singular_route_key(parent)
+        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 self.plural(prefix, suffix)
+            new(->(name) { name.route_key }, prefix, suffix)
+          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
-          else
-            record = extract_record(records)
-            route  = []
+
+            if options.empty?
+              recipient.send(method, *args)
+            else
+              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
 
-          if record.is_a?(Symbol) || record.is_a?(String)
-            route << record
-          elsif record
-            if inflection == :singular
-              route << ActiveModel::Naming.singular_route_key(record)
+          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
+            named_route = if model.persisted?
+              args << model
+              get_method_for_string model.model_name.singular_route_key
             else
-              route << ActiveModel::Naming.route_key(record)
+              get_method_for_class model
+            end
+
+            [named_route, args]
+          end
+
+          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
-          else
-            raise ArgumentError, "Nil location provided. Can't build URI."
           end
 
-          route << routing_type(options)
+          def handle_list(list)
+            record_list = list.dup
+            record      = record_list.pop
 
-          action_prefix(options) + route.join("_")
-        end
+            args = []
 
-        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
+            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
+              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
+
+            named_route = prefix + route.join("_")
+            [named_route, args]
           end
+
+          private
+
+            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_class(klass)
+              name = @key_strategy.call klass.model_name
+              get_method_for_string name
+            end
+
+            def get_method_for_string(str)
+              "#{prefix}#{str}_#{suffix}"
+            end
+
+            [nil, "new", "edit"].each do |action|
+              CACHE["url"][action]  = build action, "url"
+              CACHE["path"][action] = build action, "path"
+            end
         end
     end
   end
 end
-

data/lib/action_dispatch/routing/redirection.rb

@@ -1,10 +1,15 @@
-require 'action_dispatch/http/request'
-require 'active_support/core_ext/uri'
-require 'rack/utils'
+# 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
-    class Redirect # :nodoc:
+    class Redirect < Endpoint # :nodoc:
       attr_reader :status, :block
 
       def initialize(status, block)
@@ -12,20 +17,35 @@ module ActionDispatch
         @block  = block
       end
 
+      def redirect?; true; end
+
       def call(env)
-        req = Request.new(env)
+        serve Request.new env
+      end
+
+      def serve(req)
+        uri = URI.parse(path(req.path_parameters, req))
+
+        unless uri.host
+          if relative_path?(uri.path)
+            uri.path = "#{req.script_name}/#{uri.path}"
+          elsif uri.path.empty?
+            uri.path = req.script_name.empty? ? "/" : req.script_name
+          end
+        end
 
-        uri = URI.parse(path(req.symbolized_path_parameters, req))
         uri.scheme ||= req.scheme
         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>)
+        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] ]
@@ -34,6 +54,52 @@ module ActionDispatch
       def path(params, request)
         block.call params, request
       end
+
+      def inspect
+        "redirect(#{status})"
+      end
+
+      private
+        def relative_path?(path)
+          path && !path.empty? && path[0] != "/"
+        end
+
+        def escape(params)
+          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)] }]
+        end
+
+        def escape_path(params)
+          Hash[params.map { |k, v| [k, Journey::Router::Utils.escape_path(v)] }]
+        end
+    end
+
+    class PathRedirect < Redirect
+      URL_PARTS = /\A([^?]+)?(\?[^#]+)?(#.+)?\z/
+
+      def path(params, request)
+        if block.match(URL_PARTS)
+          path     = interpolation_required?($1, params) ? $1 % escape_path(params)     : $1
+          query    = interpolation_required?($2, params) ? $2 % escape(params)          : $2
+          fragment = interpolation_required?($3, params) ? $3 % escape_fragment(params) : $3
+
+          "#{path}#{query}#{fragment}"
+        else
+          interpolation_required?(block, params) ? block % escape(params) : block
+        end
+      end
+
+      def inspect
+        "redirect(#{status}, #{block})"
+      end
+
+      private
+        def interpolation_required?(string, params)
+          !params.empty? && string && string.match(/%\{\w*\}/)
+        end
     end
 
     class OptionRedirect < Redirect # :nodoc:
@@ -41,35 +107,50 @@ 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
-        }.merge options
+          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*\}/)
           url_options[:path] = (url_options[:path] % escape_path(params))
         end
 
+        unless options[:host] || options[:domain]
+          if relative_path?(url_options[:path])
+            url_options[:path] = "/#{url_options[:path]}"
+            url_options[:script_name] = request.script_name
+          elsif url_options[:path].empty?
+            url_options[:path] = request.script_name.empty? ? "/" : ""
+            url_options[:script_name] = request.script_name
+          end
+        end
+
         ActionDispatch::Http::URL.url_for url_options
       end
 
-      private
-        def escape_path(params)
-          Hash[params.map{ |k,v| [k, URI.parser.escape(v)] }]
-        end
+      def inspect
+        "redirect(#{status}, #{options.map { |k, v| "#{k}: #{v}" }.join(', ')})"
+      end
     end
 
     module Redirection
-
       # Redirect any path to another path:
       #
-      #   match "/stories" => redirect("/posts")
+      #   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:
       #
-      #   match 'docs/:article', :to => redirect('/wiki/%{article}')
+      #   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
+      # 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.
       #
       # Alternatively you can use one of the other syntaxes:
       #
@@ -78,54 +159,43 @@ module ActionDispatch
       # params, depending of how many arguments your block accepts. A string is required as a
       # return value.
       #
-      #   match 'jokes/:number', :to => redirect { |params, request|
+      #   get 'jokes/:number', to: redirect { |params, request|
       #     path = (params[:number].to_i.even? ? "wheres-the-beef" : "i-love-lamp")
       #     "http://#{request.host_with_port}/#{path}"
       #   }
       #
-      # The options version of redirect allows you to supply only the parts of the url which need
+      # 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
       # to change, it also supports interpolation of the path similar to the first example.
       #
-      #   match 'stores/:name',       :to => redirect(:subdomain => 'stores', :path => '/%{name}')
-      #   match 'stores/:name(*all)', :to => redirect(:subdomain => 'stores', :path => '/%{name}%{all}')
+      #   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
       # a string.
       #
-      #   match 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
+      #   get 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
       #
       def redirect(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
+        options = args.extract_options!
         status  = options.delete(:status) || 301
+        path    = args.shift
 
         return OptionRedirect.new(status, options) if options.any?
-
-        path = args.shift
-
-        block = lambda { |params, request|
-          (params.empty? || !path.match(/%\{\w*\}/)) ? path : (path % escape(params))
-        } if String === path
+        return PathRedirect.new(status, path) if String === path
 
         block = path if path.respond_to? :call
-
-        # :FIXME: remove in Rails 4.0
-        if block && block.respond_to?(:arity) && block.arity < 2
-          msg = "redirect blocks with arity of #{block.arity} are deprecated. Your block must take 2 parameters: the environment, and a request object"
-          ActiveSupport::Deprecation.warn msg
-          deprecated_block = block
-          block = lambda { |params, _| deprecated_block.call(params) }
-        end
-
         raise ArgumentError, "redirection argument not supported" unless block
-
         Redirect.new status, block
       end
-
-      private
-        def escape(params)
-          Hash[params.map{ |k,v| [k, Rack::Utils.escape(v)] }]
-        end
     end
   end
 end