Simplify URI API and implementation

8 files changed, 259 insertions, 267 deletions

diff --git a/src/env.c b/src/env.c
index 516eaf32..78680a0f 100644
--- a/src/env.c
+++ b/src/env.c
@@ -6,6 +6,7 @@
 #include "node.h"
 
 #include "serd/node.h"
+#include "serd/uri.h"
 
 #include <stdbool.h>
 #include <stdio.h>
@@ -78,15 +79,16 @@ serd_env_set_base_uri(SerdEnv* const env, const SerdNode* const uri)
     return SERD_SUCCESS;
   }
 
-  // Resolve base URI and create a new node and URI for it
-  SerdURIView base_uri;
-  SerdNode*   base_uri_node =
-    serd_new_uri_from_node(uri, &env->base_uri, &base_uri);
+  // Resolve the new base against the current base in case it is relative
+  const SerdURIView new_base_uri =
+    serd_resolve_uri(serd_parse_uri(serd_node_string(uri)), env->base_uri);
+
+  SerdNode* const new_base_node = serd_new_parsed_uri(new_base_uri);
 
   // Replace the current base URI
   serd_node_free(env->base_uri_node);
-  env->base_uri_node = base_uri_node;
-  env->base_uri      = base_uri;
+  env->base_uri_node = new_base_node;
+  env->base_uri      = serd_node_uri_view(env->base_uri_node);
 
   return SERD_SUCCESS;
 }
@@ -143,17 +145,22 @@ serd_env_set_prefix(SerdEnv* const        env,
   if (serd_uri_string_has_scheme(serd_node_string(uri))) {
     // Set prefix to absolute URI
     serd_env_add(env, name, uri);
-  } else {
-    // Resolve relative URI and create a new node and URI for it
-    SerdURIView abs_uri;
-    SerdNode*   abs_uri_node =
-      serd_new_uri_from_node(uri, &env->base_uri, &abs_uri);
-
-    // Set prefix to resolved (absolute) URI
-    serd_env_add(env, name, abs_uri_node);
-    serd_node_free(abs_uri_node);
+    return SERD_SUCCESS;
+  }
+
+  if (!env->base_uri_node) {
+    return SERD_BAD_ARG;
   }
 
+  // Resolve relative URI and create a new node and URI for it
+  SerdNode* const abs_uri =
+    serd_new_resolved_uri(serd_node_string_view(uri), env->base_uri);
+
+  // Set prefix to resolved (absolute) URI
+  serd_env_add(env, name, abs_uri);
+
+  serd_node_free(abs_uri);
+
   return SERD_SUCCESS;
 }
 
