Class: HTTPX::Response::Body

Inherits:
Object
  • Object
show all
Defined in:
lib/httpx/response/body.rb

Overview

Implementation of the HTTP Response body as a buffer which implements the IO writer protocol (for buffering the response payload), the IO reader protocol (for consuming the response payload), and can be iterated over (via #each, which yields the payload in chunks).

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(response, options) ⇒ Body

initialized with the corresponding HTTPX::Response response and HTTPX::Options options.



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/httpx/response/body.rb', line 18

def initialize(response, options)
  @response = response
  @headers = response.headers
  @options = options
  @window_size = options.window_size
  @encodings = []
  @length = 0
  @buffer = nil
  @reader = nil
  @state = :idle

  # initialize response encoding
  @encoding = if (enc = response.content_type.charset)
    begin
      Encoding.find(enc)
    rescue ArgumentError
      Encoding::BINARY
    end
  else
    Encoding::BINARY
  end

  initialize_inflaters
end

Instance Attribute Details

#encoding ⇒ Object (readonly)

the payload encoding (i.e. “utf-8”, “ASCII-8BIT”)



9
10
11
 
# File 'lib/httpx/response/body.rb', line 9

def encoding
  @encoding
end

#encodings ⇒ Object (readonly)

Array of encodings contained in the response “content-encoding” header.



12
13
14
 
# File 'lib/httpx/response/body.rb', line 12

def encodings
  @encodings
end

Class Method Details

.initialize_inflater_by_encoding(encoding, response, **kwargs) ⇒ Object

:nodoc:



234
235
236
237
238
239
240
241
 
# File 'lib/httpx/response/body.rb', line 234

def initialize_inflater_by_encoding(encoding, response, **kwargs) # :nodoc:
  case encoding
  when "gzip"
    Transcoder::GZIP.decode(response, **kwargs)
  when "deflate"
    Transcoder::Deflate.decode(response, **kwargs)
  end
end

Instance Method Details

#==(other) ⇒ Object 



153
154
155
156
157
158
159
160
 
# File 'lib/httpx/response/body.rb', line 153

def ==(other)
  super || case other
           when Response::Body
             @buffer == other.buffer
           else
             @buffer = other
           end
end

#bytesize ⇒ Object

size of the decoded response payload. May differ from “content-length” header if response was encoded over-the-wire.



83
84
85
 
# File 'lib/httpx/response/body.rb', line 83

def bytesize
  @length
end

#close ⇒ Object

closes/cleans the buffer, resets everything



144
145
146
147
148
149
150
151
 
# File 'lib/httpx/response/body.rb', line 144

def close
  if @buffer
    @buffer.close
    @buffer = nil
  end
  @length = 0
  transition(:closed)
end

#closed? ⇒ Boolean 



49
50
51
 
# File 'lib/httpx/response/body.rb', line 49

def closed?
  @state == :closed
end

#copy_to(dest) ⇒ Object

copies the payload to dest.

body.copy_to("path/to/file")
body.copy_to(Pathname.new("path/to/file"))
body.copy_to(File.new("path/to/file"))



129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/httpx/response/body.rb', line 129

def copy_to(dest)
  return unless @buffer

  rewind

  if dest.respond_to?(:path) && @buffer.respond_to?(:path)
    FileUtils.mv(@buffer.path, dest.path)
  else
    IO.copy_stream(@buffer, dest)
  end
ensure
  close
end

#each ⇒ Object

yields the payload in chunks.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/httpx/response/body.rb', line 88

def each
  return enum_for(__method__) unless block_given?

  begin
    if @buffer
      rewind
      while (chunk = @buffer.read(@window_size))
        yield(chunk.force_encoding(@encoding))
      end
    end
  ensure
    close
  end
end

#empty? ⇒ Boolean

whether the payload is empty.



120
121
122
 
# File 'lib/httpx/response/body.rb', line 120

def empty?
  @length.zero?
end

#filename ⇒ Object

returns the declared filename in the “contennt-disposition” header, when present.



104
105
106
107
108
 
# File 'lib/httpx/response/body.rb', line 104

def filename
  return unless @headers.key?("content-disposition")

  Utils.get_filename(@headers["content-disposition"])
end

#initialize_dup(other) ⇒ Object 



43
44
45
46
47
 
# File 'lib/httpx/response/body.rb', line 43

def initialize_dup(other)
  super

  @buffer = other.instance_variable_get(:@buffer).dup
end

#inspect ⇒ Object

:nocov:



163
164
165
166
167
 
# File 'lib/httpx/response/body.rb', line 163

def inspect
  "#<#{self.class}:#{object_id} " \
    "@state=#{@state} " \
    "@length=#{@length}>"
end

#read(*args) ⇒ Object

reads a chunk from the payload (implementation of the IO reader protocol).



70
71
72
73
74
75
76
77
78
79
 
# File 'lib/httpx/response/body.rb', line 70

def read(*args)
  return unless @buffer

  unless @reader
    rewind
    @reader = @buffer
  end

  @reader.read(*args)
end

#rewind ⇒ Object

rewinds the response payload buffer.



171
172
173
174
175
176
177
178
 
# File 'lib/httpx/response/body.rb', line 171

def rewind
  return unless @buffer

  # in case there's some reading going on
  @reader = nil

  @buffer.rewind
end

#to_s ⇒ Object Also known as: to_str

returns the full response payload as a string.



111
112
113
114
115
 
# File 'lib/httpx/response/body.rb', line 111

def to_s
  return "".b unless @buffer

  @buffer.to_s
end

#write(chunk) ⇒ Object

write the response payload chunk into the buffer. Inflates the chunk when required and supported.



55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/httpx/response/body.rb', line 55

def write(chunk)
  return if @state == :closed

  return 0 if chunk.empty?

  chunk = decode_chunk(chunk)

  transition(:open)
  @buffer.write(chunk)

  @response.emit(:chunk_received, chunk)
  chunk.bytesize
end