emerging-ezhttp

Releases (14)

• 0.21.0.0 indexed
• 0.20.0.0 unindexed
• 0.19.0.0 unindexed
• 0.18.0.0 unindexed
• 0.17.0.0 unindexed
• 0.16.0.0 unindexed
• 0.15.0.0 unindexed
• 0.14.0.0 unindexed
• 0.13.0.0 unindexed
• 0.12.0.0 unindexed
• 0.11.0.0 unindexed
• 0.10.0.0 unindexed
• 0.9.0.0 invalid

  expected a fresh constructor name (duplicate declaration: Text)

  at src/body.bend:9

  10 files do not load

  • main.bend
  • src/auth.bend
  • src/body.bend
  • src/cache.bend
  • src/client.bend
  • src/cookie.bend
  • src/cors.bend
  • src/http.bend
  • src/server.bend
  • src/step.bend
• 0.8.0.0 invalid

  expected a fresh constructor name (duplicate declaration: Text)

  at src/body.bend:9

  9 files do not load

  • main.bend
  • src/auth.bend
  • src/body.bend
  • src/cache.bend
  • src/client.bend
  • src/cookie.bend
  • src/cors.bend
  • src/http.bend
  • src/server.bend

Definitions (909)

src/http.bend

• def chunks.ended.sizea chunk of size n: the last one when n is 0
• def chunks.ended.hexa chunk header: a size that is not hex ends the read (the parse rejects it)
• def chunks.ended.ata chunk header that has arrived, or not yet
• def chunks.endedwhether a chunked body has reached the end of its last chunk
• def whole.ofwhether a body has all arrived under its framing
• def whole.stepa head that is interim: whole when what follows is; else whole under the framing it gives
• def whole.ata response whose head has ended, or not yet
• def whole.gothe heads in turn, at most `fuel` of them
• def wholewhether the text received so far is a whole response to a request with this method (RFC 9112 §6.3), interim 1xx heads read past (RFC 9110 §15.2); a response framed by the close never is
• def status.emptya 1xx, 204 or 304 response has no body (RFC 9110 §6.4.1)
• def head.barea head that has no body: its status and fields (RFC 9110 §6.4.1)
• def head.final.ofa final head's plan once it is known whether it has a body
• def head.finala final head's plan: no body for a reply to HEAD or a 1xx, 204 or 304 status (RFC 9110 §6.4.1, §9.3.2), else as head.plan frames it
• def interim.skip.ofan interim head is skipped when anything follows it
• def interim.skipan interim head is skipped when more text follows it
• def parse.to.barethe final head with no body: its status and fields, an empty body
• def parse.to.finalthe final head: with no body, or framed as parse frames it
• def parse.to.stepan interim head is skipped, any other is the final one
• def parse.to.ata head that has ended, or the reason it has not
• def parse.to.gothe heads in turn, at most `fuel` of them
• def parse.tothe response to a request with this method (RFC 9112 §6.3): interim 1xx heads skipped, and no body for HEAD or a 1xx, 204 or 304 final status
• type Skipbytes of UTF-8 walked off the front of a string: all of it, with this many still owed, or a stop at the first character that does not fit in what was left, with what was left and the text from that character on
• def octs.skip.stepone step of the skip: a character wider than what is left stops it
• def octs.skipwalk n bytes of UTF-8 off a string, as octs.drop does, saying how it ended
• type Walkwhere a chunked body's walk stands: ended; waiting at a chunk header (or the last chunk's trailer) that has not all arrived; inside a chunk's data with octets still owed; or at the end of a chunk's data, at what should be its CRLF.
• def walk.crlfa chunk's data skipped: whether its CRLF has arrived, and on to the next chunk header when it has
• def walk.dataa chunk's data: all of what arrived, with octets still owed, or its end
• def walk.trailthe last chunk: ended once its trailer section has
• def walk.sizea chunk of size n: the last one when n is 0
• def walk.hexa chunk header: a size that is not hex ends the walk (the parse rejects it)
• def walk.ata chunk header that has arrived, or not yet
• def walkthe walk of chunks.ended from the chunk header at the front of a text
• def walk.donewhether the walk has ended
• def walk.morethe walk once m more characters, b, have arrived
• type Hearwhere a response stands: no final head yet (with the text from the head being read on, and the fuel whole.go would have there); no body, so whole; framed by the close, so never whole; sized, with the octets that have arrived; or chunked, with its walk
• def hear.bodya final head's body under its framing
• def hear.stepan interim head: on to the next; a final one: its body
• def hear.ata head that has ended, or not yet
• def hear.gothe heads in turn, as whole.go reads them
• def hear.ofwhere a response to a request with this method stands, read from the whole text received so far
• def hear.donewhether the response has all arrived
• def hear.morewhere a response stands once more text, b, has arrived
• def walk.countswhether a walk can be advanced by a count of octets alone: inside a chunk's data that still owes at least that many
• def walk.more.na walk advanced by m octets it does not look at (walk.counts says when that is walk.more)
• def hear.countswhether a state can be advanced by a count of octets alone, without their text: a whole response, a body framed by the close or by Content-Length, or a chunk's data that still owes at least that many (SPEC.md HTTP-CLI-6)
• def hear.more.na state advanced by m octets it does not look at (hear.counts says when that is hear.more)
• def phrase.chop.ata reason phrase with the CR its line ended with removed; a reason-phrase itself holds no CR (RFC 9112 §4)
• def phrase.chopthe text of a reason phrase, a final CR removed
• def phrase.codewhat follows the status code's SP: the reason phrase; none without that SP
• def phrase.afterwhat follows the version's SP: the status code, an SP and the reason
• def phrase.linea status line's reason phrase (RFC 9112 §4: HTTP-version SP status-code SP [ reason-phrase ]), empty when the line has fewer than two SPs
• def phrase.to.stepan interim head is skipped, any other gives the reason on its first line
• def phrase.to.ata head that has ended, or none
• def phrase.to.gothe heads in turn, at most `fuel` of them
• def phrase.tothe reason phrase of the head parse.to stops at: interim 1xx heads with text after them skipped, empty when no head ends

