module ActionController::MimeResponds

:nodoc:
current action.
Collect mimes declared in the class method respond_to valid for the

def collect_mimes_from_class_level #:nodoc:
  action = action_name.to_s
  self.class.mimes_for_respond_to.keys.select do |mime|
    config = self.class.mimes_for_respond_to[mime]
    if config[:except]
      !config[:except].include?(action)
    elsif config[:only]
      config[:only].include?(action)
    else
      true
    end
  end
end

ActionController::MimeResponds.respond_to for more examples.
Be sure to check the documentation of +respond_with+ and

end
end
respond_with(@people)
@people = Person.all
def index

respond_to :html, :xml, :json
class PeopleController < ApplicationController

with the respond_with method to have the same results:
Since this is a common pattern, you can use the class method respond_to

render json: @people

Or if the format is json:

render xml: @people

In the example above, if the format is xml, it will render:

end
end
format.any(:xml, :json) { render request.format.to_sym => @people }
format.html
respond_to do |format|

@people = Person.all
def index

Respond to also allows you to specify a common block for different formats by using any:

Mime::Type.register "image/jpg", :jpg

config/initializers/mime_types.rb as follows.
If you need to use a MIME type which isn't supported by default, you can register your own handlers in

and accept Rails' defaults, life will be much easier.
in a single request (i.e., by wrapping them all in a single root node), but if you just go with the flow
Note that you can define your own XML parameter parser which would allow you to describe multiple entities

with the remaining data.
we extract the company data from the request, find or create the company, and then create the new person
In other words, we make the request so that it operates on a single entity's person. Then, in the action,



...

...


And, like this (xml-encoded):

person[name]=...&person[company][name]=...&...

single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
This is because the incoming XML document (if a web-service request is in process) can only contain a

@company = Company.find_or_create_by(name: company[:name])
company = params[:person].delete(:company)

Note, however, the extra bit at the top of that action:



...
...
...

...
...


include the person's company in the rendered XML, so you get something like this:
Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
then it is an Ajax request and we render the JavaScript template associated with this action.
If the client wants HTML, we just redirect them back to the person list. If they want JavaScript,

end
end
format.xml { render xml: @person.to_xml(include: @company) }
format.js
format.html { redirect_to(person_list_url) }
respond_to do |format|

@person = @company.people.create(params[:person])
@company = Company.find_or_create_by(name: company[:name])
company = params[:person].delete(:company)
def create

Here's the same action, with web-service support baked in:

end
redirect_to(person_list_url)

@person = @company.people.create(params[:person])
@company = Company.find_or_create_by(name: params[:company][:name])
def create

(by name) if it does not already exist, without web-services, it might look like this:
Supposing you have an action that adds a new person, optionally creating their company

(Rails determines the desired response format from the HTTP Accept header submitted by the client.)
would have before, but if the client wants XML, return them the list of people in XML format."
What that says is, "if the client wants HTML in response to this action, just respond as we

end
end
format.xml { render xml: @people }
format.html
respond_to do |format|

@people = Person.all
def index

Here's the same action, with web-service support baked in:

end
@people = Person.all
def index

might look something like this:
Without web-service support, an action which collects the data for displaying a list of people

def respond_to(*mimes, &block)
  raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?
  if collector = retrieve_collector_from_mimes(mimes, &block)
    response = collector.response
    response ? response.call : render({})
  end
end

unsuccessful html +post+ request.
2. :action - overwrites the default render action used after an
a successful html +post+ request.
1. :location - overwrites the default redirect location used after
Two additional options are relevant specifically to +respond_with+ -

after a post request.
to save a resource, e.g. when automatically rendering :new
However, note that these options are ignored after an unsuccessful attempt
respond_with @people, status: 200
formats. Any option accepted by +render+ can be used, e.g.
resource(s) is interpreted as a set of options relevant to all
Also, a hash passed to +respond_with+ immediately after the specified

do not have to first be declared using the class method +respond_to+.
block. Note that formats with responses defined explicitly in this way
object which stores the responses for the formats defined within the
The argument passed to the block is an ActionController::MimeResponds::Collector

end
end
format.html { render }
respond_with(@user) do |format|

