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.



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

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.



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

def close(error = nil)
end

#each ⇒ Object

Enumerate all chunks until finished, then invoke #close.



68
69
70
71
72
73
74
 
# File 'lib/protocol/http/body/readable.rb', line 68

def each
  while chunk = self.read
    yield chunk
  end
ensure
  self.close($!)
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) 


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

def empty?
  false
end

#finish ⇒ Object

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



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

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.



77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/protocol/http/body/readable.rb', line 77

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 



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

def length
  nil
end

#read ⇒ Object

Read the next available chunk.



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

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) 


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

def ready?
  false
end

#stream? ⇒ Boolean

Should the internal mechanism prefer to use #call?

Returns:

  • (Boolean) 


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

def stream?
  false
end