module ActionController::MimeResponds

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