class Net::HTTPResponse

Parent:: Object
Included modules:: Net::HTTPHeader

frozen_string_literal: false HTTP response class.

This class wraps together the response header and the response body (the entity requested).

It mixes in the HTTPHeader module, which provides access to response header values both via hash-like methods and via individual readers.

Note that each possible HTTP response code defines its own HTTPResponse subclass. These are listed below.

All classes are defined under the Net module. Indentation indicates inheritance. For a list of the classes see Net::HTTP.

Constants

CODE_CLASS_TO_OBJ
CODE_TO_OBJ

Attributes

code[R]

The HTTP result code string. For example, '302'. You can also determine the response type by examining which response subclass the response object is an instance of.

decode_content[RW]

Set to true automatically when the request did not contain an Accept-Encoding header from the user.

http_version[R]

The HTTP version supported by the server.

message[R]

The HTTP result message sent by the server. For example, 'Not Found'.

msg[R]

The HTTP result message sent by the server. For example, 'Not Found'.

uri[R]

The URI used to fetch this response. The response URI is only available if a URI was used to create the request.

Public Class Methods

body_permitted?() Show source

# File lib/net/http/response.rb, line 20
def body_permitted?
  self::HAS_BODY
end

true if the response has a body.

Private Class Methods

each_response_header(sock) { |key, value| ... } Show source

# File lib/net/http/response.rb, line 52
def each_response_header(sock)
  key = value = nil
  while true
    line = sock.readuntil("\n", true).sub(/\s+\z/, '')
    break if line.empty?
    if line[0] == ?\s or line[0] == ?\t and value
      value << ' ' unless value.empty?
      value << line.strip
    else
      yield key, value if key
      key, value = line.strip.split(/\s*:\s*/, 2)
      raise Net::HTTPBadResponse, 'wrong header line format' if value.nil?
    end
  end
  yield key, value if key
end

read_status_line(sock) Show source

# File lib/net/http/response.rb, line 39
def read_status_line(sock)
  str = sock.readline
  m = /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)(?:\s+(.*))?\z/in.match(str) or
    raise Net::HTTPBadResponse, "wrong status line: #{str.dump}"
  m.captures
end

response_class(code) Show source

# File lib/net/http/response.rb, line 46
def response_class(code)
  CODE_TO_OBJ[code] or
  CODE_CLASS_TO_OBJ[code[0,1]] or
  Net::HTTPUnknownResponse
end

Public Instance Methods

body() Show source

# File lib/net/http/response.rb, line 226
def body
  read_body()
end

Returns the full entity body.

Calling this method a second or subsequent time will return the string already read.

http.request_get('/index.html') {|res|
  puts res.body
}

http.request_get('/index.html') {|res|
  p res.body.object_id   # 538149362
  p res.body.object_id   # 538149362
}

Also aliased as: entity

body=(value) Show source

# File lib/net/http/response.rb, line 232
def body=(value)
  @body = value
end

Because it may be necessary to modify the body, Eg, decompression this method facilitates that.

entity()

Alias for: body

inspect() Show source

# File lib/net/http/response.rb, line 107
def inspect
  "#<#{self.class} #{@code} #{@message} readbody=#{@read}>"
end

read_body(dest = nil, &block) Show source

# File lib/net/http/response.rb, line 194
def read_body(dest = nil, &block)
  if @read
    raise IOError, "#{self.class}\#read_body called twice" if dest or block
    return @body
  end
  to = procdest(dest, block)
  stream_check
  if @body_exist
    read_body_0 to
    @body = to
  else
    @body = nil
  end
  @read = true

  @body
end

Gets the entity body returned by the remote HTTP server.

If a block is given, the body is passed to the block, and the body is provided in fragments, as it is read in from the socket.

Calling this method a second or subsequent time for the same HTTPResponse object will return the value already read.

http.request_get('/index.html') {|res|
  puts res.read_body
}

http.request_get('/index.html') {|res|
  p res.read_body.object_id   # 538149362
  p res.read_body.object_id   # 538149362
}

# using iterator
http.request_get('/index.html') {|res|
  res.read_body do |segment|
    print segment
  end
}

value() Show source

# File lib/net/http/response.rb, line 128
def value
  error! unless self.kind_of?(Net::HTTPSuccess)
end

Raises an HTTP error if the response is not 2xx (success).

Private Instance Methods

procdest(dest, block) Show source

# File lib/net/http/response.rb, line 334
def procdest(dest, block)
  raise ArgumentError, 'both arg and block given for HTTP method' if
    dest and block
  if block
    Net::ReadAdapter.new(block)
  else
    dest || ''
  end
end

read_body_0(dest) Show source

# File lib/net/http/response.rb, line 280
def read_body_0(dest)
  inflater do |inflate_body_io|
    if chunked?
      read_chunked dest, inflate_body_io
      return
    end

    @socket = inflate_body_io

    clen = content_length()
    if clen
      @socket.read clen, dest, true   # ignore EOF
      return
    end
    clen = range_length()
    if clen
      @socket.read clen, dest
      return
    end
    @socket.read_all dest
  end
end

stream_check() Show source

# File lib/net/http/response.rb, line 330
def stream_check
  raise IOError, 'attempt to read body out of block' if @socket.closed?
end

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Docs

Docs4dev

Title here