Class: Protocol::Rack::Body::Enumerable

Inherits:
HTTP::Body::Readable
  • Object
show all
Defined in:
lib/protocol/rack/body/enumerable.rb

Overview

Wraps the rack response body.

The rack body must respond to each and must only yield String values. If the body responds to close, it will be called after iteration.

Constant Summary collapse

CONTENT_LENGTH = 
'content-length'.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(body, length) ⇒ Enumerable

Initialize the output wrapper.



32
33
34
35
36
37
 
# File 'lib/protocol/rack/body/enumerable.rb', line 32

def initialize(body, length)
  @length = length
  @body = body
  
  @chunks = nil
end

Instance Attribute Details

#body ⇒ Object (readonly)

The rack response body.



40
41
42
 
# File 'lib/protocol/rack/body/enumerable.rb', line 40

def body
  @body
end

#length ⇒ Object (readonly)

The content length of the rack response body.



43
44
45
 
# File 'lib/protocol/rack/body/enumerable.rb', line 43

def length
  @length
end

Class Method Details

.wrap(body, length = nil) ⇒ Object

Wraps an array into a buffered body.



20
21
22
23
24
25
26
27
 
# File 'lib/protocol/rack/body/enumerable.rb', line 20

def self.wrap(body, length = nil)
  if body.is_a?(Array)
    length ||= body.sum(&:bytesize)
    return self.new(body, length)
  else
    return self.new(body, length)
  end
end

Instance Method Details

#call(stream) ⇒ Object 



80
81
82
83
84
 
# File 'lib/protocol/rack/body/enumerable.rb', line 80

def call(stream)
  @body.call(stream)
ensure
  self.close($!)
end

#close(error = nil) ⇒ Object

Close the response body.



56
57
58
59
60
61
62
63
64
65
 
# File 'lib/protocol/rack/body/enumerable.rb', line 56

def close(error = nil)
  if @body and @body.respond_to?(:close)
    @body.close
  end
  
  @body = nil
  @chunks = nil
  
  super
end

#each(&block) ⇒ Object

Enumerate the response body.



70
71
72
73
74
 
# File 'lib/protocol/rack/body/enumerable.rb', line 70

def each(&block)
  @body.each(&block)
ensure
  self.close($!)
end

#empty? ⇒ Boolean

Whether the body is empty.

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/protocol/rack/body/enumerable.rb', line 46

def empty?
  @length == 0 or (@body.respond_to?(:empty?) and @body.empty?)
end

#inspect ⇒ Object 



96
97
98
 
# File 'lib/protocol/rack/body/enumerable.rb', line 96

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

#read ⇒ Object

Read the next chunk from the response body.



88
89
90
91
92
93
94
 
# File 'lib/protocol/rack/body/enumerable.rb', line 88

def read
  @chunks ||= @body.to_enum(:each)
  
  return @chunks.next
rescue StopIteration
  return nil
end

#ready? ⇒ Boolean

Whether the body can be read immediately.

Returns:

  • (Boolean) 


51
52
53
 
# File 'lib/protocol/rack/body/enumerable.rb', line 51

def ready?
  body.is_a?(Array) or body.respond_to?(:to_ary)
end

#stream? ⇒ Boolean

Returns:

  • (Boolean) 


76
77
78
 
# File 'lib/protocol/rack/body/enumerable.rb', line 76

def stream?
  !@body.respond_to?(:each)
end