emerging-ezhttp

Releases (15)

• 0.22.0.0 indexed
• 0.21.0.0 unindexed
• 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 unindexed
• 0.8.0.0 unindexed

Definitions (909)

src/unescape.bend

• def name.moreinside a name, a character that is not `;`: a name character joins it while it has fewer than 32
• def nameinside a name: `;` ends the reference with it
• def stepone character where the scan stands
• def endthe end of the text: a reference left open ends there, an `&`, `&#` or `&#x` with nothing after it is text
• def scana text scanned from where it stands, character by character
• def unescapea text with its character references replaced, as html.unescape

src/url.bend

• type Loca url that came apart, or the reason it would not
• def dfltthe port a scheme implies when the authority names none (RFC 3986 §3.2.3; HTTPS default 443 is the well-known TLS port, not re-specified here)
• def port.numa port that parsed, or the scheme's own when the digits were not digits
• def port.tailthe port named after the colon, when there is anything after it
• def port.ofthe port an authority asked for, or the one its scheme implies
• def host.ofthe host an authority named: everything before the colon
• def path.ofthe path a url asked for, "/" when it named none.
• def auth.last.ofthe last piece, or "" when the split was empty
• def auth.lastthe last `@`-separated piece (the hostport).
• def auth.hostuserinfo is stripped: `user:pass@host` yields `host` (RFC 3986 §3.2.1)
• def frag.drop.ofthe first piece of a `#` split
• def frag.dropeverything before `#` (RFC 3986 §3.5).
• def query.hierthe hier-part before `?`
• def query.textthe query after the first `?`, with later `?` kept (RFC 3986 §3.4)
• def path.target.oforigin-form path: absolute-path, then `?` query when the query is present
• def path.targetabsolute-path ["?" query] (RFC 3986 §3.4, RFC 9112 §3.2.1)
• def parse.autha url whose authority is now split on its colon
• def parse.partsauthority (userinfo stripped) and origin-form path
• def parse.qhier-part split on `?`
• def parse.hierfragment stripped, then query split from the hier-part
• def parse.bodywhat follows the scheme, once it is known whether it opens with `//`
• def parse.restwhat follows the scheme, judged on its `//`
• def parse.schemea url split on its colons: the first piece is the scheme, and a colon in the path survives because the rest is joined back up
• def parsea url in pieces, or the reason it is not one
• def showa parsed url on one line, for a test to read

src/wire.bend

• def wire.maxthe most octets one receive asks for
• def wire.readsthe most receives one exchange makes
• def wire.closeclose a socket, ending its TLS session when it has one
• def wire.recvthe next octets a socket has received, packed four to a word
• def wire.senta send.words.deadline answer without its count of octets accepted
• def wire.sendsend octets, the plain send bounded by the deadline
• def wire.shakethe TLS handshake with the host, when the exchange is secure
• type Answeran exchange's answer: the failure it was reported with (a status other than 0 on its first line, then the reason, wirespec.bend wire.fail), or every octet of the response, packed
• def wire.faileda failed call's answer, the socket closed first
• def wire.loop.ona judged read: read again, or close and answer what was received
• def wire.loop.copieda receive judged by a copy of it as text, dropped after the judging; the octets themselves are appended packed
• def wire.loop.texta read judged by its text, when its count alone does not decide it
• def wire.loop.judgea read judged by its count when that decides it (SPEC.md HTTP-CLI-6)
• def wire.loop.una receive's outcome: a failure is the answer
• def wire.loopreceive until wirespec.bend says the answer is whole, the octets appended to what came before
• def wire.after.sendafter the send: read the answer, or the send's failure
• def wire.putsend the octets an exchange carries, then read its answer
• def wire.after.shakeafter the handshake: send, or the handshake's failure (the socket closed plainly, as no TLS session was made)
• def wire.after.connectafter the connect: the handshake, or the connect's failure
• def wire.dial.nexta connect that failed tries the next address; one that worked is kept
• def wire.dialconnect to each address in turn until one connects; the last one's failure when none does
• def wire.after.resolveafter the resolve: connect, or the resolve's failure (no address at all is ENOENT, as bend-kit-dns reports a name with none)
• def wire.lookedthe OS resolver's addresses, NUL-separated, as a list
• def wire.resolvea host's addresses: a numeric address or localhost as it is, else the OS resolver's answer
• def wire.run.withthe exchange once its octets are packed
• def wire.runa request with this method, sent to a host as wirespec.bend says, with its tail of octets after it, every call bounded by the deadline; its whole answer
• def wire.talka request sent to a host, its tail of octets after it, and its whole answer read back, with the default deadline
• def wire.talk.timedthe same exchange, bounded by a timeout in milliseconds

