Class: ActionDispatch::Request

Inherits:
Object
  • Object
show all
Includes:
ContentSecurityPolicy::Request, Flash::RequestMethods, Http::Cache::Request, Http::FilterParameters, Http::MimeNegotiation, Http::Parameters, Http::URL, Rack::Request::Env, Rack::Request::Helpers
Defined in:
actionpack/lib/action_dispatch/http/request.rb,
actionpack/lib/action_dispatch/request/utils.rb,
actionpack/lib/action_dispatch/request/session.rb,
actionpack/lib/action_dispatch/middleware/flash.rb

Direct Known Subclasses

TestRequest

Defined Under Namespace

Classes: Session, Utils

Constant Summary collapse

LOCALHOST = 
Regexp.union [/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, /^::1$/, /^0:0:0:0:0:0:0:1(%.*)?$/]
ENV_METHODS = 
%w[ AUTH_TYPE GATEWAY_INTERFACE
PATH_TRANSLATED REMOTE_HOST
REMOTE_IDENT REMOTE_USER REMOTE_ADDR
SERVER_NAME SERVER_PROTOCOL
ORIGINAL_SCRIPT_NAME

HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM
HTTP_NEGOTIATE HTTP_PRAGMA HTTP_CLIENT_IP
HTTP_X_FORWARDED_FOR HTTP_ORIGIN HTTP_VERSION
HTTP_X_CSRF_TOKEN HTTP_X_REQUEST_ID HTTP_X_FORWARDED_HOST
].freeze
TRANSFER_ENCODING =

:nodoc:

"HTTP_TRANSFER_ENCODING"
PASS_NOT_FOUND =

:nodoc:

Class.new { # :nodoc:
  def self.action(_); self; end
  def self.call(_); [404, { Constants::X_CASCADE => "pass" }, []]; end
  def self.action_encoding_template(action); false; end
}
RFC2616 =

HTTP methods from [RFC 2616: Hypertext Transfer Protocol – HTTP/1.1](www.ietf.org/rfc/rfc2616.txt)

%w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT)
RFC2518 =

HTTP methods from [RFC 2518: HTTP Extensions for Distributed Authoring – WEBDAV](www.ietf.org/rfc/rfc2518.txt)

%w(PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK)
RFC3253 =

HTTP methods from [RFC 3253: Versioning Extensions to WebDAV](www.ietf.org/rfc/rfc3253.txt)

%w(VERSION-CONTROL REPORT CHECKOUT CHECKIN UNCHECKOUT MKWORKSPACE UPDATE LABEL MERGE BASELINE-CONTROL MKACTIVITY)
RFC3648 =

HTTP methods from [RFC 3648: WebDAV Ordered Collections Protocol](www.ietf.org/rfc/rfc3648.txt)

%w(ORDERPATCH)
RFC3744 =

HTTP methods from [RFC 3744: WebDAV Access Control Protocol](www.ietf.org/rfc/rfc3744.txt)

%w(ACL)
RFC5323 =

HTTP methods from [RFC 5323: WebDAV SEARCH](www.ietf.org/rfc/rfc5323.txt)

%w(SEARCH)
RFC4791 =

HTTP methods from [RFC 4791: Calendaring Extensions to WebDAV](www.ietf.org/rfc/rfc4791.txt)

%w(MKCALENDAR)
RFC5789 =

HTTP methods from [RFC 5789: PATCH Method for HTTP](www.ietf.org/rfc/rfc5789.txt)

%w(PATCH)
HTTP_METHODS = 
RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC4791 + RFC5789
HTTP_METHOD_LOOKUP = 
{}
ACTION_DISPATCH_REQUEST_ID =

:nodoc:

"action_dispatch.request_id"

Constants included from ContentSecurityPolicy::Request

ContentSecurityPolicy::Request::NONCE, ContentSecurityPolicy::Request::NONCE_DIRECTIVES, ContentSecurityPolicy::Request::NONCE_GENERATOR, ContentSecurityPolicy::Request::POLICY, ContentSecurityPolicy::Request::POLICY_REPORT_ONLY

Constants included from Http::URL

Http::URL::HOST_REGEXP, Http::URL::IP_HOST_REGEXP, Http::URL::PROTOCOL_REGEXP

Constants included from Http::FilterParameters

