Class: Protocol::HTTP::Body::Readable

Inherits:
Object
  • Object
show all
Defined in:
lib/protocol/http/body/readable.rb

Overview

def finish -> buffer the stream and close it. def close(error = nil) -> close the stream immediately. end

Direct Known Subclasses

Buffered, File, Head, Wrapper

Instance Method Summary collapse

Instance Method Details

#call(stream) ⇒ Object

Write the body to the given stream.



54
55
56
57
58
59
60
 
# File 'lib/protocol/http/body/readable.rb', line 54

def call(stream)
	while chunk = self.read
		stream.write(chunk)
	end
ensure
	stream.close
end

#close(error = nil) ⇒ Object

The consumer can call stop to signal that the stream output has terminated.



21
22
 
# File 'lib/protocol/http/body/readable.rb', line 21

def close(error = nil)
end

#each ⇒ Object

Enumerate all chunks until finished, then invoke ‘#close`.



69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/protocol/http/body/readable.rb', line 69

def each
	return to_enum(:each) unless block_given?
	
	begin
		while chunk = self.read
			yield chunk
		end
	ensure
		self.close($!)
	end
end

#empty? ⇒ Boolean

Optimistically determine whether read (may) return any data. If this returns true, then calling read will definitely return nil. If this returns false, then calling read may return nil.

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/protocol/http/body/readable.rb', line 27

def empty?
	false
end

#finish ⇒ Object

Read all remaining chunks into a buffered body and close the underlying input.



63
64
65
66
 
# File 'lib/protocol/http/body/readable.rb', line 63

def finish
	# Internally, this invokes `self.each` which then invokes `self.close`.
	Buffered.for(self)
end

#join ⇒ Object

Read all remaining chunks into a single binary string using ‘#each`.



82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/protocol/http/body/readable.rb', line 82

def join
	buffer = String.new.force_encoding(Encoding::BINARY)
	
	self.each do |chunk|
		buffer << chunk
	end
	
	if buffer.empty?
		return nil
	else
		return buffer
	end
end

#length ⇒ Object 



38
39
40
 
# File 'lib/protocol/http/body/readable.rb', line 38

def length
	nil
end

#read ⇒ Object

Read the next available chunk.



43
44
45
 
# File 'lib/protocol/http/body/readable.rb', line 43

def read
	nil
end

#ready? ⇒ Boolean

Whether calling read will return a chunk of data without blocking. We prefer pessimistic implementation, and thus default to ‘false`.

Returns:

  • (Boolean) 


34
35
36
 
# File 'lib/protocol/http/body/readable.rb', line 34

def ready?
	false
end

#stream? ⇒ Boolean

Should the internal mechanism prefer to use #call?

Returns:

  • (Boolean) 


49
50
51
 
# File 'lib/protocol/http/body/readable.rb', line 49

def stream?
	false
end