module ActionController::MimeResponds

def collect_mimes_from_class_level #:nodoc:

: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]
      !action.in?(config[:except])
    elsif config[:only]
      action.in?(config[:only])
    else
      true
    end
  end
end

def respond_to(*mimes, &block)


Be sure to check respond_with and respond_to documentation for more examples.

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.to_xml }
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 : default_render({})
  end
end

def respond_with(*resources, &block)


controller responds to in the class level with a call to respond_to.
In order to use respond_with, first you need to declare the formats your

a proc to it.
is quite simple (it just needs to respond to call), you can even give
except for the option :responder itself. Since the responder interface
All options given to respond_with are sent to the underlying responder,

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

response:
It also accepts a block to be given. It's used to overwrite a default

end
respond_with(@users)
@users = User.all
def index

==== Example

an ActionController::Responder with the controller and resource.
for the request was given and template was not available), it instantiates
First it invokes respond_to, if a response cannot be found (ie. no block
respond_with wraps a resource around a responder for default representation. 
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

def retrieve_collector_from_mimes(mimes=nil, &block) #:nodoc:

:nodoc:

nil if :not_acceptable was sent to the client.
Collects mimes and return the response for the negotiated format. Returns 
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
    head :not_acceptable
    nil
  end
end