Http::FilterParameters::ENV_MATCH, Http::FilterParameters::NULL_ENV_FILTER, Http::FilterParameters::NULL_PARAM_FILTER

Constants included from Http::Parameters

Http::Parameters::DEFAULT_PARSERS, Http::Parameters::PARAMETERS_KEY

Constants included from Http::MimeNegotiation

Http::MimeNegotiation::RESCUABLE_MIME_FORMAT_ERRORS

Constants included from Http::Cache::Request

Http::Cache::Request::HTTP_IF_MODIFIED_SINCE, Http::Cache::Request::HTTP_IF_NONE_MATCH

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ContentSecurityPolicy::Request

#content_security_policy, #content_security_policy=, #content_security_policy_nonce, #content_security_policy_nonce_directives, #content_security_policy_nonce_directives=, #content_security_policy_nonce_generator, #content_security_policy_nonce_generator=, #content_security_policy_report_only, #content_security_policy_report_only=

Methods included from Http::URL

#domain, extract_domain, extract_subdomain, extract_subdomains, full_url_for, #host, #host_with_port, #optional_port, path_for, #port, #port_string, #protocol, #raw_host_with_port, #server_port, #standard_port, #standard_port?, #subdomain, #subdomains, #url, url_for

Methods included from Http::FilterParameters

#filtered_env, #filtered_parameters, #filtered_path, #parameter_filter

Methods included from Http::Parameters

#parameters, #path_parameters, #path_parameters=

Methods included from ActiveSupport::Concern

#append_features, #class_methods, extended, #included, #prepend_features, #prepended

Methods included from Http::MimeNegotiation

#accepts, #content_mime_type, #format, #format=, #formats, #formats=, #has_content_type?, #negotiate_mime, #should_apply_vary_header?, #variant, #variant=

Methods included from Http::Cache::Request

#cache_control_directives, #etag_matches?, #fresh?, #if_modified_since, #if_none_match, #if_none_match_etags, #not_modified?

Methods included from Flash::RequestMethods

#flash, #flash=, #flash_hash

Constructor Details

#initialize(env) ⇒ Request

Returns a new instance of Request.



63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 63

def initialize(env)
  super

  @rack_request = Rack::Request.new(env)

  @method            = nil
  @request_method    = nil
  @remote_ip         = nil
  @original_fullpath = nil
  @fullpath          = nil
  @ip                = nil
end

Instance Attribute Details

#rack_request ⇒ Object (readonly)

Returns the value of attribute rack_request.



76
77
78
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 76

def rack_request
  @rack_request
end

Class Method Details

.empty ⇒ Object 



59
60
61
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 59

def self.empty
  new({})
end

Instance Method Details

#authorization ⇒ Object

Returns the authorization header regardless of whether it was specified directly or through one of the proxy alternatives.



465
466
467
468
469
470
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 465

def authorization
  get_header("HTTP_AUTHORIZATION")   ||
  get_header("X-HTTP_AUTHORIZATION") ||
  get_header("X_HTTP_AUTHORIZATION") ||
  get_header("REDIRECT_X_HTTP_AUTHORIZATION")
end

#body ⇒ Object

The request body is an IO input stream. If the RAW_POST_DATA environment variable is already set, wrap it in a StringIO.



362
363
364
365
366
367
368
369
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 362

def body
  if raw_post = get_header("RAW_POST_DATA")
    raw_post = (+raw_post).force_encoding(Encoding::BINARY)
    StringIO.new(raw_post)
  else
    body_stream
  end
end

#body_stream ⇒ Object

:nodoc:



382
383
384
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 382

def body_stream # :nodoc:
  get_header("rack.input")
end

#commit_cookie_jar! ⇒ Object

:nodoc:



78
79
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 78

def commit_cookie_jar! # :nodoc:
end

#commit_csrf_token ⇒ Object 



497
498
499
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 497

def commit_csrf_token
  controller_instance.commit_csrf_token(self) if controller_instance.respond_to?(:commit_csrf_token)
end

#commit_flash ⇒ Object 



486
487
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 486

def commit_flash
end

#content_length ⇒ Object

Returns the content length of the request as an integer.



297
298
299
300
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 297

def content_length
  return raw_post.bytesize if has_header?(TRANSFER_ENCODING)
  super.to_i
end

#controller_class ⇒ Object 



87
88
89
90
91
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 87