@@ -237,16 +244,15 @@ serd_env_expand_node(const SerdEnv* const env, const SerdNode* const node)
   switch (node->type) {
   case SERD_LITERAL:
     break;
-  case SERD_URI: {
-    SerdURIView ignored;
-    return serd_new_uri_from_node(node, &env->base_uri, &ignored);
-  }
+  case SERD_URI:
+    return serd_new_resolved_uri(serd_node_string_view(node), env->base_uri);
   case SERD_CURIE: {
     SerdStringView prefix;
     SerdStringView suffix;
     if (serd_env_expand(env, node, &prefix, &suffix)) {
       return NULL;
     }
+
     const size_t len = prefix.length + suffix.length;
     SerdNode*    ret = serd_node_malloc(len, 0, SERD_URI);
     char*        buf = serd_node_buffer(ret);
diff --git a/src/node.c b/src/node.c
index 9acbb8be..de42075e 100644
--- a/src/node.c
+++ b/src/node.c
@@ -37,7 +37,7 @@ static const size_t serd_node_align = 2 * sizeof(uint64_t);
 static size_t
 serd_uri_string_length(const SerdURIView* const uri)
 {
-  size_t len = uri->path_base.length;
+  size_t len = uri->path_prefix.length;
 
 #define ADD_LEN(field, n_delims)        \
   if ((field).length) {                 \
@@ -152,29 +152,56 @@ serd_node_equals(const SerdNode* const a, const SerdNode* const b)
 }
 
 SerdNode*
-serd_new_uri_from_node(const SerdNode* const    uri_node,
-                       const SerdURIView* const base,
-                       SerdURIView* const       out)
+serd_new_uri(const char* const str)
 {
-  const char* uri_str = serd_node_string(uri_node);
-  return (uri_node && uri_node->type == SERD_URI && uri_str)
-           ? serd_new_uri_from_string(uri_str, base, out)
-           : NULL;
+  const size_t length = strlen(str);
+  SerdNode*    node   = serd_node_malloc(length, 0, SERD_URI);
+  memcpy(serd_node_buffer(node), str, length);
+  node->length = length;
+  return node;
 }
 
 SerdNode*
-serd_new_uri_from_string(const char* const        str,
-                         const SerdURIView* const base,
-                         SerdURIView* const       out)
+serd_new_parsed_uri(const SerdURIView uri)
+{
+  const size_t    len        = serd_uri_string_length(&uri);
+  SerdNode* const node       = serd_node_malloc(len, 0, SERD_URI);
+  char*           ptr        = serd_node_buffer(node);
+  const size_t    actual_len = serd_write_uri(uri, string_sink, &ptr);
+
+  serd_node_buffer(node)[actual_len] = '\0';
+  node->length                       = actual_len;
+
+  return node;
+}
+
+static SerdNode*
+serd_new_from_uri(const SerdURIView uri, const SerdURIView base)
 {
-  if (!str || str[0] == '\0') {
-    // Empty URI => Base URI, or nothing if no base is given
-    return base ? serd_new_uri(base, NULL, out) : NULL;
+  const SerdURIView abs_uri    = serd_resolve_uri(uri, base);
+  const size_t      len        = serd_uri_string_length(&abs_uri);
+  SerdNode*         node       = serd_node_malloc(len, 0, SERD_URI);
+  char*             ptr        = serd_node_buffer(node);
+  const size_t      actual_len = serd_write_uri(abs_uri, string_sink, &ptr);
+
+  serd_node_buffer(node)[actual_len] = '\0';
+  node->length                       = actual_len;
+
+  return node;
+}
+
+SerdNode*
+serd_new_resolved_uri(const SerdStringView string, const SerdURIView base)
+{
+  const SerdURIView uri    = serd_parse_uri(string.data);
+  SerdNode* const   result = serd_new_from_uri(uri, base);
+
+  if (!serd_uri_string_has_scheme(serd_node_string(result))) {
+    serd_node_free(result);
+    return NULL;
   }
 
-  SerdURIView uri;
-  serd_uri_parse(str, &uri);
-  return serd_new_uri(&uri, base, out); // Resolve/Serialise
+  return result;
 }
 
 static bool
@@ -270,61 +297,13 @@ serd_new_file_uri(const char* const  path,
   const char* const string = serd_buffer_sink_finish(&buffer);
   SerdNode* const   node   = serd_new_substring(SERD_URI, string, length);
   if (out) {
-    serd_uri_parse(serd_node_buffer(node), out);
+    *out = serd_parse_uri(serd_node_buffer(node));
   }
 
   free(buffer.buf);
   return node;
 }
 
-SerdNode*
-serd_new_uri(const SerdURIView* const uri,
-             const SerdURIView* const base,
-             SerdURIView* const       out)
-{
-  SerdURIView abs_uri = *uri;
-  if (base) {
-    serd_uri_resolve(uri, base, &abs_uri);
-  }
-
-  const size_t len        = serd_uri_string_length(&abs_uri);
-  SerdNode*    node       = serd_node_malloc(len, 0, SERD_URI);
-  char*        ptr        = serd_node_buffer(node);
-  const size_t actual_len = serd_uri_serialise(&abs_uri, string_sink, &ptr);
-
-  serd_node_buffer(node)[actual_len] = '\0';
-  node->length                       = actual_len;
-
-  if (out) {
-    serd_uri_parse(serd_node_buffer(node), out); // TODO: avoid double parse
-  }
-
-  return node;
-}
-
-SerdNode*
-serd_new_relative_uri(const SerdURIView* const uri,
-                      const SerdURIView* const base,
-                      const SerdURIView* const root,
-                      SerdURIView* const       out)
-{
-  const size_t uri_len  = serd_uri_string_length(uri);
-  const size_t base_len = serd_uri_string_length(base);
-  SerdNode*    node     = serd_node_malloc(uri_len + base_len, 0, SERD_URI);
-  char*        ptr      = serd_node_buffer(node);
-  const size_t actual_len =
-    serd_uri_serialise_relative(uri, base, root, string_sink, &ptr);
-
-  serd_node_buffer(node)[actual_len] = '\0';
-  node->length                       = actual_len;
-
-  if (out) {
-    serd_uri_parse(serd_node_buffer(node), out); // TODO: avoid double parse
-  }
-
-  return node;
-}
-
 static unsigned
 serd_digits(const double abs)
 {
@@ -458,16 +437,11 @@ serd_node_string_view(const SerdNode* const node)
   return r;
 }
 
-SerdURIView
+SERD_PURE_FUNC SerdURIView
 serd_node_uri_view(const SerdNode* const node)
 {
-  SerdURIView result = SERD_URI_NULL;
-
-  if (node->type == SERD_URI) {
-    serd_uri_parse(serd_node_string(node), &result);
-  }
-
-  return result;
+  return (node->type == SERD_URI) ? serd_parse_uri(serd_node_string(node))
+                                  : SERD_URI_NULL;
 }
 
 SerdNodeFlags
diff --git a/src/node.h b/src/node.h
index 60e0d2ff..41cf0d82 100644
--- a/src/node.h
+++ b/src/node.h
@@ -6,6 +6,8 @@
 
 #include "serd/attributes.h"
 #include "serd/node.h"
+#include "serd/string_view.h"
+#include "serd/uri.h"
 
 #include <stddef.h>
 
@@ -34,4 +36,8 @@ void
 serd_node_set(SerdNode* SERD_NONNULL* SERD_NONNULL dst,
               const SerdNode* SERD_NONNULL         src);
 
+/// Create a new URI from a string, resolved against a base URI
+SerdNode* SERD_ALLOCATED
+serd_new_resolved_uri(SerdStringView string, SerdURIView base_uri);
+
 #endif // SERD_SRC_NODE_H
diff --git a/src/reader.c b/src/reader.c
index 9a9fe744..140c07ba 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -268,7 +268,7 @@ serd_reader_set_default_graph(SerdReader* const     reader,
 SerdStatus
 serd_reader_read_file(SerdReader* const reader, const char* const uri)
 {
-  char* const path = serd_file_uri_parse(uri, NULL);
+  char* const path = serd_parse_file_uri(uri, NULL);
   if (!path) {
     return SERD_BAD_ARG;
   }
diff --git a/src/serdi.c b/src/serdi.c
index afae904c..85462532 100644
--- a/src/serdi.c
+++ b/src/serdi.c
@@ -308,7 +308,7 @@ main(int argc, char** argv)
     in_name = in_name ? in_name : input;
     if (!in_fd) {
       if (!strncmp(input, "file:", 5)) {
-        input_path = serd_file_uri_parse(input, NULL);
+        input_path = serd_parse_file_uri(input, NULL);
         input      = input_path;
       }
       if (!input || !(in_fd = serd_fopen(input, "rb"))) {
@@ -334,7 +334,8 @@ main(int argc, char** argv)
   SerdURIView base_uri = SERD_URI_NULL;
   SerdNode*   base     = NULL;
   if (a < argc) { // Base URI given on command line
-    base = serd_new_uri_from_string((const char*)argv[a], NULL, &base_uri);
+    base_uri = serd_parse_uri(argv[a]);
+    base     = serd_new_parsed_uri(base_uri);
   } else if (from_file && in_fd != stdin) { // Use input file URI
     base = serd_new_file_uri(input, NULL, &base_uri);
   }
diff --git a/src/uri.c b/src/uri.c
index a5d10877..eec9c7fc 100644
--- a/src/uri.c
+++ b/src/uri.c
@@ -5,7 +5,6 @@
 #include "uri_utils.h"
 
 #include "serd/buffer.h"
-#include "serd/status.h"
 #include "serd/stream.h"
 #include "serd/string_view.h"
 #include "serd/uri.h"
@@ -17,12 +16,13 @@
 #include <string.h>
 
 char*
-serd_file_uri_parse(const char* const uri, char** const hostname)
+serd_parse_file_uri(const char* const uri, char** const hostname)
 {
   const char* path = uri;
   if (hostname) {
     *hostname = NULL;
   }
+
   if (!strncmp(uri, "file://", 7)) {
     const char* auth = uri + 7;
     if (*auth == '/') { // No hostname
@@ -31,6 +31,7 @@ serd_file_uri_parse(const char* const uri, char** const hostname)
       if (!(path = strchr(auth, '/'))) {
         return NULL;
       }
+
       if (hostname) {
         const size_t len = (size_t)(path - auth);
         *hostname        = (char*)calloc(len + 1, 1);
@@ -62,36 +63,34 @@ serd_file_uri_parse(const char* const uri, char** const hostname)
       serd_buffer_sink(s, 1, &buffer);
     }
   }
+
   return serd_buffer_sink_finish(&buffer);
 }
 
+/// RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
 bool
-serd_uri_string_has_scheme(const char* utf8)
+serd_uri_string_has_scheme(const char* const string)
 {
-  // RFC3986: scheme ::= ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-  if (!utf8 || !is_alpha(utf8[0])) {
-    return false; // Invalid scheme initial character, URI is relative
-  }
-
-  for (char c = 0; (c = *++utf8) != '\0';) {
-    if (!is_uri_scheme_char(c)) {
-      return false;
-    }
+  if (is_alpha(string[0])) {
+    for (size_t i = 1; string[i]; ++i) {
+      if (!is_uri_scheme_char(string[i])) {
+        return false; // Non-scheme character before a ':'
+      }
 
-    if (c == ':') {
-      return true; // End of scheme
+      if (string[i] == ':') {
+        return true; // Valid scheme terminated by a ':'
+      }
     }
   }
 
   return false;
 }
 
-SerdStatus
-serd_uri_parse(const char* const utf8, SerdURIView* const out)
+SerdURIView
+serd_parse_uri(const char* const string)
 {
-  *out = SERD_URI_NULL;
-
-  const char* ptr = utf8;
+  SerdURIView result = SERD_URI_NULL;
+  const char* ptr    = string;
 
   /* See http://tools.ietf.org/html/rfc3986#section-3
      URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
@@ -105,11 +104,11 @@ serd_uri_parse(const char* const utf8, SerdURIView* const out)
       case '/':
       case '?':
       case '#':
-        ptr = utf8;
+        ptr = string;
         goto path; // Relative URI (starts with path by definition)
       case ':':
-        out->scheme.data   = utf8;
-        out->scheme.length = (size_t)((ptr++) - utf8);
+        result.scheme.data   = string;
+        result.scheme.length = (size_t)((ptr++) - string);
         goto maybe_authority; // URI with scheme
       case '+':
       case '-':
@@ -130,7 +129,7 @@ serd_uri_parse(const char* const utf8, SerdURIView* const out)
 maybe_authority:
   if (*ptr == '/' && *(ptr + 1) == '/') {
     ptr += 2;
-    out->authority.data = ptr;
+    result.authority.data = ptr;
     for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
       switch (c) {
       case '/':
@@ -140,7 +139,7 @@ maybe_authority:
       case '#':
         goto fragment;
       default:
-        ++out->authority.length;
+        ++result.authority.length;
       }
     }
   }
@@ -159,8 +158,8 @@ path:
   default:
     break;
   }
-  out->path.data   = ptr;
-  out->path.length = 0;
+  result.path.data   = ptr;
+  result.path.length = 0;
   for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
     switch (c) {
     case '?':
@@ -168,7 +167,7 @@ path:
     case '#':
       goto fragment;
     default:
-      ++out->path.length;
+      ++result.path.length;
     }
   }
 
@@ -178,12 +177,12 @@ path:
   */
 query:
   if (*ptr == '?') {
-    out->query.data = ++ptr;
+    result.query.data = ++ptr;
     for (char c = 0; (c = *ptr) != '\0'; ++ptr) {
       if (c == '#') {
         goto fragment;
       }
-      ++out->query.length;
+      ++result.query.length;
     }
   }
 
@@ -193,14 +192,14 @@ query:
   */
 fragment:
   if (*ptr == '#') {
-    out->fragment.data = ptr;
+    result.fragment.data = ptr;
     while (*ptr++ != '\0') {
-      ++out->fragment.length;
+      ++result.fragment.length;
     }
   }
 
 end:
-  return SERD_SUCCESS;
+  return result;
 }
 
 /**
@@ -262,179 +261,185 @@ merge(SerdStringView* const base, SerdStringView* const path)
 }
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.2.2
-void
-serd_uri_resolve(const SerdURIView* const r,
-                 const SerdURIView* const base,
-                 SerdURIView* const       t)
+SerdURIView
+serd_resolve_uri(const SerdURIView r, const SerdURIView base)
 {
-  if (!base->scheme.length) {
-    *t = *r; // Don't resolve against non-absolute URIs
-    return;
+  if (r.scheme.length || !base.scheme.length) {
+    return r; // No resolution necessary || possible (respectively)
   }
 
-  t->path_base.data   = "";
-  t->path_base.length = 0;
-  if (r->scheme.length) {
-    *t = *r;
+  SerdURIView t = SERD_URI_NULL;
+
+  if (r.authority.length) {
+    t.authority = r.authority;
+    t.path      = r.path;
+    t.query     = r.query;
   } else {
-    if (r->authority.length) {
-      t->authority = r->authority;
-      t->path      = r->path;
-      t->query     = r->query;
+    t.path = r.path;
+    if (!r.path.length) {
+      t.path_prefix = base.path;
+      t.query       = r.query.length ? r.query : base.query;
     } else {
-      t->path = r->path;
-      if (!r->path.length) {
-        t->path_base = base->path;
-        if (r->query.length) {
-          t->query = r->query;
-        } else {
-          t->query = base->query;
-        }
-      } else {
-        if (r->path.data[0] != '/') {
-          t->path_base = base->path;
-        }
-        merge(&t->path_base, &t->path);
-        t->query = r->query;
+      if (r.path.data[0] != '/') {
+        t.path_prefix = base.path;
       }
-      t->authority = base->authority;
+
+      merge(&t.path_prefix, &t.path);
+      t.query = r.query;
     }
-    t->scheme   = base->scheme;
-    t->fragment = r->fragment;
+
+    t.authority = base.authority;
   }
+
+  t.scheme   = base.scheme;
+  t.fragment = r.fragment;
+
+  return t;
 }
 
-/** Write the path of `uri` starting at index `i` */
-static size_t
-write_path_tail(SerdSink                 sink,
-                void* const              stream,
-                const SerdURIView* const uri,
-                const size_t             i)
+SerdURIView
+serd_relative_uri(const SerdURIView uri, const SerdURIView base)
 {
-  size_t len = 0;
-  if (i < uri->path_base.length) {
-    len += sink(uri->path_base.data + i, uri->path_base.length - i, stream);
+  if (!uri_is_related(&uri, &base)) {
+    return uri;
   }
 
-  if (uri->path.data) {
-    if (i < uri->path_base.length) {
-      len += sink(uri->path.data, uri->path.length, stream);
-    } else {
-      const size_t j = (i - uri->path_base.length);
-      len += sink(uri->path.data + j, uri->path.length - j, stream);
-    }
-  }
+  SerdURIView result = SERD_URI_NULL;
 
-  return len;
-}
+  // Regardless of the path, the query and/or fragment come along
+  result.query    = uri.query;
+  result.fragment = uri.fragment;
 
-/** Write the path of `uri` relative to the path of `base`. */
-static size_t
-write_rel_path(SerdSink                 sink,
-               void* const              stream,
-               const SerdURIView* const uri,
-               const SerdURIView* const base)
-{
-  const size_t path_len = uri_path_len(uri);
-  const size_t base_len = uri_path_len(base);
+  const size_t path_len = uri_path_len(&uri);
+  const size_t base_len = uri_path_len(&base);
   const size_t min_len  = (path_len < base_len) ? path_len : base_len;
 
   // Find the last separator common to both paths
   size_t last_shared_sep = 0;
   size_t i               = 0;
-  for (; i < min_len && uri_path_at(uri, i) == uri_path_at(base, i); ++i) {
-    if (uri_path_at(uri, i) == '/') {
+  for (; i < min_len && uri_path_at(&uri, i) == uri_path_at(&base, i); ++i) {
+    if (uri_path_at(&uri, i) == '/') {
       last_shared_sep = i;
     }
   }
 
-  if (i == path_len && i == base_len) { // Paths are identical
-    return 0;
+  // If the URI and base URI have identical paths, the relative path is empty
+  if (i == path_len && i == base_len) {
+    result.path.data   = uri.path.data;
+    result.path.length = 0;
+    return result;
   }
 
+  // Otherwise, we need to build the relative path out of string slices
+
   // Find the number of up references ("..") required
   size_t up = 0;
   for (size_t s = last_shared_sep + 1; s < base_len; ++s) {
-    if (uri_path_at(base, s) == '/') {
+    if (uri_path_at(&base, s) == '/') {
       ++up;
     }
   }
 
-  // Write up references
-  size_t len = 0;
-  for (size_t u = 0; u < up; ++u) {
-    len += sink("../", 3, stream);
+  if (up > 0) {
+    if (last_shared_sep < uri.path_prefix.length) {
+      return SERD_URI_NULL;
+    }
+
+    // Special representation: NULL buffer and len set to the depth
+    result.path_prefix.length = up;
   }
 
-  // Write suffix
-  return len + write_path_tail(sink, stream, uri, last_shared_sep + 1);
+  if (last_shared_sep < uri.path_prefix.length) {
+    result.path_prefix.data   = uri.path_prefix.data + last_shared_sep + 1;
+    result.path_prefix.length = uri.path_prefix.length - last_shared_sep - 1;
+    result.path               = uri.path;
+  } else {
+    result.path.data   = uri.path.data + last_shared_sep + 1;
+    result.path.length = uri.path.length - last_shared_sep - 1;
+  }
+
+  return result;
 }
 
-static uint8_t
-serd_uri_path_starts_without_slash(const SerdURIView* uri)
+bool
+serd_uri_is_within(const SerdURIView uri, const SerdURIView base)
 {
-  return ((uri->path_base.length || uri->path.length) &&
-          ((!uri->path_base.length || uri->path_base.data[0] != '/') &&
-           (!uri->path.length || uri->path.data[0] != '/')));
+  if (!base.scheme.length || !slice_equals(&base.scheme, &uri.scheme) ||
+      !slice_equals(&base.authority, &uri.authority)) {
+    return false;
+  }
+
+  bool         differ   = false;
+  const size_t path_len = uri_path_len(&uri);
+  const size_t base_len = uri_path_len(&base);
+
+  size_t last_base_slash = 0;
+  for (size_t i = 0; i < path_len && i < base_len; ++i) {
+    const char u = uri_path_at(&uri, i);
+    const char b = uri_path_at(&base, i);
+
+    differ = differ || u != b;
+    if (b == '/') {
+      last_base_slash = i;
+      if (differ) {
+        return false;
+      }
+    }
+  }
+
+  for (size_t i = last_base_slash + 1; i < base_len; ++i) {
+    if (uri_path_at(&base, i) == '/') {
+      return false;
+    }
+  }
+
+  return true;
 }
 
 /// See http://tools.ietf.org/html/rfc3986#section-5.3
 size_t
-serd_uri_serialise_relative(const SerdURIView* const uri,
-                            const SerdURIView* const base,
-                            const SerdURIView* const root,
-                            SerdSink                 sink,
-                            void* const              stream)
+serd_write_uri(const SerdURIView uri, SerdSink sink, void* const stream)
 {
-  size_t     len = 0;
-  const bool relative =
-    root ? uri_is_under(uri, root) : uri_is_related(uri, base);
+  size_t len = 0;
 
-  if (relative) {
-    len = write_rel_path(sink, stream, uri, base);
+  if (uri.scheme.data) {
+    len += sink(uri.scheme.data, uri.scheme.length, stream);
+    len += sink(":", 1, stream);
   }
 
-  if (!relative || (!len && base->query.data)) {
-    if (uri->scheme.data) {
-      len += sink(uri->scheme.data, uri->scheme.length, stream);
-      len += sink(":", 1, stream);
+  if (uri.authority.data) {
+    len += sink("//", 2, stream);
+    len += sink(uri.authority.data, uri.authority.length, stream);
+
+    if (uri.authority.length > 0 && uri_path_len(&uri) > 0 &&
+        uri_path_at(&uri, 0) != '/') {
+      // Special case: ensure path begins with a slash
+      // https://tools.ietf.org/html/rfc3986#section-3.2
+      len += sink("/", 1, stream);
     }
-    if (uri->authority.data) {
-      len += sink("//", 2, stream);
-      len += sink(uri->authority.data, uri->authority.length, stream);
-
-      const bool authority_ends_with_slash =
-        (uri->authority.length > 0 &&
-         uri->authority.data[uri->authority.length - 1] == '/');
-
-      if (!authority_ends_with_slash &&
-          serd_uri_path_starts_without_slash(uri)) {
-        // Special case: ensure path begins with a slash
-        // https://tools.ietf.org/html/rfc3986#section-3.2
-        len += sink("/", 1, stream);
-      }
+  }
+
+  if (uri.path_prefix.data) {
+    len += sink(uri.path_prefix.data, uri.path_prefix.length, stream);
+  } else if (uri.path_prefix.length) {
+    for (size_t i = 0; i < uri.path_prefix.length; ++i) {
+      len += sink("../", 3, stream);
     }
-    len += write_path_tail(sink, stream, uri, 0);
   }
 
-  if (uri->query.data) {
+  if (uri.path.data) {
+    len += sink(uri.path.data, uri.path.length, stream);
+  }
+
+  if (uri.query.data) {
     len += sink("?", 1, stream);
-    len += sink(uri->query.data, uri->query.length, stream);
+    len += sink(uri.query.data, uri.query.length, stream);
   }
 
-  if (uri->fragment.data) {
-    // Note uri->fragment.data includes the leading '#'
-    len += sink(uri->fragment.data, uri->fragment.length, stream);
+  if (uri.fragment.data) {
+    // Note that uri.fragment.data includes the leading '#'
+    len += sink(uri.fragment.data, uri.fragment.length, stream);
   }
 
   return len;
 }
-
-/// See http://tools.ietf.org/html/rfc3986#section-5.3
-size_t
-serd_uri_serialise(const SerdURIView* const uri,
-                   SerdSink                 sink,
-                   void* const              stream)
-{
-  return serd_uri_serialise_relative(uri, NULL, NULL, sink, stream);
-}
diff --git a/src/uri_utils.h b/src/uri_utils.h
index ebc32b78..36db5fb5 100644
--- a/src/uri_utils.h
+++ b/src/uri_utils.h
@@ -25,17 +25,17 @@ slice_equals(const SerdStringView* a, const SerdStringView* b)
 static inline size_t
 uri_path_len(const SerdURIView* uri)
 {
-  return uri->path_base.length + uri->path.length;
+  return uri->path_prefix.length + uri->path.length;
 }
 
 static inline char
 uri_path_at(const SerdURIView* uri, size_t i)
 {
-  if (i < uri->path_base.length) {
-    return uri->path_base.data[i];
+  if (i < uri->path_prefix.length) {
+    return uri->path_prefix.data[i];
   }
 
-  return uri->path.data[i - uri->path_base.length];
+  return uri->path.data[i - uri->path_prefix.length];
 }
 
 /**
@@ -87,7 +87,9 @@ uri_rooted_index(const SerdURIView* uri, const SerdURIView* root)
 static inline SERD_PURE_FUNC bool
 uri_is_related(const SerdURIView* uri, const SerdURIView* root)
 {
-  return uri_rooted_index(uri, root).shared != SIZE_MAX;
+  return root && root->scheme.length &&
+         slice_equals(&root->scheme, &uri->scheme) &&
+         slice_equals(&root->authority, &uri->authority);
 }
 
 /** Return true iff `uri` is within the base of `root` */
diff --git a/src/writer.c b/src/writer.c
index 2372f712..a0325243 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -770,21 +770,19 @@ write_uri_node(SerdWriter* const writer,
 
   TRY(st, esink("<", 1, writer));
 
-  if (writer->flags & SERD_WRITE_RESOLVED) {
-    SerdURIView in_base_uri;
-    SerdURIView uri;
-    SerdURIView abs_uri;
-    serd_env_base_uri(writer->env, &in_base_uri);
-    serd_uri_parse(node_str, &uri);
-    serd_uri_resolve(&uri, &in_base_uri, &abs_uri);
-    bool           rooted = uri_is_under(&in_base_uri, &writer->root_uri);
-    SerdURIView*   root   = rooted ? &writer->root_uri : &in_base_uri;
-    UriSinkContext ctx    = {writer, SERD_SUCCESS};
-    if (!uri_is_under(&abs_uri, root) || writer->syntax == SERD_NTRIPLES ||
-        writer->syntax == SERD_NQUADS) {
-      serd_uri_serialise(&abs_uri, uri_sink, &ctx);
+  SerdURIView base_uri = SERD_URI_NULL;
+  if ((writer->flags & SERD_WRITE_RESOLVED) &&
+      serd_env_base_uri(writer->env, &base_uri)) {
+    SerdURIView        uri     = serd_parse_uri(node_str);
+    SerdURIView        abs_uri = serd_resolve_uri(uri, base_uri);
+    bool               rooted  = uri_is_under(&base_uri, &writer->root_uri);
+    const SerdURIView* root    = rooted ? &writer->root_uri : &base_uri;
+    UriSinkContext     ctx     = {writer, SERD_SUCCESS};
+
+    if (!supports_abbrev(writer) || !uri_is_under(&abs_uri, root)) {
+      serd_write_uri(abs_uri, uri_sink, &ctx);
     } else {
-      serd_uri_serialise_relative(&uri, &in_base_uri, root, uri_sink, &ctx);
+      serd_write_uri(serd_relative_uri(uri, base_uri), uri_sink, &ctx);
     }
   } else {
     TRY(st, write_uri_from_node(writer, node));
@@ -1211,7 +1209,7 @@ serd_writer_set_root_uri(SerdWriter* writer, const SerdNode* uri)
 
   if (uri) {
     writer->root_node = serd_node_copy(uri);
-    serd_uri_parse(serd_node_string(writer->root_node), &writer->root_uri);
+    writer->root_uri  = serd_parse_uri(serd_node_string(writer->root_node));
   }
 
   return SERD_SUCCESS;