Class: Protocol::Rack::Input
- Inherits:
-
Object
- Object
- Protocol::Rack::Input
- Includes:
- HTTP::Body::Stream::Reader
- Defined in:
- lib/protocol/rack/input.rb
Overview
Wraps a streaming input body into the interface required by `rack.input`.
The input stream is an `IO`-like object which contains the raw HTTP POST data. When applicable, its external encoding must be `ASCII-8BIT` and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to `gets`, `each`, `read` and `rewind`.
This implementation is not always rewindable, to avoid buffering the input when handling large uploads. See Rewindable for more details.
Instance Attribute Summary collapse
-
#body ⇒ Object
readonly
The input body.
Instance Method Summary collapse
-
#close(error = nil) ⇒ Object
Close the input and output bodies.
-
#closed? ⇒ Boolean
Whether the stream has been closed.
-
#each(&block) ⇒ Object
Enumerate chunks of the request body.
-
#empty? ⇒ Boolean
Whether there are any output chunks remaining?.
-
#gets ⇒ Object
Read the next chunk of data from the input stream.
-
#initialize(body) ⇒ Input
constructor
Initialize the input wrapper.
-
#rewind ⇒ Object
Rewind the input stream back to the start.
Constructor Details
#initialize(body) ⇒ Input
Initialize the input wrapper.
36 37 38 39 40 41 |
# File 'lib/protocol/rack/input.rb', line 36 def initialize(body) @body = body # Will hold remaining data in `#read`. @buffer = nil end |
Instance Attribute Details
#body ⇒ Object (readonly)
The input body.
45 46 47 |
# File 'lib/protocol/rack/input.rb', line 45 def body @body end |
Instance Method Details
#close(error = nil) ⇒ Object
Close the input and output bodies.
76 77 78 79 80 81 82 83 |
# File 'lib/protocol/rack/input.rb', line 76 def close(error = nil) if @body @body.close(error) @body = nil end return nil end |
#closed? ⇒ Boolean
Whether the stream has been closed.
104 105 106 |
# File 'lib/protocol/rack/input.rb', line 104 def closed? @body.nil? end |
#each(&block) ⇒ Object
Enumerate chunks of the request body.
50 51 52 53 54 55 56 |
# File 'lib/protocol/rack/input.rb', line 50 def each(&block) return to_enum unless block_given? while chunk = gets yield chunk end end |
#empty? ⇒ Boolean
Whether there are any output chunks remaining?
109 110 111 |
# File 'lib/protocol/rack/input.rb', line 109 def empty? @output.empty? end |
#gets ⇒ Object
Read the next chunk of data from the input stream.
`gets` must be called without arguments and return a `String`, or `nil` when the input stream has no more data.
65 66 67 68 69 70 71 72 73 |
# File 'lib/protocol/rack/input.rb', line 65 def gets if @buffer.nil? return read_next else buffer = @buffer @buffer = nil return buffer end end |
#rewind ⇒ Object
Rewind the input stream back to the start.
`rewind` must be called without arguments. It rewinds the input stream back to the beginning. It must not raise Errno::ESPIPE: that is, it may not be a pipe or a socket. Therefore, handler developers must buffer the input data into some rewindable object if the underlying input stream is not rewindable.
90 91 92 93 94 95 96 97 98 99 100 101 |
# File 'lib/protocol/rack/input.rb', line 90 def rewind if @body and @body.respond_to?(:rewind) # If the body is not rewindable, this will fail. @body.rewind @buffer = nil @finished = false return true end return false end |