Class: Net::HTTPResponse

# File 'lib/net/http/response.rb', line 26

def exception_type   # :nodoc: internal use only
  self::EXCEPTION_TYPE
end

# File 'lib/net/http/response.rb', line 30

def read_new(sock)   #:nodoc: internal use only
  httpv, code, msg = read_status_line(sock)
  res = response_class(code).new(httpv, code, msg)
  each_response_header(sock) do |k,v|
    res.add_field k, v
  end
  res
end

# File 'lib/net/http/response.rb', line 41

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

# File 'lib/net/http/response.rb', line 48

def response_class(code)
  CODE_TO_OBJ[code] or
  CODE_CLASS_TO_OBJ[code[0,1]] or
  Net::HTTPUnknownResponse
end

# File 'lib/net/http/response.rb', line 269

def body=(value)
  @body = value
end

# File 'lib/net/http/response.rb', line 114

attr_reader :body_encoding

# File 'lib/net/http/response.rb', line 118

def body_encoding=(value)
  value = Encoding.find(value) if value.is_a?(String)
  @body_encoding = value
end

# File 'lib/net/http/response.rb', line 97

attr_reader :code

# File 'lib/net/http/response.rb', line 109

attr_accessor :decode_content

# File 'lib/net/http/response.rb', line 273

alias entity body   #:nodoc: obsolete

# File 'lib/net/http/response.rb', line 92

attr_reader :http_version

# File 'lib/net/http/response.rb', line 125

attr_accessor :ignore_eof

# File 'lib/net/http/response.rb', line 100

attr_reader :message

# File 'lib/net/http/response.rb', line 101

alias msg message   # :nodoc: obsolete

# File 'lib/net/http/response.rb', line 105

attr_reader :uri

# File 'lib/net/http/response.rb', line 154

def uri= uri # :nodoc:
  @uri = uri.dup if uri
end

# File 'lib/net/http/response.rb', line 135

def code_type   #:nodoc:
  self.class
end

# File 'lib/net/http/response.rb', line 278

def detect_encoding(str, encoding=nil)
  if encoding
  elsif encoding = type_params['charset']
  elsif encoding = check_bom(str)
  else
    encoding = case content_type&.downcase
    when %r{text/x(?:ht)?ml|application/(?:[^]\+)?xml}
      /\A<xml[ \t\r\n]+
        version[ \t\r\n]*=[ \t\r\n]*(?:"[0-9.]+"|'[0-9.]*')[ \t\r\n]+
        encoding[ \t\r\n]*=[ \t\r\n]*
        (?:"([A-Za-z][\-A-Za-z0-9._]*)"|'([A-Za-z][\-A-Za-z0-9._]*)')/x =~ str
      encoding = $1 || $2 || Encoding::UTF_8
    when %r{text/html.*}
      sniff_encoding(str)
    end
  end
  return encoding
end

# File 'lib/net/http/response.rb', line 139

def error!   #:nodoc:
  message = @code
  message += ' ' + @message.dump if @message
  raise error_type().new(message, self)
end

# File 'lib/net/http/response.rb', line 145

def error_type   #:nodoc:
  self.class::EXCEPTION_TYPE
end

# File 'lib/net/http/response.rb', line 404

def extracting_encodings_from_meta_elements(value)
  # http://dev.w3.org/html5/spec/fetching-resources.html#algorithm-for-extracting-an-encoding-from-a-meta-element
  if /charset[\t\n\f\r ]*=(?:"([^"]*)"|'([^']*)'|["']|\z|([^\t\n\f\r ;]+))/i =~ value
    return $1 || $2 || $3
  end
  return nil
end

# File 'lib/net/http/response.rb', line 369

