iri_to_uri.pony

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
primitive IRIToURI
  """
  Convert an IRI to a URI by percent-encoding all non-ASCII bytes.

  Each component is processed byte-by-byte: bytes >= 0x80 become `%HH`,
  existing `%XX` triplets pass through unchanged, and ASCII bytes pass
  through unchanged. The scheme component is always ASCII per RFC 3986
  and is passed through without modification.

  Always succeeds — any byte sequence is valid input.
  """
  fun apply(iri: URI val): URI val =>
    """
    Percent-encode non-ASCII bytes in each IRI component to produce a
    URI.
    """
    let uri_authority: (URIAuthority | None) =
      match \exhaustive\ iri.authority
      | let a: URIAuthority =>
        let uri_userinfo: (String | None) =
          match \exhaustive\ a.userinfo
          | let u: String => _encode(u)
          | None => None
          end
        URIAuthority(uri_userinfo, _encode(a.host), a.port)
      | None => None
      end

    let uri_query: (String | None) =
      match \exhaustive\ iri.query
      | let q: String => _encode(q)
      | None => None
      end

    let uri_fragment: (String | None) =
      match \exhaustive\ iri.fragment
      | let f: String => _encode(f)
      | None => None
      end

    URI(
      iri.scheme,
      uri_authority,
      _encode(iri.path),
      uri_query,
      uri_fragment)

  fun _is_hex(c: U8): Bool =>
    ((c >= '0') and (c <= '9')) or
      ((c >= 'A') and (c <= 'F')) or
      ((c >= 'a') and (c <= 'f'))

  fun _encode(s: String val): String val =>
    var has_non_ascii: Bool = false
    for c in s.values() do
      if c >= 0x80 then
        has_non_ascii = true
        break
      end
    end
    if not has_non_ascii then return s end

    let out = String(s.size() * 2)
    var i: USize = 0
    while i < s.size() do
      try
        let c = s(i)?
        if (c == '%') and ((i + 2) < s.size()) and
          _is_hex(s(i + 1)?) and _is_hex(s(i + 2)?)
        then
          // Pass through existing percent-encoded triplets
          out.push(c)
          out.push(s(i + 1)?)
          out.push(s(i + 2)?)
          i = i + 3
        elseif c >= 0x80 then
          out.append(PercentEncode._encode_byte(c))
          i = i + 1
        else
          out.push(c)
          i = i + 1
        end
      else
        _Unreachable()
      end
    end
    out.clone()