Module: ActionDispatch::Http::MimeNegotiation

Extended by:
ActiveSupport::Concern
Included in:
Request
Defined in:
lib/action_dispatch/http/mime_negotiation.rb

Instance Method Summary collapse

Instance Method Details

#accepts ⇒ Object

Returns the accepted MIME type for the request.



37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 37

def accepts
  fetch_header("action_dispatch.request.accepts") do |k|
    header = get_header('HTTP_ACCEPT').to_s.strip

    v = if header.empty?
      [content_mime_type]
    else
      Mime::Type.parse(header)
    end
    set_header k, v
  end
end

#content_mime_type ⇒ Object

The MIME type of the HTTP request, such as Mime.

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



17
18
19
20
21
22
23
24
25
26
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 17

def content_mime_type
  fetch_header("action_dispatch.request.content_type") do |k|
    v = if get_header('CONTENT_TYPE') =~ /^([^,\;]*)/
      Mime::Type.lookup($1.strip.downcase)
    else
      nil
    end
    set_header k, v
  end
end

#content_type ⇒ Object 



28
29
30
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 28

def content_type
  content_mime_type && content_mime_type.to_s
end

#format(view_path = []) ⇒ Object

Returns the MIME type for the format used in the request.

GET /posts/5.xml   | request.format => Mime[:xml]
GET /posts/5.xhtml | request.format => Mime[:html]
GET /posts/5       | request.format => Mime[:html] or Mime[:js], or request.accepts.first



56
57
58
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 56

def format(view_path = [])
  formats.first || Mime::NullType.instance
end

#format=(extension) ⇒ Object

Sets the format by string extension, which can be used to force custom formats that are not controlled by the extension.

class ApplicationController < ActionController::Base
  before_action :adjust_format_for_iphone

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



117
118
119
120
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 117

def format=(extension)
  parameters[:format] = extension.to_s
  set_header "action_dispatch.request.formats", [Mime::Type.lookup_by_extension(parameters[:format])]
end

#formats ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 60

def formats
  fetch_header("action_dispatch.request.formats") do |k|
    params_readable = begin
                        parameters[:format]
                      rescue ActionController::BadRequest
                        false
                      end

    v = if params_readable
      Array(Mime[parameters[:format]])
    elsif use_accept_header && valid_accept_header
      accepts
    elsif extension_format = format_from_path_extension
      [extension_format]
    elsif xhr?
      [Mime[:js]]
    else
      [Mime[:html]]
    end

    v = v.select do |format|
      format.symbol || format.ref == "*/*"
    end

    set_header k, v
  end
end

#formats=(extensions) ⇒ Object

Sets the formats by string extensions. This differs from #format= by allowing you to set multiple, ordered formats, which is useful when you want to have a fallback.

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

class ApplicationController < ActionController::Base
  before_action :adjust_format_for_iphone_with_html_fallback

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



136
137
138
139
140
141
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 136

def formats=(extensions)
  parameters[:format] = extensions.first.to_s
  set_header "action_dispatch.request.formats", extensions.collect { |extension|
    Mime::Type.lookup_by_extension(extension)
  }
end

#has_content_type? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


32
33
34
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 32

def has_content_type? # :nodoc:
  get_header "CONTENT_TYPE"
end

#negotiate_mime(order) ⇒ Object

Receives an array of mimes and return the first user sent mime that matches the order array.



146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 146

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) ? format : nil
end

#variant ⇒ Object 



102
103
104
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 102

def variant
  @variant ||= ActiveSupport::ArrayInquirer.new
end

#variant=(variant) ⇒ Object

Sets the variant for template.



89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/action_dispatch/http/mime_negotiation.rb', line 89

def variant=(variant)
  variant = Array(variant)

  if variant.all? { |v| v.is_a?(Symbol) }
    @variant = ActiveSupport::ArrayInquirer.new(variant)
  else
    raise ArgumentError, "request.variant must be set to a Symbol or an Array of Symbols. " \
      "For security reasons, never directly set the variant to a user-provided value, " \
      "like params[:variant].to_sym. Check user-provided value against a whitelist first, " \
      "then set the variant: request.variant = :tablet if params[:variant] == 'tablet'"
  end
end