Methods
G
P
#
A
B
C
D
F
G
H
I
L
M
O
P
Q
R
S
T
U
V
X
Constants
FORM_DATA_MEDIA_TYPES = [ 'application/x-www-form-urlencoded', 'multipart/form-data' ]
 

The set of form-data media-types. Requests that do not indicate one of the media types presents in this list will not be eligible for form-data / param parsing.

PARSEABLE_DATA_MEDIA_TYPES = [ 'multipart/related', 'multipart/mixed' ]
 

The set of media-types. Requests that do not indicate one of the media types presents in this list will not be eligible for param parsing like soap attachments or generic multiparts

DEFAULT_PORTS = { 'http' => 80, 'https' => 443, 'coffee' => 80 }
 

Default ports depending on scheme. Used to decide whether or not to include the port in a generated URI.

HTTP_X_FORWARDED_SCHEME = 'HTTP_X_FORWARDED_SCHEME'.freeze
 
HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO'.freeze
 
HTTP_X_FORWARDED_HOST = 'HTTP_X_FORWARDED_HOST'.freeze
 
HTTP_X_FORWARDED_PORT = 'HTTP_X_FORWARDED_PORT'.freeze
 
HTTP_X_FORWARDED_SSL = 'HTTP_X_FORWARDED_SSL'.freeze
 
Instance Public methods
GET()

Returns the data received in the query string.

# File lib/rack/request.rb, line 315
def GET
  if get_header(RACK_REQUEST_QUERY_STRING) == query_string
    get_header(RACK_REQUEST_QUERY_HASH)
  else
    query_hash = parse_query(query_string, '&;')
    set_header(RACK_REQUEST_QUERY_STRING, query_string)
    set_header(RACK_REQUEST_QUERY_HASH, query_hash)
  end
end
POST()

Returns the data received in the request body.

This method support both application/x-www-form-urlencoded and multipart/form-data.

# File lib/rack/request.rb, line 329
def POST
  if get_header(RACK_INPUT).nil?
    raise "Missing rack.input"
  elsif get_header(RACK_REQUEST_FORM_INPUT) == get_header(RACK_INPUT)
    get_header(RACK_REQUEST_FORM_HASH)
  elsif form_data? || parseable_data?
    unless set_header(RACK_REQUEST_FORM_HASH, parse_multipart)
      form_vars = get_header(RACK_INPUT).read

      # Fix for Safari Ajax postings that always append \0
      # form_vars.sub!(/\0\z/, '') # performance replacement:
      form_vars.slice!(-1) if form_vars[-1] == ?\0

      set_header RACK_REQUEST_FORM_VARS, form_vars
      set_header RACK_REQUEST_FORM_HASH, parse_query(form_vars, '&')

      get_header(RACK_INPUT).rewind
    end
    set_header RACK_REQUEST_FORM_INPUT, get_header(RACK_INPUT)
    get_header RACK_REQUEST_FORM_HASH
  else
    {}
  end
end
[](key)

shortcut for request.params[key]

# File lib/rack/request.rb, line 424
def [](key)
  if $VERBOSE
    warn("Request#[] is deprecated and will be removed in a future version of Rack. Please use request.params[] instead")
  end

  params[key.to_s]
end
[]=(key, value)

shortcut for request.params[key] = value

Note that modifications will not be persisted in the env. Use #update_param or #delete_param if you want to destructively modify params.

# File lib/rack/request.rb, line 435
def []=(key, value)
  if $VERBOSE
    warn("Request#[]= is deprecated and will be removed in a future version of Rack. Please use request.params[]= instead")
  end

  params[key.to_s] = value
end
accept_encoding()
# File lib/rack/request.rb, line 411
def accept_encoding
  parse_http_accept_header(get_header("HTTP_ACCEPT_ENCODING"))
end
accept_language()
# File lib/rack/request.rb, line 415
def accept_language
  parse_http_accept_header(get_header("HTTP_ACCEPT_LANGUAGE"))
end
authority()
# File lib/rack/request.rb, line 200
def authority
  get_header(SERVER_NAME) + ':' + get_header(SERVER_PORT)
end
base_url()
# File lib/rack/request.rb, line 392
def base_url
  url = "#{scheme}://#{host}"
  url << ":#{port}" if port != DEFAULT_PORTS[scheme]
  url
end
body()
# File lib/rack/request.rb, line 126
def body;            get_header(RACK_INPUT)                         end
content_charset()