def get_attribute(ss)
  ss.scan(/[\t\n\f\r \/]*/)
  if ss.peek(1) == '>'
    ss.getch
    return nil
  end
  name = ss.scan(/[^=\t\n\f\r \/>]*/)
  name.downcase!
  raise if name.empty?
  ss.skip(/[\t\n\f\r ]*/)
  if ss.getch != '='
    value = ''
    return [name, value]
  end
  ss.skip(/[\t\n\f\r ]*/)
  case ss.peek(1)
  when '"'
    ss.getch
    value = ss.scan(/[^"]+/)
    value.downcase!
    ss.getch
  when "'"
    ss.getch
    value = ss.scan(/[^']+/)
    value.downcase!
    ss.getch
  when '>'
    value = ''
  else
    value = ss.scan(/[^\t\n\f\r >]+/)
    value.downcase!
  end
  [name, value]
end

# File 'lib/net/http/response.rb', line 167

def header   #:nodoc:
  warn "Net::HTTPResponse#header is obsolete", uplevel: 1 if $VERBOSE
  self
end

# File 'lib/net/http/response.rb', line 421

def inflater # :nodoc:
  return yield @socket unless Net::HTTP::HAVE_ZLIB
  return yield @socket unless @decode_content
  return yield @socket if self['content-range']

  v = self['content-encoding']
  case v&.downcase
  when 'deflate', 'gzip', 'x-gzip' then
    self.delete 'content-encoding'

    inflate_body_io = Inflater.new(@socket)

    begin
      yield inflate_body_io
      success = true
    ensure
      begin
        inflate_body_io.finish
        if self['content-length']
          self['content-length'] = inflate_body_io.bytes_inflated.to_s
        end
      rescue => err
        # Ignore #finish's error if there is an exception from yield
        raise err if success
      end
    end
  when 'none', 'identity' then
    self.delete 'content-encoding'

    yield @socket
  else
    yield @socket
  end
end

# File 'lib/net/http/response.rb', line 127

def inspect
  "#<#{self.class} #{@code} #{@message} readbody=#{@read}>"
end

# File 'lib/net/http/response.rb', line 510

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

# File 'lib/net/http/response.rb', line 220

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

  case enc = @body_encoding
  when Encoding, false, nil
    # Encoding: force given encoding
    # false/nil: do not force encoding
  else
    # other value: detect encoding from body
    enc = detect_encoding(@body)
  end

  @body.force_encoding(enc) if enc

  @body
end

# File 'lib/net/http/response.rb', line 456

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, @ignore_eof
      return
    end
    clen = range_length()
    if clen
      @socket.read clen, dest
      return
    end
    @socket.read_all dest
  end
end

# File 'lib/net/http/response.rb', line 486

def read_chunked(dest, chunk_data_io) # :nodoc:
  total = 0
  while true
    line = @socket.readline
    hexlen = line.slice(/[0-9a-fA-F]+/) or
        raise Net::HTTPBadResponse, "wrong chunk size line: #{line}"
    len = hexlen.hex
    break if len == 0
    begin
      chunk_data_io.read len, dest
    ensure
      total += len
      @socket.read 2   # \r\n
    end
  end
  until @socket.readline.empty?
    # none
  end
end

# File 'lib/net/http/response.rb', line 172

def read_header   #:nodoc:
  warn "Net::HTTPResponse#read_header is obsolete", uplevel: 1 if $VERBOSE
  self
end

# File 'lib/net/http/response.rb', line 181

def reading_body(sock, reqmethodallowbody)  #:nodoc: internal use only
  @socket = sock
  @body_exist = reqmethodallowbody && self.class.body_permitted?
  begin
    yield
    self.body   # ensure to read body
  ensure
    @socket = nil
  end
end

# File 'lib/net/http/response.rb', line 162

def response   #:nodoc:
  warn "Net::HTTPResponse#response is obsolete", uplevel: 1 if $VERBOSE
  self
end

# File 'lib/net/http/response.rb', line 328

def scanning_meta(str)
  require 'strscan'
  ss = StringScanner.new(str)
  if ss.scan_until(/<meta[\t\n\f\r ]*/)
    attrs = {} # attribute_list
    got_pragma = false
    need_pragma = nil
    charset = nil

    # step: Attributes
    while attr = get_attribute(ss)
      name, value = *attr
      next if attrs[name]
      attrs[name] = true
      case name
      when 'http-equiv'
        got_pragma = true if value == 'content-type'
      when 'content'
        encoding = extracting_encodings_from_meta_elements(value)
        unless charset
          charset = encoding
        end
        need_pragma = true
      when 'charset'
        need_pragma = false
        charset = value
      end
    end

    # step: Processing
    return if need_pragma.nil?
    return if need_pragma && !got_pragma

    charset = Encoding.find(charset) rescue nil
    return unless charset
    charset = Encoding::UTF_8 if charset == Encoding::UTF_16
    return charset # tentative
  end
  nil
end

# File 'lib/net/http/response.rb', line 298

def sniff_encoding(str, encoding=nil)
  # the encoding sniffing algorithm
  # http://www.w3.org/TR/html5/parsing.html#determining-the-character-encoding
  if enc = scanning_meta(str)
    enc
  # 6. last visited page or something
  # 7. frequency
  elsif str.ascii_only?
    Encoding::US_ASCII
  elsif str.dup.force_encoding(Encoding::UTF_8).valid_encoding?
    Encoding::UTF_8
  end
  # 8. implementation-defined or user-specified
end

# File 'lib/net/http/response.rb', line 506

def stream_check
  raise IOError, 'attempt to read body out of block' if @socket.closed?
end

# File 'lib/net/http/response.rb', line 150

def value
  error! unless self.kind_of?(Net::HTTPSuccess)
end