actionpack 3.0.0.beta4 → 3.0.0.rc

data/lib/action_dispatch/routing/deprecated_mapper.rb

@@ -19,70 +19,22 @@ module ActionDispatch
 
       def in_memory_controller_namespaces
         namespaces = Set.new
-        ActionController::Base.subclasses.each do |klass|
-          controller_name = klass.underscore
-          namespaces << controller_name.split('/')[0...-1].join('/')
+        ActionController::Base.descendants.each do |klass|
+          next if klass.anonymous?
+          namespaces << klass.name.underscore.split('/')[0...-1].join('/')
         end
         namespaces.delete('')
         namespaces
       end
     end
 
-    # Mapper instances are used to build routes. The object passed to the draw
-    # block in config/routes.rb is a Mapper instance.
-    #
-    # Mapper instances have relatively few instance methods, in order to avoid
-    # clashes with named routes.
-    #
-    # == Overview
-    #
-    # ActionController::Resources are a way of defining RESTful \resources.  A RESTful \resource, in basic terms,
-    # is something that can be pointed at and it will respond with a representation of the data requested.
-    # In real terms this could mean a user with a browser requests an HTML page, or that a desktop application
-    # requests XML data.
-    #
-    # RESTful design is based on the assumption that there are four generic verbs that a user of an
-    # application can request from a \resource (the noun).
-    #
-    # \Resources can be requested using four basic HTTP verbs (GET, POST, PUT, DELETE), the method used
-    # denotes the type of action that should take place.
-    #
-    # === The Different Methods and their Usage
-    #
-    # * GET    - Requests for a \resource, no saving or editing of a \resource should occur in a GET request.
-    # * POST   - Creation of \resources.
-    # * PUT    - Editing of attributes on a \resource.
-    # * DELETE - Deletion of a \resource.
-    #
-    # === Examples
-    #
-    #   # A GET request on the Posts resource is asking for all Posts
-    #   GET /posts
-    #
-    #   # A GET request on a single Post resource is asking for that particular Post
-    #   GET /posts/1
-    #
-    #   # A POST request on the Posts resource is asking for a Post to be created with the supplied details
-    #   POST /posts # with => { :post => { :title => "My Whizzy New Post", :body => "I've got a brand new combine harvester" } }
-    #
-    #   # A PUT request on a single Post resource is asking for a Post to be updated
-    #   PUT /posts # with => { :id => 1, :post => { :title => "Changed Whizzy Title" } }
-    #
-    #   # A DELETE request on a single Post resource is asking for it to be deleted
-    #   DELETE /posts # with => { :id => 1 }
-    #
-    # By using the REST convention, users of our application can assume certain things about how the data
-    # is requested and how it is returned.  Rails simplifies the routing part of RESTful design by
-    # supplying you with methods to create them in your routes.rb file.
-    #
-    # Read more about REST at http://en.wikipedia.org/wiki/Representational_State_Transfer
     class DeprecatedMapper #:nodoc:
       def initialize(set) #:nodoc:
+        ActiveSupport::Deprecation.warn "You are using the old router DSL which will be 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/"
         @set = set
       end
 
-      # Create an unnamed route with the provided +path+ and +options+. See
-      # ActionDispatch::Routing for an introduction to routes.
       def connect(path, options = {})
         options = options.dup
 
@@ -240,17 +192,6 @@ module ActionDispatch
         connect(path, options)
       end
 
-      # Enables the use of resources in a module by setting the name_prefix, path_prefix, and namespace for the model.
-      # Example:
-      #
-      #   map.namespace(:admin) do |admin|
-      #     admin.resources :products,
-      #       :has_many => [ :tags, :images, :variants ]
-      #   end
-      #
-      # This will create +admin_products_url+ pointing to "admin/products", which will look for an Admin::ProductsController.
-      # It'll also create +admin_product_tags_url+ pointing to "admin/products/#{product_id}/tags", which will look for
-      # Admin::TagsController.
       def namespace(name, options = {}, &block)
         if options[:namespace]
           with_options({:path_prefix => "#{options.delete(:path_prefix)}/#{name}", :name_prefix => "#{options.delete(:name_prefix)}#{name}_", :namespace => "#{options.delete(:namespace)}#{name}/" }.merge(options), &block)
@@ -411,334 +352,11 @@ module ActionDispatch
         alias_method :nesting_path_prefix, :path
       end
 
