Add empty syntax type for suppressing output

8 files changed, 115 insertions, 29 deletions

diff --git a/doc/serdi.1 b/doc/serdi.1
index b3c852d7..bc8de6cb 100644
--- a/doc/serdi.1
+++ b/doc/serdi.1
@@ -67,6 +67,7 @@ Case is ignored, valid values are:
 .Dq NQuads ,
 .Dq NTriples ,
 .Dq TriG ,
+and
 .Dq Turtle .
 .Pp
 .It Fl k Ar bytes
@@ -86,10 +87,15 @@ Note that data may be lost when using this option.
 Write output as
 .Ar syntax .
 Case is ignored, valid values are:
+.Dq empty ,
 .Dq NQuads ,
 .Dq NTriples ,
 .Dq TriG ,
+and
 .Dq Turtle .
+When
+.Dq empty
+is given, output is suppressed, so only errors will be printed.
 .Pp
 .It Fl p Ar prefix
 Add
diff --git a/include/serd/serd.h b/include/serd/serd.h
index e2e610db..e13fc2db 100644
--- a/include/serd/serd.h
+++ b/include/serd/serd.h
@@ -349,17 +349,20 @@ serd_byte_sink_free(SerdByteSink* SERD_NULLABLE sink);
 
 /// Syntax supported by serd
 typedef enum {
-  SERD_TURTLE   = 1, ///< Terse triples http://www.w3.org/TR/turtle
-  SERD_NTRIPLES = 2, ///< Line-based triples http://www.w3.org/TR/n-triples/
-  SERD_NQUADS   = 3, ///< Line-based quads http://www.w3.org/TR/n-quads/
-  SERD_TRIG     = 4  ///< Terse quads http://www.w3.org/TR/trig/
+  SERD_SYNTAX_EMPTY = 0, ///< Empty syntax
+  SERD_TURTLE       = 1, ///< Terse triples http://www.w3.org/TR/turtle
+  SERD_NTRIPLES     = 2, ///< Flat triples http://www.w3.org/TR/n-triples/
+  SERD_NQUADS       = 3, ///< Flat quads http://www.w3.org/TR/n-quads/
+  SERD_TRIG         = 4  ///< Terse quads http://www.w3.org/TR/trig/
 } SerdSyntax;
 
 /**
    Get a syntax by name.
 
-   Case-insensitive, supports "Turtle", "NTriples", "NQuads", and "TriG".  Zero
-   is returned if the name is not recognized.
+   Case-insensitive, supports "Turtle", "NTriples", "NQuads", and "TriG".
+
+   @return The syntax with the given name, or the empty syntax if the name is
+   not recognised.
 */
 SERD_PURE_API
 SerdSyntax
@@ -368,8 +371,11 @@ serd_syntax_by_name(const char* SERD_NONNULL name);
 /**
    Guess a syntax from a filename.
 
-   This uses the file extension to guess the syntax of a file.  Zero is
-   returned if the extension is not recognized.
+   This uses the file extension to guess the syntax of a file, for example
+   recognising ".ttl" as the extension of a Turtle file.
+
+   @return The likely syntax of the given file, or the empty syntax if the
+   extension is not recognised.
 */
 SERD_PURE_API
 SerdSyntax
diff --git a/src/serdi.c b/src/serdi.c
index 155e570a..74b8cad4 100644
--- a/src/serdi.c
+++ b/src/serdi.c
@@ -31,6 +31,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #define SERDI_ERROR(msg) fprintf(stderr, "serdi: " msg)
 #define SERDI_ERRORF(fmt, ...) fprintf(stderr, "serdi: " fmt, __VA_ARGS__)
@@ -63,7 +64,7 @@ print_usage(const char* const name, const bool error)
   fprintf(os, "  -i SYNTAX    Input syntax: turtle/ntriples/trig/nquads.\n");
   fprintf(os, "  -k BYTES     Parser stack size.\n");
   fprintf(os, "  -l           Lax (non-strict) parsing.\n");
-  fprintf(os, "  -o SYNTAX    Output syntax: turtle/ntriples/nquads.\n");
+  fprintf(os, "  -o SYNTAX    Output syntax: empty/turtle/ntriples/nquads.\n");
   fprintf(os, "  -p PREFIX    Add PREFIX to blank node IDs.\n");
   fprintf(os, "  -q           Suppress all output except data.\n");
   fprintf(os, "  -r ROOT_URI  Keep relative URIs within ROOT_URI.\n");
