Overview

• module Protocol
  • module HTTP
    • class AcceptEncoding

      A middleware that sets the accept-encoding header and decodes the response according to the content-encoding header.
    • module Body
      • class Buffered

        A body which buffers all it's contents.
      • class Completable

        Invokes a callback once the body has completed, either successfully or due to an error.
      • class ZStream

        A body which compresses or decompresses the contents using the DEFLATE or GZIP algorithm.
      • class Deflate

        A body which compresses the contents using the DEFLATE or GZIP algorithm.
      • class Digestable

        Invokes a callback once the body has finished reading.
      • class File

        A body which reads from a file.
      • class Head

        Represents a body suitable for HEAD requests, in other words, a body that is empty and has a known length.
      • class Inflate

        A body which decompresses the contents using the DEFLATE or GZIP algorithm.
      • class Readable

        Represents a readable input streams.
      • module Reader

        General operations for interacting with a request or response body.
      • class Rewindable

        A body which buffers all it's contents as it is read.
      • class Stream

        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.

        • module Reader

          This provides a read-only interface for data, which is surprisingly tricky to implement correctly.
      • module Streamable

        A body that invokes a block that can read and write to a stream.

        • class Output

          A output stream that can be written to by a block.
        • class ConsumedError

          Raised when a streaming body is consumed more than once.
        • class Body

          A streaming body that can be read from and written to.
        • class ResponseBody

          A response body is used on the server side to generate the response body using a block.
        • class RequestBody

          A request body is used on the client side to generate the request body using a block.
      • class Wrapper

        Wrapping body instance. Typically you'd override #read.
      • class Writable

        A dynamic body which you can write to and read from.

        • class Closed

          An error indicating that the body has been closed and no further writes are allowed.
        • class Output

          The output interface for writing chunks to the body.
    • class ContentEncoding

      Encode a response according the the request's acceptable encodings.
    • class Cookie

      Represents an individual cookie key-value pair.
    • class Error

      A generic, HTTP protocol error.
    • module Header
      • class Authorization

        Used for basic authorization.
      • class CacheControl

        Represents the cache-control header, which is a list of cache directives.
      • class Connection

        Represents the connection HTTP header, which controls options for the current connection.
      • class Cookie

        The cookie header contains stored HTTP cookies previously sent by the server with the set-cookie header.
      • class SetCookie

        The set-cookie header sends cookies from the server to the user agent.
      • class Date

        The date header represents the date and time at which the message was originated.
      • class ETag

        The etag header represents the entity tag for a resource.
      • class ETags

        The etags header represents a list of entity tags (ETags) for resources.
      • class Multiple

        Represents headers that can contain multiple distinct values separated by newline characters.
      • class Priority

        Represents the priority header, used to indicate the relative importance of an HTTP request.
      • class Split

        Represents headers that can contain multiple distinct values separated by commas.
      • class Vary

        Represents the vary header, which specifies the request headers a server considers when determining the response.
    • class Headers

      Headers are an array of key-value pairs. Some header keys represent multiple values.

      • class Merged

        Used for merging objects into a sequential list of headers. Normalizes header keys and values.
    • class Methods

      Provides a convenient interface for commonly supported HTTP methods.
    • class Middleware

      The middleware interface provides a convenient wrapper for implementing HTTP middleware.

      • class Builder

        A convenient interface for constructing middleware stacks.
      • module Okay

        A simple middleware that always returns a 200 response.
      • module NotFound

        A simple middleware that always returns a 404 response.
      • module HelloWorld

        A simple middleware that always returns "Hello World!".
    • class Peer

      Provide a well defined, cached representation of a peer (address).
    • class Reference

      A relative reference, excluding any authority. The path part of an HTTP request.
    • class Request

      Represents an HTTP request which can be used both server and client-side.
    • class Response

      Represents an HTTP response which can be used both server and client-side.
    • module URL

      Helpers for working with URLs.