-      # Creates named routes for implementing verb-oriented controllers
-      # for a collection \resource.
-      #
-      # For example:
-      #
-      #   map.resources :messages
-      #
-      # will map the following actions in the corresponding controller:
-      #
-      #   class MessagesController < ActionController::Base
-      #     # GET messages_url
-      #     def index
-      #       # return all messages
-      #     end
-      #
-      #     # GET new_message_url
-      #     def new
-      #       # return an HTML form for describing a new message
-      #     end
-      #
-      #     # POST messages_url
-      #     def create
-      #       # create a new message
-      #     end
-      #
-      #     # GET message_url(:id => 1)
-      #     def show
-      #       # find and return a specific message
-      #     end
-      #
-      #     # GET edit_message_url(:id => 1)
-      #     def edit
-      #       # return an HTML form for editing a specific message
-      #     end
-      #
-      #     # PUT message_url(:id => 1)
-      #     def update
-      #       # find and update a specific message
-      #     end
-      #
-      #     # DELETE message_url(:id => 1)
-      #     def destroy
-      #       # delete a specific message
-      #     end
-      #   end
-      #
-      # Along with the routes themselves, +resources+ generates named routes for use in
-      # controllers and views. <tt>map.resources :messages</tt> produces the following named routes and helpers:
-      #
-      #   Named Route   Helpers
-      #   ============  =====================================================
-      #   messages      messages_url, hash_for_messages_url,
-      #                 messages_path, hash_for_messages_path
-      #
-      #   message       message_url(id), hash_for_message_url(id),
-      #                 message_path(id), hash_for_message_path(id)
-      #
-      #   new_message   new_message_url, hash_for_new_message_url,
-      #                 new_message_path, hash_for_new_message_path
-      #
-      #   edit_message  edit_message_url(id), hash_for_edit_message_url(id),
-      #                 edit_message_path(id), hash_for_edit_message_path(id)
-      #
-      # You can use these helpers instead of +url_for+ or methods that take +url_for+ parameters. For example:
-      #
-      #   redirect_to :controller => 'messages', :action => 'index'
-      #   # and
-      #   <%= link_to "edit this message", :controller => 'messages', :action => 'edit', :id => @message.id %>
-      #
-      # now become:
-      #
-      #   redirect_to messages_url
-      #   # and
-      #   <%= link_to "edit this message", edit_message_url(@message) # calls @message.id automatically
-      #
-      # Since web browsers don't support the PUT and DELETE verbs, you will need to add a parameter '_method' to your
-      # form tags. The form helpers make this a little easier. For an update form with a <tt>@message</tt> object:
-      #
-      #   <%= form_tag message_path(@message), :method => :put %>
-      #
-      # or
-      #
-      #   <% form_for :message, @message, :url => message_path(@message), :html => {:method => :put} do |f| %>
-      #
-      # or
-      #
-      #   <% form_for @message do |f| %>
-      #
-      # which takes into account whether <tt>@message</tt> is a new record or not and generates the
-      # path and method accordingly.
-      #
-      # The +resources+ method accepts the following options to customize the resulting routes:
-      # * <tt>:collection</tt> - Add named routes for other actions that operate on the collection.
-      #   Takes a hash of <tt>#{action} => #{method}</tt>, where method is <tt>:get</tt>/<tt>:post</tt>/<tt>:put</tt>/<tt>:delete</tt>,
-      #   an array of any of the previous, or <tt>:any</tt> if the method does not matter.
-      #   These routes map to a URL like /messages/rss, with a route of +rss_messages_url+.
-      # * <tt>:member</tt> - Same as <tt>:collection</tt>, but for actions that operate on a specific member.
-      # * <tt>:new</tt> - Same as <tt>:collection</tt>, but for actions that operate on the new \resource action.
-      # * <tt>:controller</tt> - Specify the controller name for the routes.
-      # * <tt>:singular</tt> - Specify the singular name used in the member routes.
-      # * <tt>:requirements</tt> - Set custom routing parameter requirements; this is a hash of either
-      #     regular expressions (which must match for the route to match) or extra parameters. For example:
-      #
-      #       map.resource :profile, :path_prefix => ':name', :requirements => { :name => /[a-zA-Z]+/, :extra => 'value' }
-      #
-      #     will only match if the first part is alphabetic, and will pass the parameter :extra to the controller.
-      # * <tt>:conditions</tt> - Specify custom routing recognition conditions.  \Resources sets the <tt>:method</tt> value for the method-specific routes.
-      # * <tt>:as</tt> - Specify a different \resource name to use in the URL path. For example:
-      #     # products_path == '/productos'
-      #     map.resources :products, :as => 'productos' do |product|
-      #       # product_reviews_path(product) == '/productos/1234/comentarios'
-      #       product.resources :product_reviews, :as => 'comentarios'
-      #     end
-      #
-      # * <tt>:has_one</tt> - Specify nested \resources, this is a shorthand for mapping singleton \resources beneath the current.
-      # * <tt>:has_many</tt> - Same has <tt>:has_one</tt>, but for plural \resources.
-      #
-      #   You may directly specify the routing association with +has_one+ and +has_many+ like:
-      #
-      #     map.resources :notes, :has_one => :author, :has_many => [:comments, :attachments]
-      #
-      #   This is the same as:
-      #
-      #     map.resources :notes do |notes|
-      #       notes.resource  :author
-      #       notes.resources :comments
-      #       notes.resources :attachments
-      #     end
-      #
-      # * <tt>:path_names</tt> - Specify different path names for the actions. For example:
-      #     # new_products_path == '/productos/nuevo'
-      #     # bids_product_path(1) == '/productos/1/licitacoes'
-      #     map.resources :products, :as => 'productos', :member => { :bids => :get }, :path_names => { :new => 'nuevo', :bids => 'licitacoes' }
-      #
-      #   You can also set default action names from an environment, like this:
-      #     config.action_controller.resources_path_names = { :new => 'nuevo', :edit => 'editar' }
-      #
-      # * <tt>:path_prefix</tt> - Set a prefix to the routes with required route variables.
-      #
-      #   Weblog comments usually belong to a post, so you might use +resources+ like:
-      #
-      #     map.resources :articles
-      #     map.resources :comments, :path_prefix => '/articles/:article_id'
-      #
-      #   You can nest +resources+ calls to set this automatically:
-      #
-      #     map.resources :articles do |article|
-      #       article.resources :comments
-      #     end
-      #
-      #   The comment \resources work the same, but must now include a value for <tt>:article_id</tt>.
-      #
-      #     article_comments_url(@article)
-      #     article_comment_url(@article, @comment)
-      #
-      #     article_comments_url(:article_id => @article)
-      #     article_comment_url(:article_id => @article, :id => @comment)
-      #
-      #   If you don't want to load all objects from the database you might want to use the <tt>article_id</tt> directly:
-      #
-      #     articles_comments_url(@comment.article_id, @comment)
-      #
-      # * <tt>:name_prefix</tt> - Define a prefix for all generated routes, usually ending in an underscore.
-      #   Use this if you have named routes that may clash.
-      #
-      #     map.resources :tags, :path_prefix => '/books/:book_id', :name_prefix => 'book_'
-      #     map.resources :tags, :path_prefix => '/toys/:toy_id',   :name_prefix => 'toy_'
-      #
-      # You may also use <tt>:name_prefix</tt> to override the generic named routes in a nested \resource:
-      #
-      #   map.resources :articles do |article|
-      #     article.resources :comments, :name_prefix => nil
-      #   end
-      #
-      # This will yield named \resources like so:
-      #
-      #   comments_url(@article)
-      #   comment_url(@article, @comment)
-      #
-      # * <tt>:shallow</tt> - If true, paths for nested resources which reference a specific member
-      #   (ie. those with an :id parameter) will not use the parent path prefix or name prefix.
-      #
-      # The <tt>:shallow</tt> option is inherited by any nested resource(s).
-      #
-      # For example, 'users', 'posts' and 'comments' all use shallow paths with the following nested resources:
-      #
-      #   map.resources :users, :shallow => true do |user|
-      #     user.resources :posts do |post|
-      #       post.resources :comments
-      #     end
-      #   end
-      #   # --> GET /users/1/posts (maps to the PostsController#index action as usual)
-      #   #     also adds the usual named route called "user_posts"
-      #   # --> GET /posts/2 (maps to the PostsController#show action as if it were not nested)
-      #   #     also adds the named route called "post"
-      #   # --> GET /posts/2/comments (maps to the CommentsController#index action)
-      #   #     also adds the named route called "post_comments"
-      #   # --> GET /comments/2 (maps to the CommentsController#show action as if it were not nested)
-      #   #     also adds the named route called "comment"
-      #
-      # You may also use <tt>:shallow</tt> in combination with the +has_one+ and +has_many+ shorthand notations like:
-      #
-      #   map.resources :users, :has_many => { :posts => :comments }, :shallow => true
-      #
-      # * <tt>:only</tt> and <tt>:except</tt> - Specify which of the seven default actions should be routed to.
-      #
-      # <tt>:only</tt> and <tt>:except</tt> may be set to <tt>:all</tt>, <tt>:none</tt>, an action name or a
-      # list of action names. By default, routes are generated for all seven actions.
-      #
-      # For example:
-      #
-      #   map.resources :posts, :only => [:index, :show] do |post|
-      #     post.resources :comments, :except => [:update, :destroy]
-      #   end
-      #   # --> GET /posts (maps to the PostsController#index action)
-      #   # --> POST /posts (fails)
-      #   # --> GET /posts/1 (maps to the PostsController#show action)
-      #   # --> DELETE /posts/1 (fails)
-      #   # --> POST /posts/1/comments (maps to the CommentsController#create action)
-      #   # --> PUT /posts/1/comments/1 (fails)
-      #
-      # If <tt>map.resources</tt> is called with multiple resources, they all get the same options applied.
-      #
-      # Examples:
-      #
-      #   map.resources :messages, :path_prefix => "/thread/:thread_id"
-      #   # --> GET /thread/7/messages/1
-      #
-      #   map.resources :messages, :collection => { :rss => :get }
-      #   # --> GET /messages/rss (maps to the #rss action)
-      #   #     also adds a named route called "rss_messages"
-      #
-      #   map.resources :messages, :member => { :mark => :post }
-      #   # --> POST /messages/1/mark (maps to the #mark action)
-      #   #     also adds a named route called "mark_message"
-      #
-      #   map.resources :messages, :new => { :preview => :post }
-      #   # --> POST /messages/new/preview (maps to the #preview action)
-      #   #     also adds a named route called "preview_new_message"
-      #
-      #   map.resources :messages, :new => { :new => :any, :preview => :post }
-      #   # --> POST /messages/new/preview (maps to the #preview action)
-      #   #     also adds a named route called "preview_new_message"
-      #   # --> /messages/new can be invoked via any request method
-      #
-      #   map.resources :messages, :controller => "categories",
-      #         :path_prefix => "/category/:category_id",
-      #         :name_prefix => "category_"
-      #   # --> GET /categories/7/messages/1
-      #   #     has named route "category_message"
-      #
-      # The +resources+ method sets HTTP method restrictions on the routes it generates. For example, making an
-      # HTTP POST on <tt>new_message_url</tt> will raise a RoutingError exception. The default route in
-      # <tt>config/routes.rb</tt> overrides this and allows invalid HTTP methods for \resource routes.
       def resources(*entities, &block)
         options = entities.extract_options!
         entities.each { |entity| map_resource(entity, options.dup, &block) }
       end
 
