src/url.bend

emerging-ezhttp@0.21.0.0 · 166 lines · 25 definitions

1# ezhttp/src/url: a URL taken apart far enough for an HTTP request. Scheme, host,
2# port, and an origin-form path (absolute-path, optional query). Userinfo is
3# stripped. The fragment is not part of the request-target.
4#
5# Shape follows RFC 3986 URI generic syntax: scheme ":" hier-part, with
6# hier-part as "//" authority path-abempty ["?" query] ["#" fragment]
7# (RFC 3986 §3, §3.1, §3.2, §3.4, §3.5).
8import Base
9
10# a url that came apart, or the reason it would not
11type Loc is Data:
12  Bad{why: String}
13  Loc{scheme: String, host: String, port: U32, path: String}
14
15# the port a scheme implies when the authority names none (RFC 3986 §3.2.3;
16# HTTPS default 443 is the well-known TLS port, not re-specified here)
17def dflt(scheme: String) -> U32:
18  Bool.pick(U32, String.eq(scheme, "https"), 443, 80)
19
20# a port that parsed, or the scheme's own when the digits were not digits
21def port.num(got: Maybe<&2, U32>, scheme: String) -> U32:
22  match got:
23    case None{}:
24      dflt(scheme)
25    case Some{n}:
26      n
27
28# the port named after the colon, when there is anything after it
29def port.tail(ps: List<&2, String>, scheme: String) -> U32:
30  match ps:
31    case []:
32      dflt(scheme)
33    case h <> t:
34      port.num(U32.read(h), scheme)
35
36# the port an authority asked for, or the one its scheme implies
37def port.of(ps: List<&2, String>, scheme: String) -> U32:
38  match ps:
39    case []:
40      dflt(scheme)
41    case h <> t:
42      port.tail(t, scheme)
43
44# the host an authority named: everything before the colon
45def host.of(ps: List<&2, String>) -> String:
46  match ps:
47    case []:
48      ""
49    case h <> t:
50      h
51
52# the path a url asked for, "/" when it named none. The leading slash ended
53# the authority, so it is put back. Absolute-path form matches RFC 3986
54# path-absolute / path-abempty used with an authority (§3.3).
55def path.of(ps: List<&2, String>) -> String:
56  match ps:
57    case []:
58      "/"
59    case h <> t:
60      "/" ++ String.join(t, "/")
61
62# the last piece, or "" when the split was empty
63def auth.last.of(last: Maybe<&2, String>) -> String:
64  match last:
65    case None{}:
66      ""
67    case Some{hostport}:
68      hostport
69
70# the last `@`-separated piece (the hostport). Earlier pieces are userinfo.
71def auth.last(ps: List<&2, String>) -> String:
72  auth.last.of(List.last(&2, String, ps))
73
74# userinfo is stripped: `user:pass@host` yields `host` (RFC 3986 §3.2.1)
75def auth.host(authority: String) -> String:
76  auth.last(String.split(authority, '@'))
77
78# the first piece of a `#` split
79def frag.drop.of(ps: List<&2, String>) -> String:
80  match ps:
81    case []:
82      ""
83    case hier <> _:
84      hier
85
86# everything before `#` (RFC 3986 §3.5). The fragment is not a request-target.
87def frag.drop(s: String) -> String:
88  frag.drop.of(String.split(s, '#'))
89
90# the hier-part before `?`
91def query.hier(ps: List<&2, String>) -> String:
92  match ps:
93    case []:
94      ""
95    case hier <> _:
96      hier
97
98# the query after the first `?`, with later `?` kept (RFC 3986 §3.4)
99def query.text(ps: List<&2, String>) -> String:
100  match ps:
101    case []:
102      ""
103    case _ <> rest:
104      String.join(rest, "?")
105
106# origin-form path: absolute-path, then `?` query when the query is present
107def path.target.of(path: String, query: String, empty: Bool) -> String:
108  match empty:
109    case True{}:
110      path
111    case False{}:
112      path ++ "?" ++ query
113
114# absolute-path ["?" query] (RFC 3986 §3.4, RFC 9112 §3.2.1)
115def path.target(path: String, +query: String) -> String:
116  path.target.of(path, query, String.eq(query, ""))
117
118# a url whose authority is now split on its colon
119def parse.auth(+scheme: String, +au: List<&2, String>, path: String) -> Loc:
120  Loc{scheme, host.of(au), port.of(au, scheme), path}
121
122# authority (userinfo stripped) and origin-form path
123def parse.parts(+scheme: String, +ps: List<&2, String>, query: String) -> Loc:
124  parse.auth(scheme, String.split(auth.host(host.of(ps)), ':'),
125    path.target(path.of(ps), query))
126
127# hier-part split on `?`
128def parse.q(+scheme: String, +ps: List<&2, String>) -> Loc:
129  parse.parts(scheme, String.split(query.hier(ps), '/'), query.text(ps))
130
131# fragment stripped, then query split from the hier-part
132def parse.hier(+scheme: String, +rest: String) -> Loc:
133  parse.q(scheme, String.split(frag.drop(rest), '?'))
134
135# what follows the scheme, once it is known whether it opens with `//`
136def parse.body(+scheme: String, +rest: String, slashes: Bool) -> Loc:
137  match slashes:
138    case False{}:
139      Bad{scheme ++ ":" ++ rest ++ " has no //"}
140    case True{}:
141      parse.hier(scheme, String.drop(rest, 2n))
142
143# what follows the scheme, judged on its `//`
144def parse.rest(+scheme: String, +rest: String) -> Loc:
145  parse.body(scheme, rest, String.starts_with(rest, "//"))
146
147# a url split on its colons: the first piece is the scheme, and a colon in the
148# path survives because the rest is joined back up
149def parse.scheme(ps: List<&2, String>) -> Loc:
150  match ps:
151    case []:
152      Bad{"an empty url"}
153    case h <> t:
154      parse.rest(String.to_lower(h), String.join(t, ":"))
155
156# a url in pieces, or the reason it is not one
157def parse(url: String) -> Loc:
158  parse.scheme(String.split(url, ':'))
159
160# a parsed url on one line, for a test to read
161def show(l: Loc) -> String:
162  match l:
163    case Bad{why}:
164      "bad " ++ why
165    case Loc{scheme, host, port, path}:
166      scheme ++ " " ++ host ++ " " ++ U32.show(port) ++ " " ++ path