@@ -96,14 +97,15 @@ main(int argc, char** argv)
     return print_usage(prog, true);
   }
 
-  SerdSyntax      input_syntax  = (SerdSyntax)0;
-  SerdSyntax      output_syntax = (SerdSyntax)0;
+  SerdSyntax      input_syntax  = SERD_SYNTAX_EMPTY;
+  SerdSyntax      output_syntax = SERD_SYNTAX_EMPTY;
   SerdWriterFlags writer_flags  = 0;
   bool            from_string   = false;
   bool            from_stdin    = false;
   bool            bulk_read     = true;
   bool            bulk_write    = false;
   bool            lax           = false;
+  bool            osyntax_set   = false;
   bool            quiet         = false;
   size_t          stack_size    = 4194304;
   const char*     add_prefix    = NULL;
@@ -171,12 +173,15 @@ main(int argc, char** argv)
         stack_size = (size_t)size;
         break;
       } else if (opt == 'o') {
+        osyntax_set = true;
         if (argv[a][o + 1] || ++a == argc) {
           return missing_arg(prog, 'o');
         }
 
-        if (!(output_syntax = serd_syntax_by_name(argv[a]))) {
-          return print_usage(prog, true);
+        if (!strcmp(argv[a], "empty")) {
+          output_syntax = SERD_SYNTAX_EMPTY;
+        } else if (!(output_syntax = serd_syntax_by_name(argv[a]))) {
+          return print_usage(argv[0], true);
         }
         break;
       } else if (opt == 'p') {
@@ -217,7 +222,7 @@ main(int argc, char** argv)
   }
 
   const bool input_has_graphs = serd_syntax_has_graphs(input_syntax);
-  if (!output_syntax) {
+  if (!output_syntax && !osyntax_set) {
     output_syntax = input_has_graphs ? SERD_NQUADS : SERD_NTRIPLES;
   }
 
diff --git a/src/syntax.c b/src/syntax.c
index 61814709..59453bca 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -32,7 +32,7 @@ static const Syntax syntaxes[] = {
   {"ntriples", ".nt", SERD_NTRIPLES},
   {"nquads", ".nq", SERD_NQUADS},
   {"trig", ".trig", SERD_TRIG},
-  {NULL, NULL, (SerdSyntax)0},
+  {NULL, NULL, SERD_SYNTAX_EMPTY},
 };
 
 SerdSyntax
@@ -43,7 +43,7 @@ serd_syntax_by_name(const char* const name)
       return s->syntax;
     }
   }
-  return (SerdSyntax)0;
+  return SERD_SYNTAX_EMPTY;
 }
 
 SerdSyntax
@@ -52,12 +52,12 @@ serd_guess_syntax(const char* const filename)
   const char* ext = strrchr(filename, '.');
   if (ext) {
     for (const Syntax* s = syntaxes; s->name; ++s) {
-      if (!serd_strncasecmp(s->extension, ext, strlen(ext))) {
+      if (s->extension && !serd_strncasecmp(s->extension, ext, strlen(ext))) {
         return s->syntax;
       }
     }
   }
-  return (SerdSyntax)0;
+  return SERD_SYNTAX_EMPTY;
 }
 
 bool
diff --git a/src/writer.c b/src/writer.c
index cd6ce613..3e0faa1e 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -792,9 +792,8 @@ write_curie(SerdWriter* const writer, const SerdNode* const node)
   SerdStringView prefix = {NULL, 0};
   SerdStringView suffix = {NULL, 0};
   SerdStatus     st     = SERD_SUCCESS;
-  switch (writer->syntax) {
-  case SERD_NTRIPLES:
-  case SERD_NQUADS:
+
+  if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
     if ((st = serd_env_expand_in_place(writer->env, node, &prefix, &suffix))) {
       serd_world_errorf(writer->world,
                         st,
@@ -802,18 +801,14 @@ write_curie(SerdWriter* const writer, const SerdNode* const node)
                         serd_node_string(node));
       return st;
     }
+
     TRY(st, esink("<", 1, writer));
     TRY(st, ewrite_uri(writer, prefix.buf, prefix.len));
     TRY(st, ewrite_uri(writer, suffix.buf, suffix.len));
-    TRY(st, esink(">", 1, writer));
-    break;
-  case SERD_TURTLE:
-  case SERD_TRIG:
-    TRY(st, write_lname(writer, serd_node_string(node), node->length));
-    break;
+    return esink(">", 1, writer);
   }
 
