Home > Articles > Programming > Ruby

  • Print
  • + Share This
  • 💬 Discuss
This chapter is from the book

This chapter is from the book

3.7 Nested Resources

Let's say you want to perform operations on bids: create, edit, and so forth. You know that every bid is associated with a particular auction. That means that whenever you do anything to a bid, you're really doing something to an auction/bid pair—or, to look at it another way, an auction/bid nest. Bids are at the bottom of a drill-down hierarchical structure that always passes through an auction.

What you're aiming for here is a URL that looks like


What it does depends on the HTTP verb it comes with, of course. But the semantics of the URL itself are: the resource that can be identified as bid 5, belonging to auction 3.

Why not just go for bids/5 and skip the auction? For a couple of reasons. First, the URL is more informative—longer, it's true, but longer in the service of telling you something about the resource. Second, thanks to the way RESTful routes are engineered in Rails, this kind of URL gives you immediate access to the auction id, via params[:auction_id].

To created nested resource routes, put this in routes.rb:

resources :auctions do
  resources :bids

What that tells the mapper is that you want RESTful routes for auction resources; that is, you want auctions_url, edit_auction_url, and all the rest of it. You also want RESTful routes for bids: auction_bids_url, new_auction_bid_url, and so forth.

However, the nested resource command also involves you in making a promise. You're promising that whenever you use the bid named route helpers, you will provide a auction resource in which they can be nested. In your application code, that translates into an argument to the named route method:

link_to "See all bids", auction_bids_path(auction)

When you make that call, you enable the routing system to add the /auctions/3 part before the /bids part. And, on the receiving end—in this case, in the action bids/index, which is where that URL points—you'll find the id of auction in params[:auction_id]. (It's a plural RESTful route, using GET. See Table 3.1 again if you forgot.)

You can nest to any depth. Each level of nesting adds one to the number of arguments you have to supply to the nested routes. This means that for the singular routes (show, edit, destroy), you need at least two arguments:

link_to "Delete this bid", auction_bid_path(auction, bid), :method =>

This will enable the routing system to get the information it needs (essentially auction.id and bid.id) in order to generate the route.

If you prefer, you can also make the same call using hash-style method arguments, but most people don't because it's longer code:

auction_bid_path(:auction => auction, :bid => bid)

3.7.1 RESTful Controller Mappings

Something we haven't yet explicitly discussed is how RESTful routes are mapped to a given controller. It was just presented as something that happens automatically, which in fact it does, based on the name of the resource.

Going back to our recurring example, given the following nested route:

resources :auctions do
  resources :bids

there are two controllers that come into play, the AuctionsController and the BidsController.

3.7.2 Considerations

Is nesting worth it? For single routes, a nested route usually doesn't tell you anything you wouldn't be able to figure out anyway. After all, a bid belongs to an auction.

That means you can access bid.auction_id just as easily as you can params[:auction_id], assuming you have a bid object already.

Furthermore, the bid object doesn't depend on the nesting. You'll get params[:id] set to 5, and you can dig that record out of the database directly. You don't need to know what auction it belongs to.


A common rationale for judicious use of nested resources, and the one most often issued by David, is the ease with which you can enforce permissions and context-based constraints. Typically, a nested resource should only be accessible in the context of its parent resource, and it's really easy to enforce that in your code based on the way that you load the nested resource using the parent's Active Record association.

auction = Auction.find(params[:auction_id])
bid = auction.bids.find(params[:id]) # prevents auction/bid mismatch

If you want to add a bid to an auction, your nested resource URL would be


The auction is identified in the URL rather than having to clutter your new bid form data with hidden fields or resorting to non-RESTful practices.

3.7.3 Deep Nesting?

Jamis Buck is a very influential figure in the Rails community, almost as much as David himself. In February 2007, via his blog,2 he basically told us that deep nesting was a bad thing, and proposed the following rule of thumb: Resources should never be nested more than one level deep.

That advice is based on experience and concerns about practicality. The helper methods for routes nested more than two levels deep become long and unwieldy. It's easy to make mistakes with them and hard to figure out what's wrong when they don't work as expected.

Assume that in our application example, bids have multiple comments. We could nest comments under bids in the routing like this:

resources :auctions do
  resources :bids do
    resources :comments

Instead, Jamis would have us do the following:

resources :auctions do
  resources :bids

resources :bids do
  resources :comments

resources :comments

Notice that each resource (except auctions) is defined twice, once in the top-level namespace, and one in its context. The rationale? When it comes to parent-child scope, you really only need two levels to work with. The resulting URLs are shorter and the helper methods are easier to work with.

auctions_path          # /auctions
auctions_path(1)       # /auctions/1
auction_bids_path(1)   # /auctions/1/bids
bid_path(2)            # /bids/2
bid_comments_path(3)   # /bids/3/comments
comment_path(4)        # /comments/4

I personally don't follow Jamis's guideline all the time in my projects, but I have noticed that limiting the depth of your nested resources helps with the maintainability of your codebase in the long run.

3.7.4 Shallow Routes

As of Rails 2.3 resource routes accept a :shallow option that helps to shorten URLs where possible. The goal is to leave off parent collection URL segments where they are not needed. The end result is that the only nested routes generated are for the :index, :create, and :new actions. The rest are kept in their own shallow URL context.

It's easier to illustrate than to explain, so let's define a nested set of resources and set :shallow to true:

resources :auctions, :shallow => true do
  resources :bids do
    resources :comments

alternatively coded as follows (if you're block-happy)

resources :auctions do
  shallow do
    resources :bids do
      resources :comments

The resulting routes are:

                GET    /auctions(.:format)
       auctions POST   /auctions(.:format)
    new_auction GET    /auctions/new(.:format)
                GET    /auctions/:id(.:format)
                PUT    /auctions/:id(.:format)
        auction DELETE /auctions/:id(.:format)
   edit_auction GET    /auctions/:id/edit(.:format)
                GET    /auctions/:auction_id/bids(.:format)
   auction_bids POST   /auctions/:auction_id/bids(.:format)
new_auction_bid GET    /auctions/:auction_id/bids/new(.:format)
                GET    /bids/:bid_id/comments(.:format)
   bid_comments POST   /bids/:bid_id/comments(.:format)
new_bid_comment GET    /bids/:bid_id/comments/new(.:format
                GET    /comments/:id(.:format)
                PUT    /comments/:id(.:format)
        comment DELETE /comments/:id(.:format)
   edit_comment GET    /comments/:id/edit(.:format)

If you analyze the routes generated carefully, you'll notice that the nested parts of the URL are only included when they are needed to determine what data to display.

  • + Share This
  • 🔖 Save To Your Account


comments powered by Disqus