actionpack 4.0.1 → 4.2.11.1

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -74,6 +74,19 @@ module ActionDispatch
       # * <tt>:routing_type</tt> - Allowed values are <tt>:path</tt> or <tt>:url</tt>.
       #   Default is <tt>:url</tt>.
       #
+      # 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 <tt>url_for</tt>.
+      #
+      # ==== Functionality
+      #
       #   # an Article record
       #   polymorphic_url(record)  # same as article_url(record)
       #
@@ -88,118 +101,230 @@ module ActionDispatch
       #   polymorphic_url(Comment) # same as comments_url()
       #
       def polymorphic_url(record_or_hash_or_array, options = {})
-        if record_or_hash_or_array.kind_of?(Array)
-          record_or_hash_or_array = record_or_hash_or_array.compact
-          if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
-            proxy = record_or_hash_or_array.shift
-          end
-          record_or_hash_or_array = record_or_hash_or_array[0] if record_or_hash_or_array.size == 1
+        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)
+        opts   = options.dup
+        action = opts.delete :action
+        type   = opts.delete(:routing_type) || :url
 
-        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
-        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)
-
-        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 routing_type(options)
-          options[:routing_type] || :url
+        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 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.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
-            record = extract_record(records)
-            route  = []
+            method, args = builder.handle_model record_or_hash_or_array
           end
 
-          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
+
+          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
+
+        def handle_string_call(target, str)
+          target.send get_method_for_string str
+        end
+
+        def handle_class(klass)
+          [get_method_for_class(klass), []]
+        end
+
+        def handle_class_call(target, klass)
+          target.send get_method_for_class klass
+        end
+
+        def handle_model(record)
+          args  = []
+
+          model = record.to_model
+          name = if model.persisted?
+                   args << model
+                   model.model_name.singular_route_key
+                 else
+                   @key_strategy.call model.model_name
+                 end
+
+          named_route = prefix + "#{name}_#{suffix}"
+
+          [named_route, args]
+        end
+
+        def handle_model_call(target, model)
+          method, args = handle_model model
+          target.send(method, *args)
+        end
+
+        def handle_list(list)
+          record_list = list.dup
+          record      = record_list.pop
+
+          args = []
+
+          route  = record_list.map { |parent|
+            case parent
+            when Symbol, String
+              parent.to_s
+            when Class
+              args << parent
+              parent.model_name.singular_route_key
             else
-              route << model_name_from_record_or_class(record).route_key
+              args << parent.to_model
+              parent.to_model.model_name.singular_route_key
             end
+          }
+
+          route <<
+          case record
+          when Symbol, String
+            record.to_s
+          when Class
+            @key_strategy.call record.model_name
           else
-            raise ArgumentError, "Nil location provided. Can't build URI."
+            model = record.to_model
+            if model.persisted?
+              args << model
+              model.model_name.singular_route_key
+            else
+              @key_strategy.call model.model_name
+            end
           end
 
-          route << routing_type(options)
+          route << suffix
 
-          action_prefix(options) + route.join("_")
+          named_route = prefix + route.join("_")
+          [named_route, args]
         end
 
-        def extract_record(record_or_hash_or_array)
-          case record_or_hash_or_array
-            when Array; record_or_hash_or_array.last
-            when Hash;  record_or_hash_or_array[:id]
-            else        record_or_hash_or_array
-          end
+        private
+
+        def get_method_for_class(klass)
+          name   = @key_strategy.call klass.model_name
+          prefix + "#{name}_#{suffix}"
+        end
+
+        def get_method_for_string(str)
+          prefix + "#{str}_#{suffix}"
         end
+
+        [nil, 'new', 'edit'].each do |action|
+          CACHE['url'][action]  = build action, 'url'
+          CACHE['path'][action] = build action, 'path'
+        end
+      end
     end
   end
 end
-

data/lib/action_dispatch/routing/redirection.rb

@@ -3,10 +3,11 @@ require 'active_support/core_ext/uri'
 require 'active_support/core_ext/array/extract_options'
 require 'rack/utils'
 require 'action_controller/metal/exceptions'
+require 'action_dispatch/routing/endpoint'
 
 module ActionDispatch
   module Routing
-    class Redirect # :nodoc:
+    class Redirect < Endpoint # :nodoc:
       attr_reader :status, :block
 
       def initialize(status, block)
@@ -14,27 +15,29 @@ module ActionDispatch
         @block  = block
       end
 
+      def redirect?; true; end
+
       def call(env)
-        req = Request.new(env)
+        serve Request.new env
+      end
 
-        # If any of the path parameters has a 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}"
+      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}"
+          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?
 
-        if relative_path?(uri.path)
-          uri.path = "#{req.script_name}/#{uri.path}"
-        end
-
-        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,
@@ -57,11 +60,33 @@ module ActionDispatch
         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)
-        (params.empty? || !block.match(/%\{\w*\}/)) ? block : (block % escape(params))
+        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
@@ -69,8 +94,8 @@ module ActionDispatch
       end
 
       private
-        def escape(params)
-          Hash[params.map{ |k,v| [k, Rack::Utils.escape(v)] }]
+        def interpolation_required?(string, params)
+          !params.empty? && string && string.match(/%\{\w*\}/)
         end
     end
 
@@ -90,22 +115,22 @@ module ActionDispatch
           url_options[:path] = (url_options[:path] % escape_path(params))
         end
 
-        if relative_path?(url_options[:path])
-          url_options[:path] = "/#{url_options[:path]}"
-          url_options[:script_name] = request.script_name
+        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
 
       def inspect
         "redirect(#{status}, #{options.map{ |k,v| "#{k}: #{v}" }.join(', ')})"
       end
-
-      private
-        def escape_path(params)
-          Hash[params.map{ |k,v| [k, URI.parser.escape(v)] }]
-        end
     end
 
     module Redirection