-  return st;
+  return write_lname(writer, serd_node_string(node), node->length);
 }
 
 SERD_WARN_UNUSED_RESULT static SerdStatus
@@ -922,6 +917,10 @@ serd_writer_write_statement(SerdWriter* const          writer,
   assert(!((flags & SERD_ANON_S) && (flags & SERD_LIST_S)));
   assert(!((flags & SERD_ANON_O) && (flags & SERD_LIST_O)));
 
+  if (writer->syntax == SERD_SYNTAX_EMPTY) {
+    return SERD_SUCCESS;
+  }
+
   SerdStatus            st        = SERD_SUCCESS;
   const SerdNode* const subject   = serd_statement_subject(statement);
   const SerdNode* const predicate = serd_statement_predicate(statement);
@@ -1064,7 +1063,7 @@ serd_writer_write_statement(SerdWriter* const          writer,
 SERD_WARN_UNUSED_RESULT static SerdStatus
 serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
 {
-  if (writer->syntax == SERD_NTRIPLES || writer->syntax == SERD_NQUADS) {
+  if (writer->syntax != SERD_TURTLE && writer->syntax != SERD_TRIG) {
     return SERD_SUCCESS;
   }
 
diff --git a/test/meson.build b/test/meson.build
index cd748c0c..9724f18e 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -138,6 +138,15 @@ if get_option('utils')
        should_fail: true,
        suite: ['serdi', 'input'])
 
+  # Output
+
+  test('empty', files('test_empty.py'),
+       args: script_args + [serd_ttl],
+       env: test_env,
+       suite: 'output')
+
+  # FIXME: Old base URI argument?
+
   # IO errors
 
   test('read_dir', serdi,
diff --git a/test/test_empty.py b/test/test_empty.py
new file mode 100755
index 00000000..a7978e6c
--- /dev/null
+++ b/test/test_empty.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+"""Test writing empty output."""
+
+import argparse
+import sys
+import shlex
+import subprocess
+import tempfile
+
+parser = argparse.ArgumentParser(description=__doc__)
+
+parser.add_argument("--serdi", default="./serdi", help="path to serdi")
+parser.add_argument("--wrapper", default="", help="executable wrapper")
+parser.add_argument("input", help="valid input file")
+
+args = parser.parse_args(sys.argv[1:])
+command = shlex.split(args.wrapper) + [args.serdi, "-o", "empty", args.input]
+
+with tempfile.TemporaryFile() as out:
+
+    proc = subprocess.run(command, check=False, stdout=out)
+
+    out.seek(0, 2)  # Seek to end
+
+    assert proc.returncode == 0
+    assert out.tell() == 0
diff --git a/test/test_writer.c b/test/test_writer.c
index aa5694cd..e31119bf 100644
--- a/test/test_writer.c
+++ b/test/test_writer.c
@@ -269,6 +269,39 @@ test_write_error(void)
   serd_world_free(world);
 }
 
+static void
+test_write_empty_syntax(void)
+{
+  SerdWorld* world = serd_world_new();
+  SerdNodes* nodes = serd_world_nodes(world);
+  SerdEnv*   env   = serd_env_new(SERD_EMPTY_STRING());
+
+  const SerdNode* s =
+    serd_nodes_uri(nodes, SERD_STRING("http://example.org/s"));
+  const SerdNode* p =
+    serd_nodes_uri(nodes, SERD_STRING("http://example.org/p"));
+
+  const SerdNode* o = serd_nodes_curie(nodes, SERD_STRING("eg:o"));
+
+  SerdBuffer buffer = {NULL, 0};
+
+  SerdWriter* writer = serd_writer_new(
+    world, SERD_SYNTAX_EMPTY, 0u, env, serd_buffer_sink, &buffer);
+
+  assert(writer);
+
+  assert(!serd_sink_write(serd_writer_sink(writer), 0u, s, p, o, NULL));
+
+  char* out = serd_buffer_sink_finish(&buffer);
+
+  assert(strlen(out) == 0);
+  serd_free(out);
+
+  serd_writer_free(writer);
+  serd_env_free(env);
+  serd_world_free(world);
+}
+
 int
 main(void)
 {
@@ -278,6 +311,7 @@ main(void)
   test_writer_stack_overflow();
   test_strict_write();
   test_write_error();
+  test_write_empty_syntax();
 
   return 0;
 }