flash[:notice] = "User was successfully created." if @user.save
@user = User.new(params[:user])
def create

can be used to overwrite any of the default responses, e.g. -
Like +respond_to+, +respond_with+ may also be called with a block that

=== Customizing response behavior

one specified that is rendered.
javascript, if multiple resources are passed in this way, it is the last
instead of task_url. For request formats other than html or
This would cause +respond_with+ to redirect to project_task_url

end
respond_with(@project, @task)
flash[:notice] = 'Task was successfully created.' if @task.save
@task = @project.comments.build(params[:task])
@project = Project.find(params[:project_id])
def create

in form_for and polymorphic_url. For example -
the use of nested resources, which are supplied in the same way as
For redirecting successful html requests, +respond_with+ also supports

required format (again assuming no template exists).
it is the object that gets rendered, by being converted directly to the
no template exists), while for formats other than html and javascript
for successful html requests (e.g. for +create+ actions when
can play two roles. It can be used to generate the redirect url
As outlined above, the +resources+ argument passed to +respond_with+

=== Nested resources

render xml: resource.
directly, e.g. for an xml request, the response is equivalent to calling
the method attempts to render the resource in the requested format
the resource passed to +respond_with+ responds to to_,
* for other requests - i.e. data formats such as xml, json, csv etc, if
raised.
* for a javascript request - if the template isn't found, an exception is

end
end
end
format.xml { render xml: @user }
format.html { render action: "new" }
else
format.xml { render xml: @user }
format.html { redirect_to(@user) }
flash[:notice] = 'User was successfully created.'
if @user.save
respond_to do |format|
@user = User.new(params[:user])
def create

is equivalent, in the absence of create.html.erb, to -

end
respond_with(@user)
flash[:notice] = 'User was successfully created.' if @user.save
@user = User.new(params[:user])
def create

respond_to :html, :xml

Thus an example like this -
+post+ request or :edit for +patch+ or +put+.
renders a default action, which is :new for a
2. If there are validation errors, the response
i.e. its +show+ action.
was saved successfully, the response +redirect+'s to the resource
1. If there are no errors, i.e. the resource
e.g. by a +create+ action) -
assuming that an attempt has been made to save the resource,
depends on whether the resource has any validation errors (i.e.
is raised but for other requests such as +post+ the response
* for an html response - if the request method is +get+, an exception

depends on the selected format:
e.g. index.html.erb. If no template is available, the behavior
a template named after the current action and the selected format,
'406 - not acceptable' status. Otherwise, the default response is to render
If an acceptable format is not identified, the application returns a

the controller.
the mime-type can be selected by explicitly setting request.format in
by previous calls to the controller's class method +respond_to+. Alternatively
request's Accept header and the set of available formats declared
then the mime-type of the response is typically selected based on the

end
end
respond_with @people
@people = Person.all
def index

respond_to :html, :xml, :json
class PeopleController < ApplicationController

If the method is called with just a resource, as in this example -

response based on the mime-type requested by the client.
For a given controller action, respond_with generates an appropriate

def respond_with(*resources, &block)
  raise "In order to use respond_with, first you need to declare the formats your " \
        "controller responds to in the class level" if self.class.mimes_for_respond_to.empty?
  if collector = retrieve_collector_from_mimes(&block)
    options = resources.size == 1 ? {} : resources.extract_options!
    options[:default_response] = collector.response
    (options.delete(:responder) || self.class.responder).call(self, resources, options)
  end
end

:nodoc:
is available.
Sends :not_acceptable to the client and returns nil if no suitable format

In typical usage this is the block passed to +respond_with+ or +respond_to+.
for the current request, based on the available responses defined by a block.
Returns a Collector object containing the appropriate mime-type response

def retrieve_collector_from_mimes(mimes=nil, &block) #:nodoc:
  mimes ||= collect_mimes_from_class_level
  collector = Collector.new(mimes)
  block.call(collector) if block_given?
  format = collector.negotiate_format(request)
  if format
    self.content_type ||= format.to_s
    lookup_context.formats = [format.to_sym]
    lookup_context.rendered_format = lookup_context.formats.first
    collector
  else
    raise ActionController::UnknownFormat
  end
end