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.

[View source]

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

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:

[View source]

243
244
245
246
247
248
249
250
 
# File 'lib/httpx/response/body.rb', line 243

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

[View source]

150
151
152
153
154
155
156
157
158
 
# File 'lib/httpx/response/body.rb', line 150

def ==(other)
  object_id == other.object_id || begin
    if other.respond_to?(:read)
      _with_same_buffer_pos { FileUtils.compare_stream(@buffer, other) }
    else
      to_s == other.to_s
    end
  end
end

#bytesize ⇒ Object

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

[View source]

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

def bytesize
  @length
end

#close ⇒ Object

closes/cleans the buffer, resets everything

[View source]

141
142
143
144
145
146
147
148
 
# File 'lib/httpx/response/body.rb', line 141

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

#closed? ⇒ Boolean

Returns:

  • (Boolean)
[View source]

46
47
48
 
# File 'lib/httpx/response/body.rb', line 46

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"))
[View source]

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

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
end

#each ⇒ Object

yields the payload in chunks.

[View source]

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

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.

Returns:

  • (Boolean)
[View source]

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

def empty?
  @length.zero?
end

#filename ⇒ Object

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

[View source]

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

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

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

#initialize_dup(other) ⇒ Object

[View source]

40
41
42
43
44
 
# File 'lib/httpx/response/body.rb', line 40

def initialize_dup(other)
  super

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

#inspect ⇒ Object

:nocov:

[View source]

161
162
163
164
165
 
# File 'lib/httpx/response/body.rb', line 161

def inspect
  "#<HTTPX::Response::Body:#{object_id} " \
    "@state=#{@state} " \
    "@length=#{@length}>"
end

#read(*args) ⇒ Object

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

[View source]

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

def read(*args)
  return unless @buffer

  unless @reader
    rewind
    @reader = @buffer
  end

  @reader.read(*args)
end

#rewind ⇒ Object

rewinds the response payload buffer.

[View source]

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

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.

[View source]

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

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.

[View source]

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

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

  return 0 if chunk.empty?

  chunk = decode_chunk(chunk)

  size = chunk.bytesize
  @length += size
  transition(:open)
  @buffer.write(chunk)

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