Use SerdNodes instead of manual memory management in tests

11 files changed, 204 insertions, 123 deletions

diff --git a/include/serd/env.h b/include/serd/env.h
index a0c47997..553905f7 100644
--- a/include/serd/env.h
+++ b/include/serd/env.h
@@ -51,6 +51,16 @@ SERD_API SerdStatus
 serd_env_set_base_uri(SerdEnv* ZIX_NONNULL env, SerdStringView uri);
 
 /**
+   Set the current base URI to a filesystem path.
+
+   This will set the base URI to a properly formatted file URI that points to
+   the canonical version of `path`.  Note that this requires the path to
+   actually exist.
+*/
+SERD_API SerdStatus
+serd_env_set_base_path(SerdEnv* ZIX_NONNULL env, SerdStringView path);
+
+/**
    Set a namespace prefix.
 
    A namespace prefix is used to expand CURIE nodes, for example, with the
diff --git a/src/env.c b/src/env.c
index 8d63c9c9..e90b68a4 100644
--- a/src/env.c
+++ b/src/env.c
@@ -10,7 +10,9 @@
 #include "serd/node.h"
 #include "serd/nodes.h"
 #include "serd/write_result.h"
+#include "zix/allocator.h"
 #include "zix/attributes.h"
+#include "zix/filesystem.h"
 
 #include <assert.h>
 #include <stdbool.h>
@@ -165,6 +167,46 @@ serd_env_set_base_uri(SerdEnv* const env, const SerdStringView uri)
   return SERD_SUCCESS;
 }
 
+SerdStatus
+serd_env_set_base_path(SerdEnv* const env, const SerdStringView path)
+{
+  assert(env);
+
+  if (!path.data || !path.length) {
+    return serd_env_set_base_uri(env, serd_empty_string());
+  }
+
+  char* const real_path = zix_canonical_path(NULL, path.data);
+  if (!real_path) {
+    return SERD_BAD_ARG;
+  }
+
+  const size_t real_path_len = strlen(real_path);
+  SerdNode*    base_node     = NULL;
+  const char   path_last     = path.data[path.length - 1];
+  if (path_last == '/' || path_last == '\\') {
+    char* const base_path =
+      (char*)serd_acalloc(env->allocator, real_path_len + 2, 1);
+
+    memcpy(base_path, real_path, real_path_len + 1);
+    base_path[real_path_len] = path_last;
+
+    base_node = serd_node_new(
+      NULL, serd_a_file_uri(serd_string(base_path), serd_empty_string()));
+
+    serd_afree(env->allocator, base_path);
+  } else {
+    base_node = serd_node_new(
+      NULL, serd_a_file_uri(serd_string(real_path), serd_empty_string()));
+  }
+
+  serd_env_set_base_uri(env, serd_node_string_view(base_node));
+  serd_node_free(NULL, base_node);
+  zix_free(NULL, real_path);
+
+  return SERD_SUCCESS;
+}
+
 SerdStringView
 serd_env_find_prefix(const SerdEnv* const env, const SerdStringView name)
 {
diff --git a/test/meson.build b/test/meson.build
index 6bb0e033..e86f34e9 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -278,6 +278,14 @@ if is_variable('serd_pipe')
   # Base URI options
 
   test(
+    'good_rebase',
+    serd_pipe,
+    args: ['-B', 'rebase', '-o', 'serd_rebased.ttl', serd_ttl],
+    env: test_env,
+    suite: cmd_suite,
+  )
+
+  test(
     'bad_rebase',
     serd_pipe,
     args: ['-B', 'rebase', serd_ttl],
diff --git a/test/test_env.c b/test/test_env.c
index cc3a524f..5a4c95df 100644
--- a/test/test_env.c
+++ b/test/test_env.c
@@ -8,6 +8,7 @@
 #include "serd/env.h"
 #include "serd/event.h"
 #include "serd/node.h"
+#include "serd/nodes.h"
 #include "serd/sink.h"
 #include "serd/status.h"
 #include "serd/string_view.h"
@@ -201,8 +202,9 @@ count_prefixes(void* handle, const SerdEvent* event)
 static void
 test_base_uri(void)
 {
-  SerdEnv* const  env = serd_env_new(NULL, serd_empty_string());
-  SerdNode* const eg  = serd_node_new(NULL, serd_a_uri_string(NS_EG));
+  SerdNodes* const      nodes = serd_nodes_new(NULL);
+  SerdEnv* const        env   = serd_env_new(NULL, serd_empty_string());
+  const SerdNode* const eg    = serd_nodes_get(nodes, serd_a_uri_string(NS_EG));
 
   // Test that invalid calls work as expected
   assert(!serd_env_base_uri(env));
@@ -221,8 +223,8 @@ test_base_uri(void)
   assert(!serd_env_set_base_uri(env, serd_empty_string()));
   assert(!serd_env_base_uri(env));
 
-  serd_node_free(NULL, eg);
   serd_env_free(env);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -262,13 +264,14 @@ test_set_prefix(void)
 static void
 test_expand_untyped_literal(void)
 {
-  SerdNode* const untyped = serd_node_new(NULL, serd_a_string("data"));
-  SerdEnv* const  env     = serd_env_new(NULL, serd_empty_string());
+  SerdNodes* const      nodes   = serd_nodes_new(NULL);
+  const SerdNode* const untyped = serd_nodes_get(nodes, serd_a_string("data"));
+  SerdEnv* const        env     = serd_env_new(NULL, serd_empty_string());
 
   assert(!serd_env_expand_node(env, untyped));
 
   serd_env_free(env);
-  serd_node_free(NULL, untyped);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -276,15 +279,17 @@ test_expand_bad_uri_datatype(void)
 {
   const SerdStringView type = serd_string("Type");
 
-  SerdNode* const typed =
-    serd_node_new(NULL, serd_a_typed_literal(serd_string("data"), type));
+  SerdNodes* const nodes = serd_nodes_new(NULL);
+
+  const SerdNode* const typed =
+    serd_nodes_get(nodes, serd_a_typed_literal(serd_string("data"), type));
 
   SerdEnv* const env = serd_env_new(NULL, serd_empty_string());
 
   assert(!serd_env_expand_node(env, typed));
 
   serd_env_free(env);
-  serd_node_free(NULL, typed);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -292,20 +297,21 @@ test_expand_uri(void)
 {
   const SerdStringView base = serd_string("http://example.org/b/");
 
-  SerdEnv* const  env       = serd_env_new(NULL, base);
-  SerdNode* const rel       = serd_node_new(NULL, serd_a_uri_string("rel"));
+  SerdNodes* const      nodes = serd_nodes_new(NULL);
+  SerdEnv* const        env   = serd_env_new(NULL, base);
+  const SerdNode* const rel   = serd_nodes_get(nodes, serd_a_uri_string("rel"));
+  const SerdNode* const empty = serd_nodes_get(nodes, serd_a_uri_string(""));
+
   SerdNode* const rel_out   = serd_env_expand_node(env, rel);
-  SerdNode* const empty     = serd_node_new(NULL, serd_a_uri_string(""));
   SerdNode* const empty_out = serd_env_expand_node(env, empty);
 
   assert(!strcmp(serd_node_string(rel_out), "http://example.org/b/rel"));
   assert(!strcmp(serd_node_string(empty_out), "http://example.org/b/"));
 
   serd_node_free(NULL, empty_out);
-  serd_node_free(NULL, empty);
   serd_node_free(NULL, rel_out);
-  serd_node_free(NULL, rel);
   serd_env_free(env);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -313,27 +319,31 @@ test_expand_empty_uri_ref(void)
 {
   const SerdStringView base = serd_string("http://example.org/b/");
 
-  SerdNode* const rel     = serd_node_new(NULL, serd_a_uri_string("rel"));
-  SerdEnv* const  env     = serd_env_new(NULL, base);
-  SerdNode* const rel_out = serd_env_expand_node(env, rel);
+  SerdNodes* const      nodes = serd_nodes_new(NULL);
+  SerdEnv* const        env   = serd_env_new(NULL, base);
+  const SerdNode* const rel   = serd_nodes_get(nodes, serd_a_uri_string("rel"));
+  SerdNode* const       rel_out = serd_env_expand_node(env, rel);
 
   assert(!strcmp(serd_node_string(rel_out), "http://example.org/b/rel"));
   serd_node_free(NULL, rel_out);
 
   serd_env_free(env);
-  serd_node_free(NULL, rel);
+  serd_nodes_free(nodes);
 }
 
 static void
 test_expand_bad_uri(void)
 {
-  SerdNode* const bad_uri = serd_node_new(NULL, serd_a_uri_string("rel"));
-  SerdEnv* const  env     = serd_env_new(NULL, serd_empty_string());
+  SerdNodes* const nodes = serd_nodes_new(NULL);
+  SerdEnv* const   env   = serd_env_new(NULL, serd_empty_string());
+
+  const SerdNode* const bad_uri =
+    serd_nodes_get(nodes, serd_a_uri_string("rel"));
 
   assert(!serd_env_expand_node(env, bad_uri));
 
   serd_env_free(env);
-  serd_node_free(NULL, bad_uri);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -372,13 +382,16 @@ test_expand_bad_curie(void)
 static void
 test_expand_blank(void)
 {
-  SerdNode* const blank = serd_node_new(NULL, serd_a_blank_string("b1"));
-  SerdEnv* const  env   = serd_env_new(NULL, serd_empty_string());
+  SerdNodes* const      nodes = serd_nodes_new(NULL);
+  const SerdNode* const blank =
+    serd_nodes_get(nodes, serd_a_blank(serd_string("b1")));
+
+  SerdEnv* const env = serd_env_new(NULL, serd_empty_string());
 
   assert(!serd_env_expand_node(env, blank));
 
   serd_env_free(env);
-  serd_node_free(NULL, blank);
+  serd_nodes_free(nodes);
 }
 
 static void
diff --git a/test/test_node.c b/test/test_node.c
index c1b83140..7ed6e3c5 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -158,6 +158,7 @@ test_boolean(void)
   {
     SerdNode* const true_node =
       serd_node_new(NULL, serd_a_primitive(serd_bool(true)));
+
     assert(true_node);
     assert(!strcmp(serd_node_string(true_node), "true"));
     assert(serd_node_value(true_node).data.as_bool);
@@ -170,6 +171,7 @@ test_boolean(void)
   {
     SerdNode* const false_node =
       serd_node_new(NULL, serd_a_primitive(serd_bool(false)));
+
     assert(false_node);
     assert(!strcmp(serd_node_string(false_node), "false"));
     assert(!serd_node_value(false_node).data.as_bool);
@@ -264,8 +266,9 @@ test_double(void)
     "0.0E0", "-0.0E0", "1.2E0", "-2.3E0", "4.56789E6"};
 
   for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
-    SerdNode* node =
+    SerdNode* const node =
       serd_node_new(NULL, serd_a_primitive(serd_double(test_values[i])));
+
     const char* node_str = serd_node_string(node);
     assert(!strcmp(node_str, test_strings[i]));
 
@@ -336,8 +339,9 @@ test_float(void)
     "0.0E0", "-0.0E0", "1.5E0", "-2.5E0", "4.56789E6"};
 
   for (size_t i = 0; i < sizeof(test_values) / sizeof(float); ++i) {
-    SerdNode* node =
+    SerdNode* const node =
       serd_node_new(NULL, serd_a_primitive(serd_float(test_values[i])));
+
     const char* node_str = serd_node_string(node);
     assert(!strcmp(node_str, test_strings[i]));
 
@@ -635,6 +639,7 @@ static void
 test_node_from_syntax(void)
 {
   SerdNode* const hello = serd_node_new(NULL, serd_a_string("hello\""));
+
   assert(serd_node_length(hello) == 6);
   assert(!serd_node_flags(hello));
   assert(!strncmp(serd_node_string(hello), "hello\"", 6));
@@ -656,6 +661,7 @@ test_node_from_substring(void)
 {
   SerdNode* const a_b =
     serd_node_new(NULL, serd_a_string_view(serd_substring("a\"bc", 3)));
+
   assert(serd_node_length(a_b) == 3);
   assert(!serd_node_flags(a_b));
   assert(strlen(serd_node_string(a_b)) == 3);
@@ -674,16 +680,45 @@ check_copy_equals(const SerdNode* const node)
 }
 
 static void
+test_uri(void)
+{
+  const SerdStringView base = serd_string("http://example.org/base/");
+  const SerdStringView rel  = serd_string("a/b");
+  const SerdStringView abs  = serd_string("http://example.org/base/a/b");
+
+  const SerdURIView base_uri = serd_parse_uri(base.data);
+  const SerdURIView rel_uri  = serd_parse_uri(rel.data);
+  const SerdURIView abs_uri  = serd_resolve_uri(rel_uri, base_uri);
+
+  SerdNode* const from_string = serd_node_new(NULL, serd_a_uri(abs));
+
+  SerdNode* const from_uri = serd_node_new(NULL, serd_a_parsed_uri(abs_uri));
+
+  assert(from_string);
+  assert(from_uri);
+  assert(!strcmp(serd_node_string(from_string), serd_node_string(from_uri)));
+
+  serd_node_free(NULL, from_uri);
+  serd_node_free(NULL, from_string);
+}
+
+static void
 test_literal(void)
 {
   const SerdStringView hello_str = serd_string("hello");
   const SerdStringView empty_str = serd_empty_string();
 
+  assert(!serd_node_new(NULL,
+                        serd_a_literal(hello_str,
+                                       SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE,
+                                       serd_string("whatever"))));
+
   assert(!serd_node_new(NULL, serd_a_typed_literal(hello_str, empty_str)));
   assert(!serd_node_new(NULL, serd_a_plain_literal(hello_str, empty_str)));
 
   assert(
     !serd_node_new(NULL, serd_a_typed_literal(hello_str, serd_string("Type"))));
+
   assert(
     !serd_node_new(NULL, serd_a_typed_literal(hello_str, serd_string("de"))));
 
@@ -756,12 +791,11 @@ test_compare(void)
   SerdNode* angst_de = serd_node_new(
     NULL, serd_a_plain_literal(serd_string("angst"), serd_string("de")));
 
-  assert(angst_de);
   SerdNode* angst_en = serd_node_new(
     NULL, serd_a_plain_literal(serd_string("angst"), serd_string("en")));
 
   SerdNode* hallo = serd_node_new(
-    NULL, serd_a_typed_literal(serd_string("Hallo"), serd_string("de")));
+    NULL, serd_a_plain_literal(serd_string("Hallo"), serd_string("de")));
 
   SerdNode* hello     = serd_node_new(NULL, serd_a_string("Hello"));
   SerdNode* universe  = serd_node_new(NULL, serd_a_string("Universe"));
@@ -828,6 +862,7 @@ main(void)
   test_node_equals();
   test_node_from_syntax();
   test_node_from_substring();
+  test_uri();
   test_literal();
   test_blank();
   test_compare();
diff --git a/test/test_overflow.c b/test/test_overflow.c
index edabd4eb..abc7d989 100644
--- a/test/test_overflow.c
+++ b/test/test_overflow.c
@@ -22,14 +22,16 @@ test_size(SerdWorld* const      world,
   limits.reader_stack_size = stack_size;
   serd_world_set_limits(world, limits);
 
-  SerdSink*         sink   = serd_sink_new(NULL, NULL, NULL, NULL);
-  SerdEnv* const    env    = serd_env_new(NULL, serd_empty_string());
-  SerdReader* const reader = serd_reader_new(world, syntax, flags, env, sink);
+  SerdNodes* const     nodes = serd_world_nodes(world);
+  SerdAllocator* const alloc = serd_world_allocator(world);
+  SerdSink*            sink  = serd_sink_new(alloc, NULL, NULL, NULL);
+  SerdEnv* const       env   = serd_env_new(alloc, serd_empty_string());
+  SerdReader* const reader   = serd_reader_new(world, syntax, flags, env, sink);
   if (!reader) {
     return SERD_BAD_STACK;
   }
 
-  SerdNode*       string_name = serd_node_new(NULL, serd_a_string("string"));
+  const SerdNode* string_name = serd_nodes_get(nodes, serd_a_string("string"));
   const char*     position    = str;
   SerdInputStream in          = serd_open_input_string(&position);
   serd_reader_start(reader, &in, string_name, 1);
@@ -37,7 +39,6 @@ test_size(SerdWorld* const      world,
   const SerdStatus st = serd_reader_read_document(reader);
 
   serd_close_input(&in);
-  serd_node_free(NULL, string_name);
   serd_reader_free(reader);
   serd_env_free(env);
   serd_sink_free(sink);
diff --git a/test/test_reader.c b/test/test_reader.c
index 54dbca9f..3d59af8e 100644
--- a/test/test_reader.c
+++ b/test/test_reader.c
@@ -10,6 +10,7 @@
 #include "serd/event.h"
 #include "serd/input_stream.h"
 #include "serd/node.h"
+#include "serd/nodes.h"
 #include "serd/reader.h"
 #include "serd/sink.h"
 #include "serd/statement.h"
@@ -613,6 +614,7 @@ static void
 test_error_cursor(void)
 {
   SerdWorld* const  world  = serd_world_new(NULL);
+  SerdNodes* const  nodes  = serd_world_nodes(world);
   bool              called = false;
   SerdSink* const   sink   = serd_sink_new(NULL, &called, check_cursor, NULL);
   SerdEnv* const    env    = serd_env_new(NULL, serd_empty_string());
@@ -624,9 +626,11 @@ test_error_cursor(void)
     "<http://example.org/s> <http://example.org/p> "
     "<http://example.org/o> .";
 
-  SerdNode* const string_name = serd_node_new(NULL, serd_a_string("string"));
-  const char*     position    = string;
-  SerdInputStream in          = serd_open_input_string(&position);
+  const SerdNode* const string_name =
+    serd_nodes_get(nodes, serd_a_string("string"));
+
+  const char*     position = string;
+  SerdInputStream in       = serd_open_input_string(&position);
 
   SerdStatus st = serd_reader_start(reader, &in, string_name, 1);
   assert(!st);
@@ -635,7 +639,6 @@ test_error_cursor(void)
   assert(called);
   assert(!serd_close_input(&in));
 
-  serd_node_free(NULL, string_name);
   serd_reader_free(reader);
   serd_env_free(env);
   serd_sink_free(sink);
diff --git a/test/test_uri.c b/test/test_uri.c
index 294b00ec..b1af8a02 100644
--- a/test/test_uri.c
+++ b/test/test_uri.c
@@ -169,13 +169,15 @@ test_parse_uri(void)
   const SerdURIView base_uri  = serd_parse_uri(base.data);
   const SerdURIView empty_uri = serd_parse_uri("");
 
-  SerdNode* const nil = serd_node_new(
-    NULL, serd_a_parsed_uri(serd_resolve_uri(empty_uri, base_uri)));
+  SerdNodes* const nodes = serd_nodes_new(NULL);
+
+  const SerdNode* const nil = serd_nodes_get(
+    nodes, serd_a_parsed_uri(serd_resolve_uri(empty_uri, base_uri)));
 
   assert(serd_node_type(nil) == SERD_URI);
   assert(!strcmp(serd_node_string(nil), base.data));
 
-  serd_node_free(NULL, nil);
+  serd_nodes_free(nodes);
 }
 
 static void
@@ -230,27 +232,27 @@ check_relative_uri(const char* const uri_string,
   assert(base_string);
   assert(expected_string);
 
-  SerdNode* const uri_node = serd_node_new(NULL, serd_a_uri_string(uri_string));
-  const SerdURIView uri    = serd_node_uri_view(uri_node);
-  SerdNode* const   base_node =
-    serd_node_new(NULL, serd_a_uri_string(base_string));
-
+  SerdNodes* const nodes = serd_nodes_new(NULL);
+  const SerdNode*  uri_node =
+    serd_nodes_get(nodes, serd_a_uri_string(uri_string));
+  const SerdURIView uri = serd_node_uri_view(uri_node);
+  const SerdNode*   base_node =
+    serd_nodes_get(nodes, serd_a_uri_string(base_string));
   const SerdURIView base = serd_node_uri_view(base_node);
 
-  SerdNode* result_node = NULL;
+  const SerdNode* result_node = NULL;
   if (!root_string) {
     result_node =
-      serd_node_new(NULL, serd_a_parsed_uri(serd_relative_uri(uri, base)));
+      serd_nodes_get(nodes, serd_a_parsed_uri(serd_relative_uri(uri, base)));
   } else {
-    SerdNode* const root_node =
-      serd_node_new(NULL, serd_a_uri_string(root_string));
+    const SerdNode* root_node =
+      serd_nodes_get(nodes, serd_a_uri_string(root_string));
     const SerdURIView root = serd_node_uri_view(root_node);
 
     result_node =
       serd_uri_is_within(uri, root)
-        ? serd_node_new(NULL, serd_a_parsed_uri(serd_relative_uri(uri, base)))
-        : serd_node_new(NULL, serd_a_uri_string(uri_string));
-    serd_node_free(NULL, root_node);
+        ? serd_nodes_get(nodes, serd_a_parsed_uri(serd_relative_uri(uri, base)))
+        : serd_nodes_get(nodes, serd_a_uri_string(uri_string));
   }
 
   assert(!strcmp(serd_node_string(result_node), expected_string));
@@ -263,10 +265,7 @@ check_relative_uri(const char* const uri_string,
   assert(chunk_equals(&result.path, &expected.path));
   assert(chunk_equals(&result.query, &expected.query));
   assert(chunk_equals(&result.fragment, &expected.fragment));
-
-  serd_node_free(NULL, result_node);
-  serd_node_free(NULL, base_node);
-  serd_node_free(NULL, uri_node);
+  serd_nodes_free(nodes);
 }
 
 static void
diff --git a/test/test_writer.c b/test/test_writer.c
index a80783f6..60f50308 100644
--- a/test/test_writer.c
+++ b/test/test_writer.c
@@ -237,7 +237,7 @@ test_writer_cleanup(void)
   const SerdNode* const p =
     serd_nodes_get(nodes, serd_a_uri_string("http://example.org/p"));
 
-  const SerdNode* o = serd_nodes_get(nodes, serd_a_string("start"));
+  const SerdNode* o = serd_nodes_get(nodes, serd_a_blank(serd_string("start")));
 
   st = serd_sink_write(sink, SERD_ANON_O, s, p, o, NULL);
   assert(!st);
@@ -257,9 +257,8 @@ test_writer_cleanup(void)
   assert(!(st = serd_writer_finish(writer)));
 
   // Set the base to an empty URI
-  const SerdNode* const empty_uri =
-    serd_nodes_get(nodes, serd_a_uri_string(""));
-  assert(!(st = serd_sink_write_base(sink, empty_uri)));
+  assert(!(st = serd_sink_write_base(
+             sink, serd_nodes_get(nodes, serd_a_uri_string("")))));
 
   // Free (which could leak if the writer doesn't clean up the stack properly)
   serd_writer_free(writer);
@@ -275,6 +274,7 @@ test_strict_write(void)
   assert(fd);
 
   SerdWorld*        world = serd_world_new(NULL);
+  SerdNodes*        nodes = serd_world_nodes(world);
   SerdEnv* const    env   = serd_env_new(NULL, serd_empty_string());
   SerdOutputStream  out   = serd_open_output_stream(null_sink, NULL, NULL, fd);
   SerdWriter* const writer =
@@ -286,21 +286,23 @@ test_strict_write(void)
 
   const uint8_t bad_str[] = {0xFF, 0x90, 'h', 'i', 0};
 
-  SerdNode* s = serd_node_new(NULL, serd_a_uri_string("http://example.org/s"));
-  SerdNode* p = serd_node_new(NULL, serd_a_uri_string("http://example.org/p"));
+  const SerdNode* const s =
+    serd_nodes_get(nodes, serd_a_uri_string("http://example.org/s"));
+
+  const SerdNode* const p =
+    serd_nodes_get(nodes, serd_a_uri_string("http://example.org/p"));
+
+  const SerdNode* const bad_lit =
+    serd_nodes_get(nodes, serd_a_string((const char*)bad_str));
 
-  SerdNode* bad_lit = serd_node_new(NULL, serd_a_string((const char*)bad_str));
-  SerdNode* bad_uri =
-    serd_node_new(NULL, serd_a_uri_string((const char*)bad_str));
+  const SerdNode* const bad_uri =
+    serd_nodes_get(nodes, serd_a_uri_string((const char*)bad_str));
 
   assert(serd_sink_write(sink, 0, s, p, bad_lit, NULL) == SERD_BAD_TEXT);
   assert(serd_sink_write(sink, 0, s, p, bad_uri, NULL) == SERD_BAD_TEXT);
 
-  serd_node_free(NULL, bad_uri);
-  serd_node_free(NULL, bad_lit);
-  serd_node_free(NULL, p);
-  serd_node_free(NULL, s);
   serd_writer_free(writer);
+  serd_close_output(&out);
   serd_env_free(env);
   serd_world_free(world);
   fclose(fd);
@@ -325,11 +327,13 @@ static void
 test_write_error(void)
 {
   SerdWorld* const world = serd_world_new(NULL);
+  SerdNodes* const nodes = serd_world_nodes(world);
   SerdEnv* const   env   = serd_env_new(NULL, serd_empty_string());
   SerdOutputStream out = serd_open_output_stream(error_sink, NULL, NULL, NULL);
   SerdStatus       st  = SERD_SUCCESS;
 
-  SerdNode* u = serd_node_new(NULL, serd_a_uri_string("http://example.com/u"));
+  const SerdNode* const u =
+    serd_nodes_get(nodes, serd_a_uri_string("http://example.com/u"));
 
   SerdWriter* const writer =
     serd_writer_new(world, SERD_TURTLE, (SerdWriterFlags)0, env, &out, 1U);
@@ -341,7 +345,6 @@ test_write_error(void)
   assert(st == SERD_BAD_WRITE);
   serd_writer_free(writer);
 
-  serd_node_free(NULL, u);
   serd_env_free(env);
   serd_world_free(world);
 }
diff --git a/tools/console.c b/tools/console.c
index 94d9a0c5..89223eaf 100644
--- a/tools/console.c
+++ b/tools/console.c
@@ -10,9 +10,7 @@
 #include "serd/syntax.h"
 #include "serd/uri.h"
 #include "serd/version.h"
-#include "zix/allocator.h"
 #include "zix/attributes.h"
-#include "zix/filesystem.h"
 
 #ifdef _WIN32
 #  ifdef _MSC_VER
@@ -197,39 +195,6 @@ serd_get_size_argument(OptionIter* const iter, size_t* const argument)
   return SERD_SUCCESS;
 }
 
-SerdStatus
-serd_set_base_uri_from_path(SerdEnv* const env, const char* const path)
-{
-  const size_t path_len  = strlen(path);
-  char* const  real_path = zix_canonical_path(NULL, path);
-  if (!real_path) {
-    return SERD_BAD_ARG;
-  }
-
-  const size_t real_path_len = strlen(real_path);
-  SerdNode*    base_node     = NULL;
-  if (path[path_len - 1] == '/' || path[path_len - 1] == '\\') {
-    char* const base_path = (char*)calloc(real_path_len + 2, 1);
-
-    memcpy(base_path, real_path, real_path_len + 1);
-    base_path[real_path_len] = path[path_len - 1];
-
-    base_node = serd_node_new(
-      NULL, serd_a_file_uri(serd_string(base_path), serd_empty_string()));
-
-    free(base_path);
-  } else {
-    base_node = serd_node_new(
-      NULL, serd_a_file_uri(serd_string(real_path), serd_empty_string()));
-  }
-
-  serd_env_set_base_uri(env, serd_node_string_view(base_node));
-  serd_node_free(NULL, base_node);
-  zix_free(NULL, real_path);
-
-  return SERD_SUCCESS;
-}
-
 SerdSyntax
 serd_choose_syntax(SerdWorld* const        world,
                    const SerdSyntaxOptions options,
@@ -431,24 +396,29 @@ serd_create_env(SerdAllocator* const allocator,
                 const char* const    base_string,
                 const char* const    out_filename)
 {
-  const bool is_rebase = base_string && !strcmp(base_string, "rebase");
-  if (is_rebase && !out_filename) {
-    fprintf(stderr, "%s: rebase requires an output filename\n", program);
-    return NULL;
-  }
-
-  if (base_string && serd_uri_string_has_scheme(base_string)) {
+  if (serd_uri_string_has_scheme(base_string)) {
     return serd_env_new(allocator, serd_string(base_string));
   }
 
-  SerdEnv* const env = serd_env_new(allocator, serd_empty_string());
-  if (base_string && base_string[0]) {
-    const SerdStatus st = serd_set_base_uri_from_path(env, base_string);
-    if (st) {
-      fprintf(stderr, "%s: invalid base URI \"%s\"\n", program, base_string);
-      serd_env_free(env);
+  const bool is_rebase = !strcmp(base_string, "rebase");
+  if (is_rebase) {
+    if (!out_filename) {
+      fprintf(stderr, "%s: rebase requires an output filename\n", program);
       return NULL;
     }
+
+    SerdEnv* const env = serd_env_new(allocator, serd_empty_string());
+    serd_env_set_base_path(env, serd_string(out_filename));
+    return env;
+  }
+
+  SerdEnv* const       env  = serd_env_new(allocator, serd_empty_string());
+  const SerdStringView base = serd_string(base_string);
+  const SerdStatus     st   = serd_env_set_base_path(env, base);
+  if (st) {
+    fprintf(stderr, "%s: invalid base URI \"%s\"\n", program, base_string);
+    serd_env_free(env);
+    return NULL;
   }
 
   return env;
@@ -536,7 +506,7 @@ serd_read_inputs(SerdWorld* const        world,
     // Use the filename as the base URI if possible if user didn't override it
     const char* const in_path = inputs[i];
     if (!opts.base_uri[0] && !!strcmp(in_path, "-")) {
-      serd_set_base_uri_from_path(env, in_path);
+      serd_env_set_base_path(env, serd_string(in_path));
     }
 
     // Open the input stream
diff --git a/tools/console.h b/tools/console.h
index c8c68411..ed59264a 100644
--- a/tools/console.h
+++ b/tools/console.h
@@ -76,9 +76,6 @@ serd_set_stream_utf8_mode(FILE* stream);
 SerdStatus
 serd_print_version(const char* program);
 
-SerdStatus
-serd_set_base_uri_from_path(SerdEnv* env, const char* path);
-
 SerdSyntax
 serd_choose_syntax(SerdWorld*        world,
                    SerdSyntaxOptions options,