-      # Creates named routes for implementing verb-oriented controllers for a singleton \resource.
-      # A singleton \resource is global to its current context.  For unnested singleton \resources,
-      # the \resource is global to the current user visiting the application, such as a user's
-      # <tt>/account</tt> profile.  For nested singleton \resources, the \resource is global to its parent
-      # \resource, such as a <tt>projects</tt> \resource that <tt>has_one :project_manager</tt>.
-      # The <tt>project_manager</tt> should be mapped as a singleton \resource under <tt>projects</tt>:
-      #
-      #   map.resources :projects do |project|
-      #     project.resource :project_manager
-      #   end
-      #
-      # See +resources+ for general conventions.  These are the main differences:
-      # * A singular name is given to <tt>map.resource</tt>.  The default controller name is still taken from the plural name.
-      # * To specify a custom plural name, use the <tt>:plural</tt> option.  There is no <tt>:singular</tt> option.
-      # * No default index route is created for the singleton \resource controller.
-      # * When nesting singleton \resources, only the singular name is used as the path prefix (example: 'account/messages/1')
-      #
-      # For example:
-      #
-      #   map.resource :account
-      #
-      # maps these actions in the Accounts controller:
-      #
-      #   class AccountsController < ActionController::Base
-      #     # GET new_account_url
-      #     def new
-      #       # return an HTML form for describing the new account
-      #     end
-      #
-      #     # POST account_url
-      #     def create
-      #       # create an account
-      #     end
-      #
-      #     # GET account_url
-      #     def show
-      #       # find and return the account
-      #     end
-      #
-      #     # GET edit_account_url
-      #     def edit
-      #       # return an HTML form for editing the account
-      #     end
-      #
-      #     # PUT account_url
-      #     def update
-      #       # find and update the account
-      #     end
-      #
-      #     # DELETE account_url
-      #     def destroy
-      #       # delete the account
-      #     end
-      #   end
-      #
-      # Along with the routes themselves, +resource+ generates named routes for
-      # use in controllers and views. <tt>map.resource :account</tt> produces
-      # these named routes and helpers:
-      #
-      #   Named Route   Helpers
-      #   ============  =============================================
-      #   account       account_url, hash_for_account_url,
-      #                 account_path, hash_for_account_path
-      #
-      #   new_account   new_account_url, hash_for_new_account_url,
-      #                 new_account_path, hash_for_new_account_path
-      #
-      #   edit_account  edit_account_url, hash_for_edit_account_url,
-      #                 edit_account_path, hash_for_edit_account_path
       def resource(*entities, &block)
         options = entities.extract_options!
         entities.each { |entity| map_singleton_resource(entity, options.dup, &block) }
