module HTTP

HTTP: require "http". An HTTP/1.1 server for use behind a reverse proxy (docs/11-http.md): a handler takes a Request and returns a Response; the server runs a task per connection.

require "http"
HTTP.serve(8080) { |req| HTTP::Response.text("hello #{req.path}") }

<std:http>:12

Classes and modules

• HTTP::BadRequest A malformed request or body: answered 400.
• HTTP::Body A request body, read from the connection as the handler asks for it.
• HTTP::BodyWriter Given to a Stream body's procedure: each write is a chunk.
• HTTP::Error Answered with its status (and its message as a text body) when a handler raises it; the parser raises the subclasses.
• HTTP::Field One header field, its name lowercased.
• HTTP::Handler What serves requests: a Router, a procedure (HTTP.handler) or a class or data of one's own. Handlers are Shareable, since every connection's task calls them: state shared between requests lives in an Atom or a Channel. Middleware is a handler holding the next.
• HTTP::Headers Header fields in order, names lowercased; a name may repeat. Names are case-insensitive, and written out in the conventional form (Content-Type). Immutable: put, add and delete return new headers.
• HTTP::HeadersTooLarge A request line and headers over the server's max_header_bytes: answered 431.
• HTTP::Options A server's settings, as Server.new takes them.
• HTTP::PayloadTooLarge A body over the server's max_body_bytes (Body#read): answered 413.
• HTTP::Proxies Trusted proxies: addresses or networks (10.0.0.0/8, fd00::/8).
• HTTP::Request A request, as the server read it or as a test builds it (HTTP::Request.get). A data value: with makes a changed copy. It is not Shareable, since its Body is not: copy the fields a task needs out of it before spawning one.
• HTTP::Response What a handler returns. A data value: #header and with make changed copies. When it sends one, the server adds the framing (Content-Length or Transfer-Encoding) and a Date header.
• HTTP::ResponseBody The body of a Response. The server adds the framing it implies: Content-Length for all but ResponseBody::Stream, which is sent chunked.
• HTTP::Router Routes by method and path pattern (/users/{id}, /files/{path...}): the most specific match wins; a path that only other methods have is answered 405.
• HTTP::RouterBuilder Collects routes for Router.build. A pattern is a path whose segments may be {name} (one segment) or, last, {name...} (the rest of the path, possibly empty, slashes included); a trailing slash is significant.
• HTTP::Server An HTTP/1.1 server: a task per connection, requests on one connection served in order. Shareable, so that a Signal.trap block or another task can shut it down.

Class methods

HTTP.split_target("/a%20b?x=1")   # => ["/a b", "x=1"]
HTTP.split_target("/a")           # => ["/a", ""]

HTTP.parse_query("a=1&b=2&a=3")   # => {"a" => ["1", "3"], "b" => ["2"]}
HTTP.parse_query("a+b=c%20d&&e")  # => {"a b" => ["c d"], "e" => [""]}

hello = HTTP.handler { |req| HTTP::Response.text("hello #{req.path}") }
hello.call(HTTP::Request.get("/world")).body
# => HTTP::ResponseBody::Text(text: "hello /world")