def controller_class
  params = path_parameters
  params[:action] ||= "index"
  controller_class_for(params[:controller])
end

#controller_class_for(name) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 93

def controller_class_for(name)
  if name
    controller_param = name.underscore
    const_name = controller_param.camelize << "Controller"
    begin
      const_name.constantize
    rescue NameError => error
      if error.missing_name == const_name || const_name.start_with?("#{error.missing_name}::")
        raise MissingController.new(error.message, error.name)
      else
        raise
      end
    end
  else
    PASS_NOT_FOUND
  end
end

#controller_instance ⇒ Object

:nodoc:



195
196
197
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 195

def controller_instance # :nodoc:
  get_header("action_controller.instance")
end

#controller_instance=(controller) ⇒ Object

:nodoc:



199
200
201
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 199

def controller_instance=(controller) # :nodoc:
  set_header("action_controller.instance", controller)
end

#engine_script_name(_routes) ⇒ Object

:nodoc:



181
182
183
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 181

def engine_script_name(_routes) # :nodoc:
  get_header(_routes.env_key)
end

#engine_script_name=(name) ⇒ Object

:nodoc:



185
186
187
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 185

def engine_script_name=(name) # :nodoc:
  set_header(routes.env_key, name.dup)
end

#form_data? ⇒ Boolean

Determine whether the request body contains form-data by checking the request ‘Content-Type` for one of the media-types: `application/x-www-form-urlencoded` or `multipart/form-data`. The list of form-data media types can be modified through the `FORM_DATA_MEDIA_TYPES` array.

A request body is not assumed to contain form-data when no ‘Content-Type` header is provided and the request_method is POST.

Returns:

  • (Boolean) 


378
379
380
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 378

def form_data?
  FORM_DATA_MEDIA_TYPES.include?(media_type)
end

#fullpath ⇒ Object

Returns the ‘String` full path including params of the last URL requested.

# get "/articles"
request.fullpath # => "/articles"

# get "/articles?page=2"
request.fullpath # => "/articles?page=2"



276
277
278
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 276

def fullpath
  @fullpath ||= super
end

#GET ⇒ Object Also known as: query_parameters

Override Rack’s GET method to support indifferent access.



400
401
402
403
404
405
406
407
408
409
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 400

def GET
  fetch_header("action_dispatch.request.query_parameters") do |k|
    encoding_template = Request::Utils::CustomParamEncoder.action_encoding_template(self, path_parameters[:controller], path_parameters[:action])
    rack_query_params = ActionDispatch::ParamBuilder.from_query_string(rack_request.query_string, encoding_template: encoding_template)

    set_header k, rack_query_params
  end
rescue ActionDispatch::ParamError => e
  raise ActionController::BadRequest.new("Invalid query parameters: #{e.message}")
end

#headers ⇒ Object

Provides access to the request’s HTTP headers, for example:

request.headers["Content-Type"] # => "text/plain"



237
238
239
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 237

def headers
  @headers ||= Http::Headers.new(self)
end

#http_auth_salt ⇒ Object 



203
204
205
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 203

def http_auth_salt
  get_header "action_dispatch.http_auth_salt"
end

#inspect ⇒ Object

:nodoc:



489
490
491
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 489

def inspect # :nodoc:
  "#<#{self.class.name} #{method} #{original_url.dump} for #{remote_ip}>"
end

#ip ⇒ Object

Returns the IP address of client as a ‘String`.



311
312
313
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 311

def ip
  @ip ||= super
end

#key?(key) ⇒ Boolean

Returns true if the request has a header matching the given key parameter.

request.key? :ip_spoofing_check # => true

Returns:

  • (Boolean) 


114
115
116
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 114

def key?(key)
  has_header? key
end

#local? ⇒ Boolean

True if the request came from localhost, 127.0.0.1, or ::1.

Returns:

  • (Boolean) 


473
474
475
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 473

def local?
  LOCALHOST.match?(remote_addr) && LOCALHOST.match?(remote_ip)
end

#logger ⇒ Object 



482
483
484
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 482

def logger
  get_header("action_dispatch.logger")
end

#media_type ⇒ Object