The character set of the request body if a “charset” media type parameter was given, or nil if no “charset” was specified. Note that, per RFC2616, text/* media types that specify no explicit charset are to be considered ISO-8859-1.

# File lib/rack/request.rb, line 290
def content_charset
  media_type_params['charset']
end
content_length()
# File lib/rack/request.rb, line 135
def content_length;  get_header('CONTENT_LENGTH')                   end
content_type()
# File lib/rack/request.rb, line 216
def content_type
  content_type = get_header('CONTENT_TYPE')
  content_type.nil? || content_type.empty? ? nil : content_type
end
cookies()
# File lib/rack/request.rb, line 204
def cookies
  hash = fetch_header(RACK_REQUEST_COOKIE_HASH) do |k|
    set_header(k, {})
  end
  string = get_header HTTP_COOKIE

  return hash if string == get_header(RACK_REQUEST_COOKIE_STRING)
  hash.replace Utils.parse_cookies_header get_header HTTP_COOKIE
  set_header(RACK_REQUEST_COOKIE_STRING, string)
  hash
end
delete?()

Checks the HTTP request method (or verb) to see if it was of type DELETE

# File lib/rack/request.rb, line 157
def delete?;  request_method == DELETE  end
delete_param(k)

Destructively delete a parameter, whether it's in #GET or #POST. Returns the value of the deleted parameter.

If the parameter is in both #GET and #POST, the #POST value takes precedence since that's how params works.

env['rack.input'] is not touched.

# File lib/rack/request.rb, line 388
def delete_param(k)
  [ self.POST.delete(k), self.GET.delete(k) ].compact.first
end
form_data?()

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 also assumed to contain form-data when no Content-Type header is provided and the #request_method is #POST.

# File lib/rack/request.rb, line 302
def form_data?
  type = media_type
  meth = get_header(RACK_METHODOVERRIDE_ORIGINAL_METHOD) || get_header(REQUEST_METHOD)
  (meth == POST && type.nil?) || FORM_DATA_MEDIA_TYPES.include?(type)
end
fullpath()
# File lib/rack/request.rb, line 407
def fullpath
  query_string.empty? ? path : "#{path}?#{query_string}"
end
get?()

Checks the HTTP request method (or verb) to see if it was of type #GET

# File lib/rack/request.rb, line 160
def get?;     request_method == GET       end
head?()

Checks the HTTP request method (or verb) to see if it was of type HEAD

# File lib/rack/request.rb, line 163
def head?;    request_method == HEAD      end
host()
# File lib/rack/request.rb, line 233
def host
  # Remove port number.
  host_with_port.to_s.sub(/:\d+\z/, '')
end
host_with_port()
# File lib/rack/request.rb, line 225
def host_with_port
  if forwarded = get_header(HTTP_X_FORWARDED_HOST)
    forwarded.split(/,\s?/).last
  else
    get_header(HTTP_HOST) || "#{get_header(SERVER_NAME) || get_header(SERVER_ADDR)}:#{get_header(SERVER_PORT)}"
  end
end
ip()
# File lib/rack/request.rb, line 256
def ip
  remote_addrs = split_ip_addresses(get_header('REMOTE_ADDR'))
  remote_addrs = reject_trusted_ip_addresses(remote_addrs)

  return remote_addrs.first if remote_addrs.any?

  forwarded_ips = split_ip_addresses(get_header('HTTP_X_FORWARDED_FOR'))

  return reject_trusted_ip_addresses(forwarded_ips).last || get_header("REMOTE_ADDR")
end

Checks the HTTP request method (or verb) to see if it was of type LINK

logger()
# File lib/rack/request.rb, line 136
def logger;          get_header(RACK_LOGGER)                        end
media_type()

The media type (type/subtype) portion of the CONTENT_TYPE header without any media type parameters. e.g., when CONTENT_TYPE is “text/plain;charset=utf-8”, the media-type is “text/plain”.

For more information on the use of media types in HTTP, see: www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7

# File lib/rack/request.rb, line 273
def media_type
  MediaType.type(content_type)
end
media_type_params()

The media type parameters provided in CONTENT_TYPE as a Hash, or an empty Hash if no CONTENT_TYPE or media-type parameters were provided. e.g., when the CONTENT_TYPE is “text/plain;charset=utf-8”, this method responds with the following Hash:

{ 'charset' => 'utf-8' }
# File lib/rack/request.rb, line 282
def media_type_params
  MediaType.params(content_type)
end
multithread?()
# File lib/rack/request.rb, line 138
def multithread?;    get_header(RACK_MULTITHREAD)                   end
options?()

Checks the HTTP request method (or verb) to see if it was of type OPTIONS

# File lib/rack/request.rb, line 166
def options?; request_method == OPTIONS end
params()

The union of #GET and #POST data.

Note that modifications will not be persisted in the env. Use #update_param or #delete_param if you want to destructively modify params.

# File lib/rack/request.rb, line 357
def params
  self.GET.merge(self.POST)
rescue EOFError
  self.GET.dup
end
parseable_data?()

Determine whether the request body contains data by checking the request #media_type against registered parse-data media-types

# File lib/rack/request.rb, line 310
def parseable_data?
  PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
end
patch?()

Checks the HTTP request method (or verb) to see if it was of type PATCH

# File lib/rack/request.rb, line 172
def patch?;   request_method == PATCH   end
path()
# File lib/rack/request.rb, line 403
def path
  script_name + path_info
end
path_info()
# File lib/rack/request.rb, line 130
def path_info;       get_header(PATH_INFO).to_s                     end
path_info=(s)
# File lib/rack/request.rb, line 131
def path_info=(s);   set_header(PATH_INFO, s.to_s)                  end
port()
# File lib/rack/request.rb, line 238
def port
  if port = host_with_port.split(/:/)[1]
    port.to_i
  elsif port = get_header(HTTP_X_FORWARDED_PORT)
    port.to_i
  elsif has_header?(HTTP_X_FORWARDED_HOST)
    DEFAULT_PORTS[scheme]
  elsif has_header?(HTTP_X_FORWARDED_PROTO)
    DEFAULT_PORTS[get_header(HTTP_X_FORWARDED_PROTO).split(',')[0]]
  else
    get_header(SERVER_PORT).to_i
  end
end
post?()

Checks the HTTP request method (or verb) to see if it was of type #POST

# File lib/rack/request.rb, line 175
def post?;    request_method == POST    end
put?()

Checks the HTTP request method (or verb) to see if it was of type PUT

# File lib/rack/request.rb, line 178
def put?;     request_method == PUT     end
query_string()
# File lib/rack/request.rb, line 134
def query_string;    get_header(QUERY_STRING).to_s                  end
referer()

the referer of the client

Also aliased as: referrer
# File lib/rack/request.rb, line 141
def referer;         get_header('HTTP_REFERER')                     end
referrer()
Alias for: referer
request_method()
# File lib/rack/request.rb, line 133
def request_method;  get_header(REQUEST_METHOD)                     end
scheme()
# File lib/rack/request.rb, line 186
def scheme
  if get_header(HTTPS) == 'on'
    'https'
  elsif get_header(HTTP_X_FORWARDED_SSL) == 'on'
    'https'
  elsif get_header(HTTP_X_FORWARDED_SCHEME)
    get_header(HTTP_X_FORWARDED_SCHEME)
  elsif get_header(HTTP_X_FORWARDED_PROTO)
    get_header(HTTP_X_FORWARDED_PROTO).split(',')[0]
  else
    get_header(RACK_URL_SCHEME)
  end
end
script_name()
# File lib/rack/request.rb, line 127
def script_name;     get_header(SCRIPT_NAME).to_s                   end
script_name=(s)
# File lib/rack/request.rb, line 128
def script_name=(s); set_header(SCRIPT_NAME, s.to_s)                end
session()
# File lib/rack/request.rb, line 144
def session
  fetch_header(RACK_SESSION) do |k|
    set_header RACK_SESSION, default_session
  end
end
session_options()
# File lib/rack/request.rb, line 150
def session_options
  fetch_header(RACK_SESSION_OPTIONS) do |k|
    set_header RACK_SESSION_OPTIONS, {}
  end
end
ssl?()
# File lib/rack/request.rb, line 252
def ssl?
  scheme == 'https'
end
trace?()

Checks the HTTP request method (or verb) to see if it was of type TRACE

# File lib/rack/request.rb, line 181
def trace?;   request_method == TRACE   end
trusted_proxy?(ip)
# File lib/rack/request.rb, line 419
def trusted_proxy?(ip)
  ip =~ /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|\A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/i
end

Checks the HTTP request method (or verb) to see if it was of type UNLINK

update_param(k, v)

Destructively update a parameter, whether it's in #GET and/or #POST. Returns nil.

The parameter is updated wherever it was previous defined, so #GET, #POST, or both. If it wasn't previously defined, it's inserted into #GET.

env['rack.input'] is not touched.

# File lib/rack/request.rb, line 368
def update_param(k, v)
  found = false
  if self.GET.has_key?(k)
    found = true
    self.GET[k] = v
  end
  if self.POST.has_key?(k)
    found = true
    self.POST[k] = v
  end
  unless found
    self.GET[k] = v
  end
end
url()

Tries to return a remake of the original request URL as a string.

# File lib/rack/request.rb, line 399
def url
  base_url + fullpath
end
user_agent()
# File lib/rack/request.rb, line 137
def user_agent;      get_header('HTTP_USER_AGENT')                  end
values_at(*keys)

like Hash#values_at

# File lib/rack/request.rb, line 444
def values_at(*keys)
  keys.map { |key| params[key] }
end
xhr?()
# File lib/rack/request.rb, line 221
def xhr?
  get_header("HTTP_X_REQUESTED_WITH") == "XMLHttpRequest"
end