resolve_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
primitive ResolveURI
  """
  Resolve a URI reference against a base URI per RFC 3986 section 5.

  Given an absolute base URI and any URI-reference, produces the target URI
  that the reference identifies relative to the base. This is the operation
  browsers perform when resolving `href` attributes against the current
  document URL.

  The base must be an absolute URI (must have a scheme). Returns
  `BaseURINotAbsolute` if the base lacks a scheme.
  """
  fun apply(base: URI val, reference: URI val)
    : (URI val | ResolveURIError val)
  =>
    """
    Resolve `reference` against `base` using the algorithm from RFC 3986
    section 5.2.2. The base must have a scheme; the reference may be any
    URI-reference (absolute or relative).
    """
    let base_scheme =
      match \exhaustive\ base.scheme
      | let s: String => s
      | None => return BaseURINotAbsolute
      end

    match reference.scheme
    | let r_scheme: String =>
      // Reference has scheme — use it entirely (with dot-segment removal)
      URI(
        r_scheme,
        reference.authority,
        RemoveDotSegments(reference.path),
        reference.query,
        reference.fragment)
    else
      match reference.authority
      | let r_auth: URIAuthority =>
        // Reference has authority — inherit base scheme only
        URI(
          base_scheme,
          r_auth,
          RemoveDotSegments(reference.path),
          reference.query,
          reference.fragment)
      else
        if reference.path == "" then
          // Empty path — inherit base path; inherit base query only when
          // the reference has no query at all
          let q: (String | None) =
            match reference.query
            | let rq: String => rq
            else
              base.query
            end
          URI(
            base_scheme,
            base.authority,
            base.path,
            q,
            reference.fragment)
        else
          // Non-empty relative path
          let resolved_path =
            try
              if reference.path(0)? == '/' then
                // Absolute path — use directly with dot-segment removal
                RemoveDotSegments(reference.path)
              else
                // Relative path — merge with base then remove dot segments
                RemoveDotSegments(_merge(base, reference.path))
              end
            else
              _Unreachable()
              ""
            end
          URI(
            base_scheme,
            base.authority,
            resolved_path,
            reference.query,
            reference.fragment)
        end
      end
    end

  fun _merge(base: URI val, ref_path: String val): String val =>
    """
    RFC 3986 section 5.2.3: merge a relative-path reference with a base URI.
    """
    match base.authority
    | let _: URIAuthority =>
      if base.path == "" then
        // Base has authority and empty path — prepend "/"
        return "/" + ref_path
      end
    end
    // Take base path up to and including last "/", append reference path
    try
      var i = base.path.size()
      while i > 0 do
        i = i - 1
        if base.path(i)? == '/' then
          return base.path.substring(0, (i + 1).isize()) + ref_path
        end
      end
    else
      _Unreachable()
    end
    // No "/" in base path — reference path stands alone
    ref_path

primitive BaseURINotAbsolute is Stringable
  """
  The base URI passed to `ResolveURI` does not have a scheme.

  RFC 3986 section 5.2.2 requires the base URI to be an absolute URI.
  A relative reference cannot serve as a resolution base.
  """
  fun string(): String iso^ => "BaseURINotAbsolute".clone()

type ResolveURIError is BaseURINotAbsolute