@@ -882,7 +500,7 @@ module ActionDispatch
         end
 
         def add_conditions_for(conditions, method)
-          returning({:conditions => conditions.dup}) do |options|
+          {:conditions => conditions.dup}.tap do |options|
             options[:conditions][:method] = method unless method == :any
           end
         end

data/lib/action_dispatch/routing/mapper.rb

@@ -13,6 +13,8 @@ module ActionDispatch
           end
         end
 
+        attr_reader :app
+
         def initialize(app, constraints, request)
           @app, @constraints, @request = app, constraints, request
         end
@@ -33,11 +35,12 @@ module ActionDispatch
       end
 
       class Mapping #:nodoc:
-        IGNORE_OPTIONS = [:to, :as, :controller, :action, :via, :on, :constraints, :defaults, :only, :except, :anchor]
+        IGNORE_OPTIONS = [:to, :as, :via, :on, :constraints, :defaults, :only, :except, :anchor, :shallow, :shallow_path, :shallow_prefix]
 
         def initialize(set, scope, args)
           @set, @scope    = set, scope
           @path, @options = extract_path_and_options(args)
+          normalize_options!
         end
 
         def to_route
@@ -55,23 +58,29 @@ module ActionDispatch
               path = args.first
             end
 
-            if @scope[:module] && options[:to]
-              if options[:to].to_s.include?("#")
-                options[:to] = "#{@scope[:module]}/#{options[:to]}"
-              elsif @scope[:controller].nil?
-                options[:to] = "#{@scope[:module]}##{options[:to]}"
-              end
+            if path.match(':controller')
+              raise ArgumentError, ":controller segment is not allowed within a namespace block" if @scope[:module]
+
+              # Add a default constraint for :controller path segments that matches namespaced
+              # controllers with default routes like :controller/:action/:id(.:format), e.g:
+              # GET /admin/products/show/1
+              # => { :controller => 'admin/products', :action => 'show', :id => '1' }
+              options.reverse_merge!(:controller => /.+?/)
             end
 
-            path = normalize_path(path)
-            path_without_format = path.sub(/\(\.:format\)$/, '')
+            [ normalize_path(path), options ]
+          end
+
+          def normalize_options!
+            path_without_format = @path.sub(/\(\.:format\)$/, '')
 
-            if using_match_shorthand?(path_without_format, options)
-              options[:to] ||= path_without_format[1..-1].sub(%r{/([^/]*)$}, '#\1')
-              options[:as] ||= path_without_format[1..-1].gsub("/", "_")
+            if using_match_shorthand?(path_without_format, @options)
+              to_shorthand    = @options[:to].blank?
+              @options[:to] ||= path_without_format[1..-1].sub(%r{/([^/]*)$}, '#\1')
+              @options[:as] ||= path_without_format[1..-1].gsub("/", "_")
             end
 
-            [ path, options ]
+            @options.merge!(default_controller_and_action(to_shorthand))
           end
 
           # match "account" => "account#index"
@@ -102,7 +111,7 @@ module ActionDispatch
           end
 
           def requirements
-            @requirements ||= (@options[:constraints] || {}).tap do |requirements|
+            @requirements ||= (@options[:constraints].is_a?(Hash) ? @options[:constraints] : {}).tap do |requirements|
               requirements.reverse_merge!(@scope[:constraints]) if @scope[:constraints]
               @options.each { |k, v| requirements[k] = v if v.is_a?(Regexp) }
             end
@@ -110,40 +119,43 @@ module ActionDispatch
 
           def defaults
             @defaults ||= (@options[:defaults] || {}).tap do |defaults|
-              defaults.merge!(default_controller_and_action)
               defaults.reverse_merge!(@scope[:defaults]) if @scope[:defaults]
               @options.each { |k, v| defaults[k] = v unless v.is_a?(Regexp) || IGNORE_OPTIONS.include?(k.to_sym) }
             end
           end
 
-          def default_controller_and_action
+          def default_controller_and_action(to_shorthand=nil)
             if to.respond_to?(:call)
               { }
             else
-              defaults = case to
-              when String
+              if to.is_a?(String)
                 controller, action = to.split('#')
-                { :controller => controller, :action => action }
-              when Symbol
-                { :action => to.to_s }
-              else
-                {}
+              elsif to.is_a?(Symbol)
+                action = to.to_s
               end
 
-              defaults[:controller] ||= default_controller
+              controller ||= default_controller
+              action     ||= default_action
 
