class Falcon::Adapters::Output

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. If the body is replaced by a middleware after action, the original body must be closed first, if it responds to `close`. If the body responds to `to_path`, it must return a String identifying the location of a file whose contents are identical to that produced by calling `each`; this may be used by the server as an alternative, possibly more efficient way to transport the response. The body commonly is an `Array` of strings, the application instance itself, or a `File`-like object.

Constants

CONTENT_LENGTH

Attributes

body[R]

The rack response body.

length[R]

The content length of the rack response body.

Public Class Methods

new(body, length) click to toggle source

Initialize the output wrapper. @parameter body [Object] The rack response body. @parameter length [Integer] The rack response length.

# File lib/falcon/adapters/output.rb, line 61
def initialize(body, length)
        @length = length
        @body = body
        
        @chunks = nil
end
wrap(status, headers, body) click to toggle source

Wraps an array into a buffered body. @parameter status [Integer] The response status. @parameter headers [Protocol::HTTP::Headers] The response headers. @parameter body [Object] The `rack` response body.

# File lib/falcon/adapters/output.rb, line 38
def self.wrap(status, headers, body)
        # In no circumstance do we want this header propagating out:
        if length = headers.delete(CONTENT_LENGTH)
                # We don't really trust the user to provide the right length to the transport.
                length = Integer(length)
        end
        
        if body.is_a?(::Protocol::HTTP::Body::Readable)
                return body
        elsif status == 200 and body.respond_to?(:to_path)
                # Don't mangle partial responsese (206)
                return ::Protocol::HTTP::Body::File.open(body.to_path)
        elsif body.is_a?(Array)
                length ||= body.sum(&:bytesize)
                return self.new(body, length)
        else
                return self.new(body, length)
        end
end

Public Instance Methods

close(error = nil) click to toggle source

Close the response body.

Calls superclass method
# File lib/falcon/adapters/output.rb, line 85
def close(error = nil)
        if @body and @body.respond_to?(:close)
                @body.close
        end
        
        @body = nil
        @chunks = nil
        
        super
end
each(&block) click to toggle source

Enumerate the response body. @yields {|chunk| …}

@parameter chunk [String]
# File lib/falcon/adapters/output.rb, line 99
def each(&block)
        @body.each(&block)
ensure
        self.close($!)
end
empty?() click to toggle source

Whether the body is empty.

# File lib/falcon/adapters/output.rb, line 75
def empty?
        @length == 0 or (@body.respond_to?(:empty?) and @body.empty?)
end
inspect() click to toggle source
# File lib/falcon/adapters/output.rb, line 115
def inspect
        "\#<#{self.class} length=#{@length.inspect} body=#{@body.class}>"
end
read() click to toggle source

Read the next chunk from the response body. @returns [String | Nil]

# File lib/falcon/adapters/output.rb, line 107
def read
        @chunks ||= @body.to_enum(:each)
        
        return @chunks.next
rescue StopIteration
        return nil
end
ready?() click to toggle source

Whether the body can be read immediately.

# File lib/falcon/adapters/output.rb, line 80
def ready?
        true
end