actionpack 3.0.0.beta4 → 3.0.0.rc

data/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -0,0 +1,186 @@
+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
+    # 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:
+    #
+    #   polymorphic_url([:admin, @article, @comment])
+    #
+    # results in:
+    #
+    #   admin_article_comment_url(@article, @comment)
+    #
+    # == Usage within the framework
+    #
+    # Polymorphic URL helpers are used in a number of places throughout the Rails framework:
+    #
+    # * <tt>url_for</tt>, so you can use it with a record as the argument, e.g.
+    #   <tt>url_for(@article)</tt>;
+    # * ActionView::Helpers::FormHelper uses <tt>polymorphic_path</tt>, so you can write
+    #   <tt>form_for(@article)</tt> without having to specify <tt>:url</tt> parameter for the form
+    #   action;
+    # * <tt>redirect_to</tt> (which, in fact, uses <tt>url_for</tt>) so you can write
+    #   <tt>redirect_to(post)</tt> in your controllers;
+    # * ActionView::Helpers::AtomFeedHelper, so you don't have to explicitly specify URLs
+    #   for feed entries.
+    #
+    # == 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>
+    # in options. Those are:
+    #
+    # * <tt>edit_polymorphic_url</tt>, <tt>edit_polymorphic_path</tt>
+    # * <tt>new_polymorphic_url</tt>, <tt>new_polymorphic_path</tt>
+    #
+    # Example usage:
+    #
+    #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
+    #   polymorphic_path(@post, :format => :pdf)  # => "/posts/1.pdf"
+    module PolymorphicRoutes
+      # Constructs a call to a named RESTful route for the given record and returns the
+      # resulting URL string. For example:
+      #
+      #   # calls post_url(post)
+      #   polymorphic_url(post) # => "http://example.com/posts/1"
+      #   polymorphic_url([blog, post]) # => "http://example.com/blogs/1/posts/1"
+      #   polymorphic_url([:admin, blog, post]) # => "http://example.com/admin/blogs/1/posts/1"
+      #   polymorphic_url([user, :blog, post]) # => "http://example.com/users/1/blog/posts/1"
+      #   polymorphic_url(Comment) # => "http://example.com/comments"
+      #
+      # ==== Options
+      #
+      # * <tt>:action</tt> - Specifies the action prefix for the named route:
+      #   <tt>:new</tt> or <tt>:edit</tt>. Default is no prefix.
+      # * <tt>:routing_type</tt> - Allowed values are <tt>:path</tt> or <tt>:url</tt>.
+      #   Default is <tt>:url</tt>.
+      #
+      # ==== Examples
+      #
+      #   # an Article record
+      #   polymorphic_url(record)  # same as article_url(record)
+      #
+      #   # a Comment record
+      #   polymorphic_url(record)  # same as comment_url(record)
+      #
+      #   # it recognizes new records and maps to the collection
+      #   record = Comment.new
+      #   polymorphic_url(record)  # same as comments_url()
+      #
+      #   # the class of a record will also map to the collection
+      #   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
+          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 = record.to_model if record.respond_to?(:to_model)
+
+        args = case record_or_hash_or_array
+          when Hash;  [ record_or_hash_or_array ]
+          when Array; record_or_hash_or_array.dup
+          else        [ record_or_hash_or_array ]
+        end
+
+        inflection = if 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
+
+        send(named_route, *args)
+      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))
+      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
+        EOT
+      end
+
+      private
+        def action_prefix(options)
+          options[:action] ? "#{options[:action]}_" : ''
+        end
+
+        def routing_type(options)
+          options[:routing_type] || :url
+        end
+
+        def build_named_route_call(records, inflection, options = {})
+          unless records.is_a?(Array)
+            record = extract_record(records)
+            route  = ''
+          else
+            record = records.pop
+            route = records.inject("") do |string, parent|
+              if parent.is_a?(Symbol) || parent.is_a?(String)
+                string << "#{parent}_"
+              else
+                string << ActiveModel::Naming.plural(parent).singularize
+                string << "_"
+              end
+            end
+          end
+
+          if record.is_a?(Symbol) || record.is_a?(String)
+            route << "#{record}_"
+          else
+            route << ActiveModel::Naming.plural(record)
+            route = route.singularize if inflection == :singular
+            route << "_"
+            route << "index_" if ActiveModel::Naming.uncountable?(record) && inflection == :plural
+          end
+
+          action_prefix(options) + route + routing_type(options).to_s
+        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
+        end
+    end
+  end
+end
+

data/lib/action_dispatch/routing/route.rb

