module ActionDispatch::Http::MimeNegotiation

def accepts

Returns the accepted MIME type for the request. 
def accepts
  @env["action_dispatch.request.accepts"] ||= begin
    header = @env['HTTP_ACCEPT'].to_s.strip
    if header.empty?
      [content_mime_type]
    else
      Mime::Type.parse(header)
    end
  end
end

def content_mime_type

X-Post-Data-Format HTTP header if present.
For backward compatibility, the post \format is extracted from the

The MIME type of the HTTP request, such as Mime::XML. 
def content_mime_type
  @env["action_dispatch.request.content_type"] ||= begin
    if @env['CONTENT_TYPE'] =~ /^([^,\;]*)/
      Mime::Type.lookup($1.strip.downcase)
    else
      nil
    end
  end
end

def content_type 

def content_type
  content_mime_type && content_mime_type.to_s
end

def format(view_path = [])


GET /posts/5 | request.format => Mime::HTML or MIME::JS, or request.accepts.first
GET /posts/5.xhtml | request.format => Mime::HTML
GET /posts/5.xml | request.format => Mime::XML

Returns the MIME type for the \format used in the request. 
def format(view_path = [])
  formats.first
end

def format=(extension)

end
end
request.format = :iphone if request.env["HTTP_USER_AGENT"][/iPhone/]
def adjust_format_for_iphone
private

before_action :adjust_format_for_iphone
class ApplicationController < ActionController::Base

that are not controlled by the extension.
Sets the \format by string extension, which can be used to force custom formats 
def format=(extension)
  parameters[:format] = extension.to_s
  @env["action_dispatch.request.formats"] = [Mime::Type.lookup_by_extension(parameters[:format])]
end

def formats 

def formats
  @env["action_dispatch.request.formats"] ||=
    if parameters[:format]
      Array(Mime[parameters[:format]])
    elsif use_accept_header && valid_accept_header
      accepts
    elsif xhr?
      [Mime::JS]
    else
      [Mime::HTML]
    end
end

def formats=(extensions)

end
end
request.formats = [ :iphone, :html ] if request.env["HTTP_USER_AGENT"][/iPhone/]
def adjust_format_for_iphone_with_html_fallback
private

before_action :adjust_format_for_iphone_with_html_fallback
class ApplicationController < ActionController::Base

to the :html format.
In this example, the :iphone format will be used if it's available, otherwise it'll fallback

to set multiple, ordered formats, which is useful when you want to have a fallback.
Sets the \formats by string extensions. This differs from #format= by allowing you 
def formats=(extensions)
  parameters[:format] = extensions.first.to_s
  @env["action_dispatch.request.formats"] = extensions.collect do |extension|
    Mime::Type.lookup_by_extension(extension)
  end
end

def negotiate_mime(order)


matches the order array.
Receives an array of mimes and return the first user sent mime that 
def negotiate_mime(order)
  formats.each do |priority|
    if priority == Mime::ALL
      return order.first
    elsif order.include?(priority)
      return priority
    end
  end
  order.include?(Mime::ALL) ? formats.first : nil
end

def use_accept_header 

def use_accept_header
  !self.class.ignore_accept_header
end

def valid_accept_header 

def valid_accept_header
  (xhr? && (accept.present? || content_mime_type)) ||
    (accept.present? && accept !~ BROWSER_LIKE_ACCEPTS)
end