# class Net::HTTPResponse

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?() click to toggle source

true if the response has a body.

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

### Private Class Methods

each_response_header(sock) { |key, value| ... } click to toggle 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) click to toggle 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) click to toggle 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() click to toggle source

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
    }

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

Also aliased as: entity
body=(value) click to toggle source

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

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

entity()
Alias for: body
inspect() click to toggle source

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

read_body(dest = nil, &block) click to toggle source

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
    }

    # File lib/net/http/response.rb, line 196
    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

value() click to toggle source

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

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

### Private Instance Methods

procdest(dest, block) click to toggle source

    # File lib/net/http/response.rb, line 337
    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) click to toggle source

    # File lib/net/http/response.rb, line 283
    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() click to toggle source

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