@@ -2,9 +2,10 @@ module ActionDispatch
   module Routing
     class Route #:nodoc:
       attr_reader :app, :conditions, :defaults, :name
-      attr_reader :path, :requirements
+      attr_reader :path, :requirements, :set
 
-      def initialize(app, conditions, requirements, defaults, name, anchor)
+      def initialize(set, app, conditions, requirements, defaults, name, anchor)
+        @set = set
         @app = app
         @defaults = defaults
         @name = name
@@ -24,6 +25,9 @@ module ActionDispatch
           h[k] = Rack::Mount::RegexpWithNamedGroups.new(v)
           h
         }
+
+        @conditions.delete_if{ |k,v| k != :path_info && !valid_condition?(k) }
+        @requirements.delete_if{ |k,v| !valid_condition?(k) }
       end
 
       def verb
@@ -50,6 +54,11 @@ module ActionDispatch
           "%-6s %-40s %s" % [(verb || :any).to_s.upcase, path, requirements.inspect]
         end
       end
+
+      private
+        def valid_condition?(method)
+          segment_keys.include?(method) || set.valid_conditions.include?(method)
+        end
     end
   end
 end

data/lib/action_dispatch/routing/route_set.rb

@@ -24,7 +24,7 @@ module ActionDispatch
             return [404, {'X-Cascade' => 'pass'}, []]
           end
 
-          controller.action(params[:action]).call(env)
+          dispatch(controller, params[:action], env)
         end
 
         def prepare_params!(params)
@@ -32,29 +32,43 @@ module ActionDispatch
           split_glob_param!(params) if @glob_param
         end
 
-        def controller(params, raise_error=true)
+        # 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
+        # an 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]
-            unless controller = @controllers[controller_param]
-              controller_name = "#{controller_param.camelize}Controller"
-              controller = @controllers[controller_param] =
-                ActiveSupport::Dependencies.ref(controller_name)
-            end
-
-            controller.get
+            controller_reference(controller_param)
           end
         rescue NameError => e
-          raise ActionController::RoutingError, e.message, e.backtrace if raise_error
+          raise ActionController::RoutingError, e.message, e.backtrace if default_controller
         end
 
-        private
-          def merge_default_action!(params)
-            params[:action] ||= 'index'
-          end
+      private
 
-          def split_glob_param!(params)
-            params[@glob_param] = params[@glob_param].split('/').map { |v| URI.unescape(v) }
+        def controller_reference(controller_param)
+          unless controller = @controllers[controller_param]
+            controller_name = "#{controller_param.camelize}Controller"
+            controller = @controllers[controller_param] =
+              ActiveSupport::Dependencies.ref(controller_name)
           end
+          controller.get
+        end
+
+        def dispatch(controller, action, env)
+          controller.action(action).call(env)
+        end
+
+        def merge_default_action!(params)
+          params[:action] ||= 'index'
+        end
+
+        def split_glob_param!(params)
+          params[@glob_param] = params[@glob_param].split('/').map { |v| URI.unescape(v) }
+        end
       end
 
       # A NamedRouteCollection instance is a collection of named routes, and also
@@ -185,9 +199,9 @@ module ActionDispatch
           end
       end
 
-      attr_accessor :routes, :named_routes
+      attr_accessor :set, :routes, :named_routes
       attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options, :request_class
+      attr_accessor :default_url_options, :request_class, :valid_conditions
 
       def self.default_resources_path_names
         { :new => 'new', :edit => 'edit' }
@@ -199,7 +213,11 @@ module ActionDispatch
         self.resources_path_names = self.class.default_resources_path_names.dup
         self.controller_namespaces = Set.new
         self.default_url_options = {}
+
         self.request_class = request_class
+        self.valid_conditions = request_class.public_instance_methods.map { |m| m.to_sym }
+        self.valid_conditions.delete(:id)
+        self.valid_conditions.push(:controller, :action)
 
         @disable_clear_and_finalize = false
         clear!
@@ -262,10 +280,10 @@ module ActionDispatch
             # Yes plz - JP
             included do
               routes.install_helpers(self)
-              singleton_class.send(:define_method, :_router) { routes }
+              singleton_class.send(:define_method, :_routes) { routes }
             end
 
-            define_method(:_router) { routes }
+            define_method(:_routes) { routes }
           end
 
           helpers
@@ -277,7 +295,7 @@ module ActionDispatch
       end
 
       def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
-        route = Route.new(app, conditions, requirements, defaults, name, anchor)
+        route = Route.new(self, app, conditions, requirements, defaults, name, anchor)
         @set.add_route(*route)
         named_routes[name] = route if name
         routes << route
