How to limit the resource formats in the Rails routes file

Question

When routing resources in Rails the optional format attribute is automatically appended to the generated routes. This is so that the resource in question can be requested as either XML, HTML etc. Which formats that is actually allowed is usually described in the controller using respond_to.

But in many cases you only want to support HTML and it feels like an overhead to write respond_to :html in every action in every controller. It would therefore be cool if there where a way to limit to allowed content types already when building the routes in the routes.rb file, e.g.

map.resources :users, :formats => :html
map.resources :users, :formats => [:html, :xml]
map.resources :users, :formats => {:index => :html, :show => [:html, :xml]}

Is there a way to achieve this either native or via a plugin?

P.S. The usual way to work around this is to just ignore the problem and don't use respond_to in the actions. But this actually doesn't limit the allowed content types. Instead it just expects that a template exists in the views directory for each possible content type. If one doesn't exist when requested, the system will throw a HTTP 500 error.

Answer 1

You must wrap those routes in a scope if you want to restrict them to a specific format (e.g. html or json). Constraints unfortunately don't work as expected in this case.

This is an example of such a block...

scope :format => true, :constraints => { :format => 'json' } do
  get '/bar' => "bar#index_with_json"
end

More information can be found here: https://github.com/rails/rails/issues/5548

This answer is copied from my previous answer here..

Rails Routes - Limiting the available formats for a resource

Answer 2

Since Rails uses the equivalent of a wildcard to handle formats ".:format" it's a bit more difficult to prevent things on the route side.

Instead of this, it's pretty easy way to catch any non HTML requests in a before filter. Here's one way this might look:

class ApplicationController < ActionController::Base
  before_filter :check_format

  private

    def check_format
      if request.format != Mime::HTML
        raise ActionController::RoutingError, "Format #{params[:format].inspect} not supported for #{request.path.inspect}"
      end
    end

end

ActionController::RoutingErrors are handled as 404 errors which is sensible. In the event that you do have an action that needs to support something other than HTML, just use:

skip_before_filter :check_format, :only => ACTION_NAME

Answer 3

I believe you are able to do something like this:

respond_to do |format|
  format.html
  format.json { render :json => @things }
  format.any { render :text => "Invalid format", :status => 403 }
end

If the user requests html or json it'll do it as it should, but anything else will render the "Invalid Format" text.

Answer 4

In either case wouldn't you want a HTTP 500 error? Like in the second line of your example, if someone requested JSON instead of HTML or XML isn't an error code return the appropriate response?

Answer 5

rather than doing:

def some_action
  ...
  respond_to do |format|
    format.html
    format.json { whatever }
    format.any { whatever  }
  end
end

just use:

def some_action
  ...
end

and Rails will default to looking for some_action.html.erb or whatever format was requested. If you don't define any views other than html, then all other formats will fail if requested.