-              defaults.delete(:controller) if defaults[:controller].blank?
-              defaults.delete(:action)     if defaults[:action].blank?
+              unless controller.is_a?(Regexp) || to_shorthand
+                controller = [@scope[:module], controller].compact.join("/").presence
+              end
+
+              controller = controller.to_s unless controller.is_a?(Regexp)
+              action     = action.to_s     unless action.is_a?(Regexp)
 
-              if defaults[:controller].blank? && segment_keys.exclude?("controller")
+              if controller.blank? && segment_keys.exclude?("controller")
                 raise ArgumentError, "missing :controller"
               end
 
-              if defaults[:action].blank? && segment_keys.exclude?("action")
+              if action.blank? && segment_keys.exclude?("action")
                 raise ArgumentError, "missing :action"
               end
 
-              defaults
+              { :controller => controller, :action => action }.tap do |hash|
+                hash.delete(:controller) if hash[:controller].blank?
+                hash.delete(:action)     if hash[:action].blank?
+              end
             end
           end
 
@@ -182,9 +194,17 @@ module ActionDispatch
 
           def default_controller
             if @options[:controller]
-              @options[:controller].to_s
+              @options[:controller]
             elsif @scope[:controller]
-              @scope[:controller].to_s
+              @scope[:controller]
+            end
+          end
+
+          def default_action
+            if @options[:action]
+              @options[:action]
+            elsif @scope[:action]
+              @scope[:action]
             end
           end
       end
@@ -194,7 +214,7 @@ module ActionDispatch
       # for root cases, where the latter is the correct one.
       def self.normalize_path(path)
         path = Rack::Mount::Utils.normalize_path(path)