src/packed.bend

• type Gota response read off its octets: torn, or its status, its header fields and reason phrase as octet text, and its body's octets
• type Partsa chunked body's octets so far, newest first, or why it was torn
• def packed.text.ofa slice's copy as text, the buffer kept
• def packed.textn octets from `at` as text (a head or a chunk-size line), the buffer kept
• def packed.copyn octets from `at`, the buffer dropped
• def packed.chunk.takea chunk's octets copied out, then on to the chunk-size line after its CRLF
• def packed.chunk.ready.isa chunk of k octets from d, ready when its CRLF follows them
• def packed.chunk.readya chunk of k octets from d whose CRLF has been looked for (chunks.ready)
• def packed.chunk.dataa chunk of n octets from d: its octets must all be there, and a CRLF after them
• def packed.chunk.sizewhat a chunk-size line says, acted on with the octets after it
• def packed.chunk.linea chunk-size line read, its octets after its CRLF
• def packed.chunk.ata chunk-size line that ends at i, or none ends: the body ends there
• def packed.chunksthe chunks from the chunk-size line at p, at most `fuel` of them
• def packed.chunkeda chunked body's octets in order, or why it was torn
• def packed.sizeda body framed by Content-Length: torn when fewer octets arrived
• def packed.bodythe octets after the final head, as its framing says
• def packed.finalthe final head's plan carried out on the octets after it
• def packed.stepan interim head is skipped, any other is the final one
• def packed.head.texta head read as text, and the octets after its blank line from q
• def packed.heada head that ends at i, or none ends
• def packed.headsthe heads in turn from p, at most `fuel` of them
• def packed.reply.ofthe response to a request with this method, its octets counted
• def packed.replythe response to a request with this method, read off its octets as parse.to reads its text (SPEC.md HTTP-CLI-9, HTTP-CLI-15, HTTP-TRUST-9)

src/pct.bend

• def unreservedRFC 3986 §2.3 unreserved: ALPHA / DIGIT / "-" / "." / "_" / "~"
• def safea character a form writes as itself: unreserved, or "/" when `slash` (the path form) keeps it
• def hexone hex digit, upper case: 0-9 then A-F ('A' is 55 + 10)
• def pctbytes as %XX triples, high nibble first, followed by `rest`
• def conta continuation byte: 10xxxxxx from the six bits at `shift`
• def utf8.fourfour bytes: U+10000 to U+10FFFF
• def utf8.threethree bytes below U+10000, else four
• def utf8.twotwo bytes below U+0800, else more
• def utf8.oneone byte below U+0080, else more
• def utf8the UTF-8 bytes of one code point, in order (RFC 3629 §3)
• def one.ofone character, once it is known whether the form keeps it
• def oneone character as the form writes it, followed by `rest`
• def quotea string as the form writes it: each character in turn

src/qs.bend

• def Kva name and a value, as a query field or a cookie: a reusable pair, so a list of them can be looked up more than once
• type Tokone piece of a string being decoded: a byte of an ASCII run, or a character outside ASCII, which is kept as it is and ends the run
• type Escwhere the decoding stands: in plain text, after `%`, or after `%` and one hex digit (kept)
• def tok.hexwhether a character is a hex digit (`0`-`9`, `A`-`F`, `a`-`f`)
• def tok.bytethe byte a plain ASCII character stands for: `+` is a space when `plus`
• def tok.asciia plain ASCII character: `%` opens an escape, any other is its byte
• def tok.widea plain character once it is known whether it is outside ASCII
• def tok.plaina character in plain text
• def tok.pcta character after `%`: a hex digit is kept, anything else leaves the `%` as written