src/wirespec.bend

• def wire.ms.dfltthe deadline of an exchange with no timeout: 60 s, in milliseconds
• def wire.ms.picka timeout once it is known whether it is 0
• def wire.ms.ata timeout as a deadline bend-kit-wire reads: 0 would be none there, so it is 1 ms
• def wire.ms.ofthe deadline every socket call of an exchange gets: the timeout it was made with, or the default (SPEC.md HTTP-CLI-1, 2)
• def wire.latethe wire status for an exchange that ran out of time (curl's CURLE_OPERATION_TIMEDOUT)
• def wire.why.ofwhat a failed exchange is reported as: a timeout is marked, any other failure's reason is kept as it is
• def wire.whya failed exchange's status and reason as the reason the client reports
• def wire.timed_outwhether a reported reason is a timeout
• type Exchangewhat a request to a URL becomes: nothing when the URL did not parse, else the scheme (secure or not), host, port, method and request text the effect is given; the answer is read by that method (wire.read.next)
• def wire.exchange.atthe exchange once it is known whether the scheme wants TLS
• def wire.exchange.methodthe method an exchange is sent and read by, none when nothing is sent
• def wire.exchangea request with this method, headers and body to a URL that came apart
• def wire.exchange.octetsa request with n octets of body to a URL that came apart: the request text ends at the blank line, and the octets go after it
• def wire.exchange.bodya request with a body of this shape to a URL that came apart: text inside the request text as UTF-8, octets after it (SPEC.md HTTP-CLI-10)
• def wire.code.ofan answer's status: the number on its first line, if it is one
• def wire.codean answer's status line as a number
• def wire.text.ofthe text after an answer's first newline
• def wire.textthe text after an answer's first newline
• def wire.ok.ofwhether a status is success (0)
• def wire.okwhether an answer has status 0
• def wire.joinedthe text a list of pieces, newest first, stands for
• def wire.join.gothe pieces put together onto what follows them, each copied once
• def wire.jointhe text a list of pieces, newest first, stands for, built in one pass
• def wire.gotwhere a response to a request with this method stands before anything has been received
• type Readafter a read: read again from where the response now stands, or it has all been received
• def wire.read.donewhere the response stands after a read, judged
• def wire.read.withwhere the response stands after a read, judged
• def wire.read.gota read that brought text, or found the connection closed
• def wire.read.nextwhat to do after a read brought this text, judged from where the response stood (SPEC.md HTTP-CLI-6)
• def wire.read.counteda read of m octets judged by its count, when that is enough to judge it
• def wire.read.count.ata read of m octets: none is the close
• def wire.read.countwhat to do after a read of m octets, when their count alone decides it; none when their text is needed (wire.read.next) (SPEC.md HTTP-CLI-6)
• def wire.spentthe answer when the reads run out before the response ends
• def wire.failedthe reason a failed exchange's answer is reported with (wire.why)
• def wire.heard.ofthe response an exchange's answer holds, read by the request's method (SPEC.md HTTP-CLI-9); a failed exchange is torn with the reason it is reported with (wire.why)
• def wire.phrasethe reason phrase of the response an exchange's answer holds (SPEC.md HTTP-CLI-11); a failed exchange's is read from its reason and not used
• def wire.heardthe response an exchange's answer holds
• def wire.payload.texta request text's UTF-8 octets, one character each, onto the octets after it
• def wire.payloadthe octets of a request text, one character each: its UTF-8 (the body's octets go after them)
• type Phasewhere in an exchange a call failed
• def wire.etimedoutthe error number a call that ran out of time fails with (Linux ETIMEDOUT)