-        path.sub!(%r{/(\(+)/?:}, '\1/:') unless path =~ %r{^/\(+:.*\)$}
+        path.gsub!(%r{/(\(+)/?}, '\1/') unless path =~ %r{^/\(+[^/]+\)$}
         path
       end
 
@@ -299,6 +319,11 @@ module ActionDispatch
           options = args.extract_options!
           options = options.dup
 
+          if name_prefix = options.delete(:name_prefix)
+            options[:as] ||= name_prefix
+            ActiveSupport::Deprecation.warn ":name_prefix was deprecated in the new router syntax. Use :as instead.", caller
+          end
+
           case args.first
           when String
             options[:path] = args.first
@@ -341,9 +366,11 @@ module ActionDispatch
           scope(controller.to_sym) { yield }
         end
 
-        def namespace(path)
+        def namespace(path, options = {})
           path = path.to_s
-          scope(:path => path, :name_prefix => path, :module => path) { yield }
+          options = { :path => path, :as => path, :module => path,
+                      :shallow_path => path, :shallow_prefix => path }.merge!(options)
+          scope(options) { yield }
         end
 
         def constraints(constraints = {})
@@ -359,10 +386,10 @@ module ActionDispatch
 
           options = (@scope[:options] || {}).merge(options)
 
-          if @scope[:name_prefix] && !options[:as].blank?
-            options[:as] = "#{@scope[:name_prefix]}_#{options[:as]}"
-          elsif @scope[:name_prefix] && options[:as] == ""
-            options[:as] = @scope[:name_prefix].to_s
+          if @scope[:as] && !options[:as].blank?
+            options[:as] = "#{@scope[:as]}_#{options[:as]}"
+          elsif @scope[:as] && options[:as] == ""
+            options[:as] = @scope[:as].to_s
           end
 
           args.push(options)
@@ -378,7 +405,15 @@ module ActionDispatch
             Mapper.normalize_path("#{parent}/#{child}")
           end
 
-          def merge_name_prefix_scope(parent, child)
+          def merge_shallow_path_scope(parent, child)
+            Mapper.normalize_path("#{parent}/#{child}")
+          end
+
+          def merge_as_scope(parent, child)
+            parent ? "#{parent}_#{child}" : child
+          end
+
+          def merge_shallow_prefix_scope(parent, child)
             parent ? "#{parent}_#{child}" : child
           end
 
@@ -387,7 +422,7 @@ module ActionDispatch
           end
 
           def merge_controller_scope(parent, child)
-            @scope[:module] ? "#{@scope[:module]}/#{child}" : child
+            child
           end
 
           def merge_path_names_scope(parent, child)
@@ -403,56 +438,60 @@ module ActionDispatch
           end
 
           def merge_blocks_scope(parent, child)
-            (parent || []) + [child]
+            merged = parent ? parent.dup : []
+            merged << child if child
+            merged
           end
 
           def merge_options_scope(parent, child)
-            (parent || {}).merge(child)
+            (parent || {}).except(*override_keys(child)).merge(child)
+          end
+
+          def merge_shallow_scope(parent, child)
+            child ? true : false
+          end
+
+          def override_keys(child)
+            child.key?(:only) || child.key?(:except) ? [:only, :except] : []
           end
       end
 
       module Resources
-        CRUD_ACTIONS = [:index, :show, :create, :update, :destroy] #:nodoc:
+        # CANONICAL_ACTIONS holds all actions that does not need a prefix or
+        # a path appended since they fit properly in their scope level.
+        VALID_ON_OPTIONS = [:new, :collection, :member]
+        CANONICAL_ACTIONS = [:index, :create, :new, :show, :update, :destroy]
+        RESOURCE_OPTIONS = [:as, :controller, :path, :only, :except]
 
         class Resource #:nodoc:
-          def self.default_actions
-            [:index, :create, :new, :show, :update, :destroy, :edit]
-          end
+          DEFAULT_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit]
 
           attr_reader :controller, :path, :options
 
           def initialize(entities, options = {})
             @name       = entities.to_s
             @path       = options.delete(:path) || @name
-            @controller = options.delete(:controller) || @name.to_s.pluralize
+            @controller = (options.delete(:controller) || @name).to_s
+            @as         = options.delete(:as)
             @options    = options
           end
 
           def default_actions
-            self.class.default_actions
+            self.class::DEFAULT_ACTIONS
           end
 
           def actions
-            if only = options[:only]
+            if only = @options[:only]
               Array(only).map(&:to_sym)
-            elsif except = options[:except]
+            elsif except = @options[:except]
               default_actions - Array(except).map(&:to_sym)
             else
               default_actions
             end
           end
 
-          def action_type(action)
-            case action
-            when :index, :create
-              :collection
-            when :show, :update, :destroy
-              :member
-            end
-          end
-
           def name
-            options[:as] || @name
+            @as || @name
           end
 
           def plural
@@ -463,98 +502,57 @@ module ActionDispatch
             name.to_s.singularize
           end
 
-          def member_prefix
-            ':id'
-          end
-
           def member_name
             singular
           end
 
           # Checks for uncountable plurals, and appends "_index" if they're.
           def collection_name
-            uncountable? ? "#{plural}_index" : plural
+            singular == plural ? "#{plural}_index" : plural
           end
 
-          def uncountable?
-            singular == plural
+          def resource_scope
+            { :controller => controller }
           end
 
-          def name_for_action(action)
-            case action_type(action)
-            when :collection
-              collection_name
-            when :member
-              member_name
-            end
+          def collection_scope
+            path
           end
 
-          def id_segment
-            ":#{singular}_id"
+          def member_scope
+            "#{path}/:id"
           end
 
-          def constraints
-            options[:constraints] || {}
+          def new_scope(new_path)
+            "#{path}/#{new_path}"
           end
 
-          def id_constraint?
-            options[:id] && options[:id].is_a?(Regexp) || constraints[:id] && constraints[:id].is_a?(Regexp)
+          def nested_scope
+            "#{path}/:#{singular}_id"
           end
 
-          def id_constraint
-            options[:id] || constraints[:id]
-          end
-
-          def collection_options
-            (options || {}).dup.tap do |options|
-              options.delete(:id)
-              options[:constraints] = options[:constraints].dup if options[:constraints]
-              options[:constraints].delete(:id) if options[:constraints].is_a?(Hash)
-            end
-          end
-
-          def nested_prefix
-            id_segment
-          end
-
-          def nested_options
-            options = { :name_prefix => member_name }
-            options["#{singular}_id".to_sym] = id_constraint if id_constraint?
-            options
-          end
         end
 
         class SingletonResource < Resource #:nodoc:
-          def self.default_actions
-            [:show, :create, :update, :destroy, :new, :edit]
-          end
+          DEFAULT_ACTIONS = [:show, :create, :update, :destroy, :new, :edit]
 
-          def initialize(entity, options = {})
-            super
-          end
-
-          def action_type(action)
-            case action
-            when :show, :create, :update, :destroy
-              :member
-            end
-          end
-
-          def member_prefix
-            ''
+          def initialize(entities, options)
+            @name       = entities.to_s
+            @path       = options.delete(:path) || @name
+            @controller = (options.delete(:controller) || plural).to_s
+            @as         = options.delete(:as)
+            @options    = options
           end
 
           def member_name
             name
           end
+          alias :collection_name :member_name
 
-          def nested_prefix
-            ''
-          end
-
-          def nested_options
-            { :name_prefix => member_name }
+          def member_scope
+            path
           end
+          alias :nested_scope :member_scope
         end
 
         def initialize(*args) #:nodoc:
@@ -562,31 +560,33 @@ module ActionDispatch
           @scope[:path_names] = @set.resources_path_names
         end
 
+        def resources_path_names(options)
+          @scope[:path_names].merge!(options)
+        end
+
         def resource(*resources, &block)
           options = resources.extract_options!
-          options = (@scope[:options] || {}).merge(options)
 
           if apply_common_behavior_for(:resource, resources, options, &block)
             return self
           end
 
-          resource = SingletonResource.new(resources.pop, options)
+          resource_scope(SingletonResource.new(resources.pop, options)) do
+            yield if block_given?
 
-          scope(:path => resource.path, :controller => resource.controller) do
-            with_scope_level(:resource, resource) do
+            collection_scope do
+              post :create
+            end if parent_resource.actions.include?(:create)
 
-              yield if block_given?
+            new_scope do
+              get :new
+            end if parent_resource.actions.include?(:new)
 
-              with_scope_level(:member) do
-                scope(resource.options) do
-                  get    :show if resource.actions.include?(:show)
-                  post   :create if resource.actions.include?(:create)
-                  put    :update if resource.actions.include?(:update)
-                  delete :destroy if resource.actions.include?(:destroy)
-                  get    :new, :as => resource.name if resource.actions.include?(:new)
-                  get    :edit, :as => resource.name if resource.actions.include?(:edit)
-                end
-              end
+            member_scope  do
+              get    :show if parent_resource.actions.include?(:show)
+              put    :update if parent_resource.actions.include?(:update)
+              delete :destroy if parent_resource.actions.include?(:destroy)
+              get    :edit if parent_resource.actions.include?(:edit)
             end
           end
 
@@ -595,36 +595,28 @@ module ActionDispatch
 
         def resources(*resources, &block)
           options = resources.extract_options!
-          options = (@scope[:options] || {}).merge(options)
 
           if apply_common_behavior_for(:resources, resources, options, &block)
             return self
           end
 
-          resource = Resource.new(resources.pop, options)
+          resource_scope(Resource.new(resources.pop, options)) do
+            yield if block_given?
 
-          scope(:path => resource.path, :controller => resource.controller) do
-            with_scope_level(:resources, resource) do
-              yield if block_given?
+            collection_scope do
+              get  :index if parent_resource.actions.include?(:index)
+              post :create if parent_resource.actions.include?(:create)
+            end
 
-              with_scope_level(:collection) do
-                scope(resource.collection_options) do
-                  get  :index if resource.actions.include?(:index)
-                  post :create if resource.actions.include?(:create)
-                  get  :new, :as => resource.singular if resource.actions.include?(:new)
-                end
-              end
+            new_scope do
+              get :new
+            end if parent_resource.actions.include?(:new)
 
-              with_scope_level(:member) do
-                scope(':id') do
-                  scope(resource.options) do
-                    get    :show if resource.actions.include?(:show)
-                    put    :update if resource.actions.include?(:update)
-                    delete :destroy if resource.actions.include?(:destroy)
-                    get    :edit, :as => resource.singular if resource.actions.include?(:edit)
-                  end
-                end
-              end
+            member_scope  do
+              get    :show if parent_resource.actions.include?(:show)
+              put    :update if parent_resource.actions.include?(:update)
+              delete :destroy if parent_resource.actions.include?(:destroy)
+              get    :edit if parent_resource.actions.include?(:edit)
             end
           end
 
@@ -636,10 +628,8 @@ module ActionDispatch
             raise ArgumentError, "can't use collection outside resources scope"
           end
 
-          with_scope_level(:collection) do
-            scope(:name_prefix => parent_resource.collection_name, :as => "") do
-              yield
-            end
+          collection_scope do
+            yield
           end
         end
 
@@ -648,10 +638,8 @@ module ActionDispatch
             raise ArgumentError, "can't use member outside resource(s) scope"
           end
 
-          with_scope_level(:member) do
-            scope(parent_resource.member_prefix, :name_prefix => parent_resource.member_name, :as => "") do
-              yield
-            end
+          member_scope do
+            yield
           end
         end
 
@@ -659,11 +647,9 @@ module ActionDispatch
           unless resource_scope?
             raise ArgumentError, "can't use new outside resource(s) scope"
           end
-          
-          with_scope_level(:new) do
-            scope(new_scope_prefix, :name_prefix => parent_resource.member_name, :as => "") do
-              yield
-            end
+
+          new_scope do
+            yield
           end
         end
 
@@ -673,13 +659,23 @@ module ActionDispatch
           end
 
           with_scope_level(:nested) do
-            scope(parent_resource.nested_prefix, parent_resource.nested_options) do
-              yield
+            if shallow?
+              with_exclusive_scope do
+                if @scope[:shallow_path].blank?
+                  scope(parent_resource.nested_scope, nested_options) { yield }
+                else
+                  scope(@scope[:shallow_path], :as => @scope[:shallow_prefix]) do
+                    scope(parent_resource.nested_scope, nested_options) { yield }
+                  end
+                end
+              end
+            else
+              scope(parent_resource.nested_scope, nested_options) { yield }
             end
           end
         end
 
-        def namespace(path)
+        def namespace(path, options = {})
           if resource_scope?
             nested { super }
           else
@@ -687,93 +683,105 @@ module ActionDispatch
           end
         end
 
-        def match(*args)
-          options = args.extract_options!
+        def shallow
+          scope(:shallow => true) do
+            yield
+          end
+        end
 
+        def shallow?
+          parent_resource.instance_of?(Resource) && @scope[:shallow]
+        end
+
+        def match(*args)
+          options = args.extract_options!.dup
           options[:anchor] = true unless options.key?(:anchor)
 
           if args.length > 1
-            args.each { |path| match(path, options) }
+            args.each { |path| match(path, options.dup) }
             return self
           end
 
-          path_names = options.delete(:path_names)
-
-          if args.first.is_a?(Symbol)
-            action = args.first
-            if CRUD_ACTIONS.include?(action)
-              begin
-                old_path = @scope[:path]
-                @scope[:path] = "#{@scope[:path]}(.:format)"
-                return match(options.reverse_merge(
-                  :to => action,
-                  :as => parent_resource.name_for_action(action)
-                ))
-              ensure
-                @scope[:path] = old_path
-              end
-            else
-              with_exclusive_name_prefix(action_name_prefix(action, options)) do
-                return match("#{action_path(action, path_names)}(.:format)", options.reverse_merge(:to => action))
-              end
-            end
+          on = options.delete(:on)
+          if VALID_ON_OPTIONS.include?(on)
+            args.push(options)
+            return send(on){ match(*args) }
+          elsif on
+            raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
           end
 
-          args.push(options)
-
-          case options.delete(:on)
-          when :collection
-            return collection { match(*args) }
-          when :member
+          if @scope[:scope_level] == :resource
+            args.push(options)
             return member { match(*args) }
-          when :new
-            return new { match(*args) }
           end
 
-          if @scope[:scope_level] == :resource
-            return member { match(*args) }
+          path = options.delete(:path)
+          action = args.first
+
+          if action.is_a?(Symbol)
+            path = path_for_action(action, path)
+            options[:to] ||= action
+            options[:as]   = name_for_action(action, options[:as])
+
+            with_exclusive_scope do
+              return super(path, options)
+            end
+          elsif resource_method_scope?
+            path = path_for_custom_action
+            options[:as] = name_for_action(options[:as]) if options[:as]
+            args.push(options)
+
+            with_exclusive_scope do
+              scope(path) do
+                return super
+              end
+            end
           end
 
           if resource_scope?
             raise ArgumentError, "can't define route directly in resource(s) scope"
           end
 
+          args.push(options)
           super
         end
 
         def root(options={})
-          options[:on] ||= :collection if @scope[:scope_level] == :resources
-          super(options)
+          if @scope[:scope_level] == :resources
+            with_scope_level(:nested) do
+              scope(parent_resource.path, :as => parent_resource.collection_name) do
+                super(options)
+              end
+            end
+          else
+            super(options)
+          end
         end
 
         protected
+
           def parent_resource #:nodoc:
             @scope[:scope_level_resource]
           end
 
-        private
-          def action_path(name, path_names = nil)
-            path_names ||= @scope[:path_names]
-            path_names[name.to_sym] || name.to_s
-          end
-
-          def action_name_prefix(action, options = {})
-            (options[:on] == :new || @scope[:scope_level] == :new) ? "#{action}_new" : action
-          end
-
           def apply_common_behavior_for(method, resources, options, &block)
             if resources.length > 1
               resources.each { |r| send(method, r, options, &block) }
               return true
             end
 
-            if path_names = options.delete(:path_names)
-              scope(:path_names => path_names) do
+            scope_options = options.slice!(*RESOURCE_OPTIONS)
+            unless scope_options.empty?
+              scope(scope_options) do
                 send(method, resources.pop, options, &block)
               end
               return true
             end
 
+            unless action_options?(options)
+              options.merge!(scope_action_options) if scope_action_options?
+            end
+
             if resource_scope?
               nested do
                 send(method, resources.pop, options, &block)
@@ -784,27 +792,36 @@ module ActionDispatch
             false
           end
 
-          def new_scope_prefix
-            @scope[:path_names][:new] || 'new'
+          def action_options?(options)
+            options[:only] || options[:except]
+          end
+
+          def scope_action_options?
+            @scope[:options].is_a?(Hash) && (@scope[:options][:only] || @scope[:options][:except])
+          end
+
+          def scope_action_options
+            @scope[:options].slice(:only, :except)
           end
 
           def resource_scope?
             [:resource, :resources].include?(@scope[:scope_level])
           end
 
-          def with_exclusive_name_prefix(prefix)
+          def resource_method_scope?
+            [:collection, :member, :new].include?(@scope[:scope_level])
+          end
+
+          def with_exclusive_scope
             begin
-              old_name_prefix = @scope[:name_prefix]
+              old_name_prefix, old_path = @scope[:as], @scope[:path]
+              @scope[:as], @scope[:path] = nil, nil
 
-              if !old_name_prefix.blank?
-                @scope[:name_prefix] = "#{prefix}_#{@scope[:name_prefix]}"
-              else
-                @scope[:name_prefix] = prefix.to_s
+              with_scope_level(:exclusive) do
+                yield
               end
-
-              yield
             ensure
-              @scope[:name_prefix] = old_name_prefix
+              @scope[:as], @scope[:path] = old_name_prefix, old_path
             end
           end
 
@@ -816,6 +833,119 @@ module ActionDispatch
             @scope[:scope_level] = old
             @scope[:scope_level_resource] = old_resource
           end
+
+          def resource_scope(resource)
+            with_scope_level(resource.is_a?(SingletonResource) ? :resource : :resources, resource) do
+              scope(parent_resource.resource_scope) do
+                yield
+              end
+            end
+          end
+
+          def new_scope
+            with_scope_level(:new) do
+              scope(parent_resource.new_scope(action_path(:new))) do
+                yield
+              end
+            end
+          end
+
+          def collection_scope
+            with_scope_level(:collection) do
+              scope(parent_resource.collection_scope) do
+                yield
+              end
+            end
+          end
+
+          def member_scope
+            with_scope_level(:member) do
+              scope(parent_resource.member_scope) do
+                yield
+              end
+            end
+          end
+
+          def nested_options
+            {}.tap do |options|
+              options[:as] = parent_resource.member_name
+              options[:constraints] = { "#{parent_resource.singular}_id".to_sym => id_constraint } if id_constraint?
+            end
+          end
+
+          def id_constraint?
+            @scope[:id].is_a?(Regexp) || (@scope[:constraints] && @scope[:constraints][:id].is_a?(Regexp))
+          end
+
+          def id_constraint
+            @scope[:id] || @scope[:constraints][:id]
+          end
+
+          def canonical_action?(action, flag)
+            flag && CANONICAL_ACTIONS.include?(action)
+          end
+
+          def shallow_scoping?
+            shallow? && @scope[:scope_level] == :member
+          end
+
+          def path_for_action(action, path)
+            prefix = shallow_scoping? ?
+              "#{@scope[:shallow_path]}/#{parent_resource.path}/:id" : @scope[:path]
+
+            if canonical_action?(action, path.blank?)
+              "#{prefix}(.:format)"
+            else
+              "#{prefix}/#{action_path(action, path)}(.:format)"
+            end
+          end
+
+          def path_for_custom_action
+            if shallow_scoping?
+              "#{@scope[:shallow_path]}/#{parent_resource.path}/:id"
+            else
+              @scope[:path]
+            end
+          end
+
+          def action_path(name, path = nil)
+            path || @scope[:path_names][name.to_sym] || name.to_s
+          end
+
+          def prefix_name_for_action(action, as)
+            if as.present?
+              "#{as}_"
+            elsif as
+              ""
+            elsif !canonical_action?(action, @scope[:scope_level])
+              "#{action}_"
+            end
+          end
+
+          def name_for_action(action, as=nil)
+            prefix = prefix_name_for_action(action, as)
+            name_prefix = @scope[:as]
+
+            if parent_resource
+              collection_name = parent_resource.collection_name
+              member_name = parent_resource.member_name
+              name_prefix = "#{name_prefix}_" if name_prefix.present?
+            end
+
+            case @scope[:scope_level]
+            when :collection
+              "#{prefix}#{name_prefix}#{collection_name}"
+            when :new
+              "#{prefix}new_#{name_prefix}#{member_name}"
+            else
+              if shallow_scoping?
+                shallow_prefix = "#{@scope[:shallow_prefix]}_" if @scope[:shallow_prefix].present?
+                "#{prefix}#{shallow_prefix}#{member_name}"
+              else
+                "#{prefix}#{name_prefix}#{member_name}"
+              end
+            end
+          end
       end
 
       include Base