The ‘String` MIME type of the request.

# get "/articles"
request.media_type # => "application/x-www-form-urlencoded"



292
293
294
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 292

def media_type
  content_mime_type&.to_s
end

#method(*args) ⇒ Object

Returns the original value of the environment’s REQUEST_METHOD, even if it was overridden by middleware. See #request_method for more information.

For debugging purposes, when called with arguments this method will fall back to Object#method



217
218
219
220
221
222
223
224
225
226
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 217

def method(*args)
  if args.empty?
    @method ||= check_method(
      get_header("rack.methodoverride.original_method") ||
      get_header("REQUEST_METHOD")
    )
  else
    super
  end
end

#method_symbol ⇒ Object

Returns a symbol form of the #method.



230
231
232
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 230

def method_symbol
  HTTP_METHOD_LOOKUP[method]
end

#original_fullpath ⇒ Object

Returns a ‘String` with the last requested path including their params.

# get '/foo'
request.original_fullpath # => '/foo'

# get '/foo?bar'
request.original_fullpath # => '/foo?bar'



265
266
267
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 265

def original_fullpath
  @original_fullpath ||= (get_header("ORIGINAL_FULLPATH") || fullpath)
end

#original_url ⇒ Object

Returns the original request URL as a ‘String`.

# get "/articles?page=2"
request.original_url # => "http://www.example.com/articles?page=2"



284
285
286
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 284

def original_url
  base_url + original_fullpath
end

#POST ⇒ Object Also known as: request_parameters

Override Rack’s POST method to support indifferent access.



413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 413

def POST
  fetch_header("action_dispatch.request.request_parameters") do
    encoding_template = Request::Utils::CustomParamEncoder.action_encoding_template(self, path_parameters[:controller], path_parameters[:action])

    param_list = nil
    pr = parse_formatted_parameters(params_parsers) do
      if param_list = request_parameters_list
        ActionDispatch::ParamBuilder.from_pairs(param_list, encoding_template: encoding_template)
      else
        # We're not using a version of Rack that provides raw form
        # pairs; we must use its hash (and thus post-process it below).
        fallback_request_parameters
      end
    end

    # If the request body was parsed by a custom parser like JSON
    # (and thus the above block was not run), we need to
    # post-process the result hash.
    if param_list.nil?
      pr = ActionDispatch::ParamBuilder.from_hash(pr, encoding_template: encoding_template)
    end

    self.request_parameters = pr
  end
rescue ActionDispatch::ParamError, EOFError => e
  raise ActionController::BadRequest.new("Invalid request parameters: #{e.message}")
end

#raw_post ⇒ Object

Read the request body. This is useful for web services that need to work with raw requests directly.



353
354
355
356
357
358
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 353

def raw_post
  unless has_header? "RAW_POST_DATA"
    set_header("RAW_POST_DATA", read_body_stream)
  end
  get_header "RAW_POST_DATA"
end

#raw_request_method ⇒ Object

:nodoc:



144
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 144

alias raw_request_method request_method

#remote_ip ⇒ Object

Returns the IP address of client as a ‘String`, usually set by the RemoteIp middleware.



317
318
319
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 317

def remote_ip
  @remote_ip ||= (get_header("action_dispatch.remote_ip") || ip).to_s
end

#remote_ip=(remote_ip) ⇒ Object 



321
322
323
324
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 321

def remote_ip=(remote_ip)
  @remote_ip = nil
  set_header "action_dispatch.remote_ip", remote_ip
end

#request_id ⇒ Object Also known as: uuid