@@ -312,7 +330,11 @@ module ActionDispatch
 
         def use_recall_for(key)
           if @recall[key] && (!@options.key?(key) || @options[key] == @recall[key])
-            @options[key] = @recall.delete(key)
+            if named_route_exists?
+              @options[key] = @recall.delete(key) if segment_keys.include?(key)
+            else
+              @options[key] = @recall.delete(key)
+            end
           end
         end
 
@@ -371,7 +393,7 @@ module ActionDispatch
 
         def generate
           error = ActionController::RoutingError.new("No route matches #{options.inspect}")
-          path, params = @set.generate(:path_info, named_route, options, recall, opts)
+          path, params = @set.set.generate(:path_info, named_route, options, recall, opts)
 
           raise error unless path
 
@@ -392,7 +414,8 @@ module ActionDispatch
             elsif value.is_a?(Array)
               value.map { |v| Rack::Mount::Utils.escape_uri(v.to_param) }.join('/')
             else
-              Rack::Mount::Utils.escape_uri(value.to_param)
+              return nil unless param = value.to_param
+              param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
             end
           end
           {:parameterize => parameterize}
@@ -402,6 +425,15 @@ module ActionDispatch
           return false unless current_controller
           controller.to_param != current_controller.to_param
         end
+
+        private
+          def named_route_exists?
+            named_route && set.named_routes[named_route]
+          end
+
+          def segment_keys
+            set.named_routes[named_route].segment_keys
+          end
       end
 
       # Generate the path indicated by the arguments, and return an array of
@@ -415,14 +447,14 @@ module ActionDispatch
       end
 
       def generate(options, recall = {}, extras = false)
-        Generator.new(options, recall, @set, extras).generate
+        Generator.new(options, recall, self, extras).generate
       end
 
       RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :port, :trailing_slash]
 
       def url_for(options)
         finalize!
-        options = default_url_options.merge(options || {})
+        options = (options || {}).reverse_merge!(default_url_options)
 
         handle_positional_args(options)
 
@@ -445,9 +477,9 @@ module ActionDispatch
         path_options = yield(path_options) if block_given?
         path = generate(path_options, path_segments || {})
 
-        # ROUTES TODO: This can be called directly, so script_name should probably be set in the router
+        # ROUTES TODO: This can be called directly, so script_name should probably be set in the routes
         rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
-        rewritten_url << "##{Rack::Utils.escape(options[:anchor].to_param.to_s)}" if options[:anchor]
+        rewritten_url << "##{Rack::Mount::Utils.escape_uri(options[:anchor].to_param.to_s)}" if options[:anchor]
 
         rewritten_url
       end
@@ -477,6 +509,8 @@ module ActionDispatch
           end
 
           dispatcher = route.app
+          dispatcher = dispatcher.app while dispatcher.is_a?(Mapper::Constraints)
+
           if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
             dispatcher.prepare_params!(params)
             return params

data/lib/action_dispatch/routing/url_for.rb

@@ -82,6 +82,7 @@ module ActionDispatch
     #
     module UrlFor
       extend ActiveSupport::Concern
+      include PolymorphicRoutes
 
       included do
         # TODO: with_routing extends @controller with url_helpers, trickling down to including this module which overrides its default_url_options
@@ -128,7 +129,7 @@ module ActionDispatch
         when String
           options
         when nil, Hash
-          _router.url_for(url_options.merge((options || {}).symbolize_keys))
+          _routes.url_for((options || {}).reverse_merge!(url_options).symbolize_keys)
         else
           polymorphic_url(options)
         end

data/lib/action_dispatch/testing/assertions.rb

@@ -1,7 +1,6 @@
 module ActionDispatch
   module Assertions
     autoload :DomAssertions, 'action_dispatch/testing/assertions/dom'
-    autoload :ModelAssertions, 'action_dispatch/testing/assertions/model'
     autoload :ResponseAssertions, 'action_dispatch/testing/assertions/response'
     autoload :RoutingAssertions, 'action_dispatch/testing/assertions/routing'
     autoload :SelectorAssertions, 'action_dispatch/testing/assertions/selector'
@@ -11,7 +10,6 @@ module ActionDispatch
 
     included do
       include DomAssertions
-      include ModelAssertions
       include ResponseAssertions
       include RoutingAssertions
       include SelectorAssertions

data/lib/action_dispatch/testing/assertions/routing.rb

@@ -53,7 +53,6 @@ module ActionDispatch
         extras.each_key { |key| expected_options.delete key } unless extras.nil?
 
         expected_options.stringify_keys!
-        routing_diff = expected_options.diff(request.path_parameters)
         msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
             request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
         assert_block(msg) { request.path_parameters == expected_options }