parse_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
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
primitive ParseURI
  """
  Parse a URI-reference (RFC 3986 section 4.1) into structured components.

  Handles both absolute URIs (`http://host/path?query`) and relative
  references (`/path?query`). Components are stored percent-encoded.

  The parsing algorithm follows RFC 3986 section 3: scan for `:` before
  any of `/?#` to identify the scheme, then check for `//` to identify
  authority, then extract path (up to `?` or `#`), query (between `?`
  and `#`), and fragment (after `#`). Scanning operates on literal
  delimiter characters only — percent-encoded delimiters (`%2F`, `%3F`,
  `%23`) are not treated as structural boundaries.

  Scheme validation: the scheme must start with a letter and contain
  only letters, digits, `+`, `-`, and `.` (RFC 3986 section 3.1).

  The asterisk-form (`*`) used by HTTP OPTIONS is a valid relative
  reference under RFC 3986 — it parses as a URI with path `*` and no
  other components.
  """
  fun apply(raw: String val): (URI val | URIParseError val) =>
    """
    Parse `raw` into a `URI`, or return a `URIParseError` on failure.
    """
    var pos: USize = 0
    let len = raw.size()

    // Step 1: Detect scheme by scanning for ':' before any of '/?#'
    var scheme: (String | None) = None
    try
      var i: USize = 0
      while i < len do
        let c = raw(i)?
        if c == ':' then
          // Everything before ':' is potential scheme
          let candidate: String val = raw.substring(0, i.isize())
          if _valid_scheme(candidate) then
            scheme = candidate
            pos = i + 1
          end
          break
        elseif (c == '/') or (c == '?') or (c == '#') then
          break
        end
        i = i + 1
      end
    else
      _Unreachable()
    end

    // Step 2: Check for authority (starts with "//")
    var authority: (URIAuthority | None) = None
    try
      if ((pos + 1) < len) and (raw(pos)? == '/') and (raw(pos + 1)? == '/')
      then
        pos = pos + 2
        // Find end of authority: next '/', '?', or '#'
        var auth_end = pos
        while auth_end < len do
          let c = raw(auth_end)?
          if (c == '/') or (c == '?') or (c == '#') then
            break
          end
          auth_end = auth_end + 1
        end
        match \exhaustive\ ParseURIAuthority._parse(raw, pos, auth_end)
        | let a: URIAuthority val =>
          authority = a
        | let e: URIParseError val =>
          return e
        end
        pos = auth_end
      end
    else
      _Unreachable()
    end

    // Step 3: Extract path (up to '?' or '#')
    var path_end = pos
    try
      while path_end < len do
        let c = raw(path_end)?
        if (c == '?') or (c == '#') then
          break
        end
        path_end = path_end + 1
      end
    else
      _Unreachable()
    end
    let path: String val = raw.substring(pos.isize(), path_end.isize())
    pos = path_end

    // Step 4: Extract query (between '?' and '#')
    var query: (String | None) = None
    try
      if (pos < len) and (raw(pos)? == '?') then
        pos = pos + 1
        var query_end = pos
        while query_end < len do
          if raw(query_end)? == '#' then
            break
          end
          query_end = query_end + 1
        end
        let q: String val = raw.substring(pos.isize(), query_end.isize())
        query = q
        pos = query_end
      end
    else
      _Unreachable()
    end

    // Step 5: Extract fragment (after '#')
    var fragment: (String | None) = None
    try
      if (pos < len) and (raw(pos)? == '#') then
        pos = pos + 1
        let f: String val = raw.substring(pos.isize(), len.isize())
        fragment = f
      end
    else
      _Unreachable()
    end

    URI(scheme, authority, path, query, fragment)

  fun _valid_scheme(candidate: String val): Bool =>
    """
    RFC 3986 section 3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    """
    if candidate.size() == 0 then
      return false
    end
    try
      let first = candidate(0)?
      if not (((first >= 'A') and (first <= 'Z')) or
        ((first >= 'a') and (first <= 'z')))
      then
        return false
      end
      var i: USize = 1
      while i < candidate.size() do
        let c = candidate(i)?
        if not (
          ((c >= 'A') and (c <= 'Z')) or
            ((c >= 'a') and (c <= 'z')) or
            ((c >= '0') and (c <= '9')) or
            (c == '+') or (c == '-') or (c == '.'))
        then
          return false
        end
        i = i + 1
      end
    else
      _Unreachable()
    end
    true