Returns the unique request id, which is based on either the ‘X-Request-Id` header that can be generated by a firewall, load balancer, or web server, or by the RequestId middleware (which sets the `action_dispatch.request_id` environment variable).

This unique ID is useful for tracing a request from end-to-end as part of logging or debugging. This relies on the Rack variable set by the ActionDispatch::RequestId middleware.



336
337
338
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 336

def request_id
  get_header ACTION_DISPATCH_REQUEST_ID
end

#request_id=(id) ⇒ Object

:nodoc:



340
341
342
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 340

def request_id=(id) # :nodoc:
  set_header ACTION_DISPATCH_REQUEST_ID, id
end

#request_method ⇒ Object

Returns the HTTP method that the application should see. In the case where the method was overridden by a middleware (for instance, if a HEAD request was converted to a GET, or if a _method parameter was used to determine the method the application should use), this method returns the overridden value, not the original.



151
152
153
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 151

def request_method
  @request_method ||= check_method(super)
end

#request_method=(request_method) ⇒ Object

:nodoc:



189
190
191
192
193
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 189

def request_method=(request_method) # :nodoc:
  if check_method(request_method)
    @request_method = set_header("REQUEST_METHOD", request_method)
  end
end

#request_method_symbol ⇒ Object

Returns a symbol form of the #request_method.



208
209
210
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 208

def request_method_symbol
  HTTP_METHOD_LOOKUP[request_method]
end

#request_parameters=(params) ⇒ Object 



477
478
479
480
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 477

def request_parameters=(params)
  raise if params.nil?
  set_header("action_dispatch.request.request_parameters", params)
end

#request_parameters_list ⇒ Object 



442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 442

def request_parameters_list
  # We don't use Rack's parse result, but we must call it so Rack
  # can populate the rack.request.* keys we need.
  rack_post = rack_request.POST

  if form_pairs = get_header("rack.request.form_pairs")
    # Multipart
    form_pairs
  elsif form_vars = get_header("rack.request.form_vars")
    # URL-encoded
    ActionDispatch::QueryParser.each_pair(form_vars)
  elsif rack_post && !rack_post.empty?
    # It was multipart, but Rack did not preserve a pair list
    # (probably too old). Flat parameter list is not available.
    nil
  else
    # No request body, or not a format Rack knows
    []
  end
end

#reset_csrf_token ⇒ Object 



493
494
495
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 493

def reset_csrf_token
  controller_instance.reset_csrf_token(self) if controller_instance.respond_to?(:reset_csrf_token)
end

#reset_session ⇒ Object 



386
387
388
389
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 386

def reset_session
  session.destroy
  reset_csrf_token
end

#route=(route) ⇒ Object

:nodoc:



169
170
171
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 169

def route=(route) # :nodoc:
  @env["action_dispatch.route"] = route
end

#route_uri_pattern ⇒ Object

Returns the URI pattern of the matched route for the request, using the same format as ‘bin/rails routes`:

request.route_uri_pattern # => "/:controller(/:action(/:id))(.:format)"



159
160
161
162
163
164
165
166
167
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 159

def route_uri_pattern
  unless pattern = get_header("action_dispatch.route_uri_pattern")
    route = get_header("action_dispatch.route")
    return if route.nil?
    pattern = route.path.spec.to_s
    set_header("action_dispatch.route_uri_pattern", pattern)
  end
  pattern
end

#routes ⇒ Object

:nodoc:



173
174
175
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 173

def routes # :nodoc:
  get_header("action_dispatch.routes")
end

#routes=(routes) ⇒ Object

:nodoc:



177
178
179
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 177

def routes=(routes) # :nodoc:
  set_header("action_dispatch.routes", routes)
end

#send_early_hints(links) ⇒ Object

Early Hints is an HTTP/2 status code that indicates hints to help a client start making preparations for processing the final response.

If the env contains ‘rack.early_hints` then the server accepts HTTP2 push for link headers.

The ‘send_early_hints` method accepts a hash of links as follows:

send_early_hints("link" => "</style.css>; rel=preload; as=style,</script.js>; rel=preload")

If you are using javascript_include_tag or stylesheet_link_tag the Early Hints headers are included by default if supported.



254
255
256
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 254

def send_early_hints(links)
  env["rack.early_hints"]&.call(links)
end

#server_software ⇒ Object

Returns the lowercase name of the HTTP server software.



347
348
349
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 347

def server_software
  (get_header("SERVER_SOFTWARE") && /^([a-zA-Z]+)/ =~ get_header("SERVER_SOFTWARE")) ? $1.downcase : nil
end

#session=(session) ⇒ Object

:nodoc:



391
392
393
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 391

def session=(session) # :nodoc:
  Session.set self, session
end

#session_options=(options) ⇒ Object 



395
396
397
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 395

def session_options=(options)
  Session::Options.set self, options
end

#xml_http_request? ⇒ Boolean Also known as: xhr?

Returns true if the ‘X-Requested-With` header contains “XMLHttpRequest” (case-insensitive), which may need to be manually added depending on the choice of JavaScript libraries and frameworks.

Returns:

  • (Boolean) 


305
306
307
 
# File 'actionpack/lib/action_dispatch/http/request.rb', line 305

def xml_http_request?
  /XMLHttpRequest/i.match?(get_header("HTTP_X_REQUESTED_WITH"))
end