namespace validation, additional json validation and tests, bug where output file was appended

GregHanson · GregHanson · commit 4728c1499ad3 · 2026-04-15T10:37:28.000-04:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -23,7 +23,7 @@ use oxrdf::{BlankNode, Graph, IriParseError, Literal, NamedNodeRef, TripleRef};
 
 use serde_json::{Deserializer, Value};
 use std::collections::VecDeque;
-use std::fs::{File, OpenOptions};
+use std::fs::File;
 use std::io::{BufReader, Write};
 use thiserror::Error;
 
@@ -45,6 +45,10 @@ pub enum Json2RdfError {
         #[source]
         source: IriParseError,
     },
+
+    /// A root-level JSON value has no predicate context and cannot be converted to a triple.
+    #[error("unsupported root-level JSON {kind}; root must be an object or array")]
+    UnsupportedRootValue { kind: &'static str },
 }
 
 /// Converts JSON data to RDF format.
@@ -77,11 +81,15 @@ pub fn json_to_rdf(
     namespace: &Option<String>,
     output_file: &Option<String>,
 ) -> Result<Option<Graph>, Json2RdfError> {
-    let rdf_namespace: String = if namespace.is_some() {
+    let mut prefix: String = if namespace.is_some() {
         namespace.clone().unwrap()
     } else {
         "https://decisym.ai/json2rdf/model".to_owned()
     };
+    // Respect hash (`#`), slash (`/`), and colon (`:`) terminators; otherwise default to `/`.
+    if !prefix.ends_with(['#', '/', ':']) {
+        prefix.push('/');
+    }
 
     let file = File::open(file_path)?;
     let reader = BufReader::new(file);
@@ -90,64 +98,57 @@ pub fn json_to_rdf(
     let mut graph = Graph::default(); // oxrdf Graph object
 
     let mut subject_stack: VecDeque<BlankNode> = VecDeque::new();
-    let mut property: Option<String> = None;
 
     for value in stream {
-        let value = value?;
-        match value {
-            Value::Object(obj) => {
-                let subject = BlankNode::default(); // Create a new blank node
-                subject_stack.push_back(subject);
-
-                for (key, val) in obj {
-                    property = Some(format!("{}/{}", rdf_namespace, key));
-                    process_value(
-                        &mut subject_stack,
-                        &property,
-                        val,
-                        &mut graph,
-                        &rdf_namespace,
-                    )?;
-                }
-
-                subject_stack.pop_back();
-            }
-            Value::Array(arr) => {
-                for val in arr {
-                    process_value(
-                        &mut subject_stack,
-                        &property,
-                        val,
-                        &mut graph,
-                        &rdf_namespace,
-                    )?;
-                }
-            }
-            other => {
-                process_value(
-                    &mut subject_stack,
-                    &property,
-                    other,
-                    &mut graph,
-                    &rdf_namespace,
-                )?;
-            }
-        }
+        process_top_level(&mut subject_stack, value?, &mut graph, &prefix)?;
     }
 
     if let Some(output_path) = output_file {
-        let mut file = OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(output_path)?;
-
+        let mut file = File::create(output_path)?;
         writeln!(file, "{}", graph)?;
         Ok(None)
     } else {
         Ok(Some(graph))
     }
 }
 
+/// Processes a single top-level JSON value from the input stream.
+///
+/// Each top-level value is handled independently: streamed values (NDJSON) do not
+/// share predicate state with each other. Root-level primitives have no predicate
+/// context and are rejected with [`Json2RdfError::UnsupportedRootValue`].
+fn process_top_level(
+    subject_stack: &mut VecDeque<BlankNode>,
+    value: Value,
+    graph: &mut Graph,
+    prefix: &String,
+) -> Result<(), Json2RdfError> {
+    match value {
+        Value::Object(obj) => {
+            let subject = BlankNode::default();
+            subject_stack.push_back(subject);
+
+            for (key, val) in obj {
+                let property = Some(format!("{}{}", prefix, key));
+                process_value(subject_stack, &property, val, graph, prefix)?;
+            }
+
+            subject_stack.pop_back();
+            Ok(())
+        }
+        Value::Array(arr) => {
+            for item in arr {
+                process_top_level(subject_stack, item, graph, prefix)?;
+            }
+            Ok(())
+        }
+        Value::Bool(_) => Err(Json2RdfError::UnsupportedRootValue { kind: "boolean" }),
+        Value::Number(_) => Err(Json2RdfError::UnsupportedRootValue { kind: "number" }),
+        Value::String(_) => Err(Json2RdfError::UnsupportedRootValue { kind: "string" }),
+        Value::Null => Err(Json2RdfError::UnsupportedRootValue { kind: "null" }),
+    }
+}
+
 /// This function handles different JSON data types, converting each into RDF triples:
 /// - JSON Objects create new blank nodes and recursively process nested values.
 /// - JSON Arrays iterate over each element and process it as an individual value.
@@ -165,7 +166,8 @@ pub fn json_to_rdf(
 /// - `property`: RDF predicate (property) associated with the JSON value.
 /// - `value`: JSON value to process.
 /// - `graph`: RDF graph where triples are added.
-/// - `namespace`: Namespace for generating predicate URIs.
+/// - `prefix`: Fully-prepared namespace prefix (already terminated with `#`, `/`, or `:`)
+///   used to build predicate IRIs by direct concatenation with each JSON key.
 ///
 /// # JSON Type to RDF Conversion
 /// - **Object**: Creates a blank node and recursively processes key-value pairs.
@@ -178,14 +180,8 @@ fn process_value(
     property: &Option<String>,
     value: Value,
     graph: &mut Graph,
-    namespace: &String,
+    prefix: &String,
 ) -> Result<(), Json2RdfError> {
-    let ns = if namespace.ends_with("/") {
-        namespace
-    } else {
-        &([namespace, "/"].join(""))
-    };
-
     let Some(last_subject) = subject_stack.back().cloned() else {
         return Ok(());
     };
@@ -233,14 +229,14 @@ fn process_value(
             subject_stack.push_back(new_subject);
 
             for (key, val) in obj {
-                let nested_property: Option<String> = Some(format!("{}{}", ns, key));
-                process_value(subject_stack, &nested_property, val, graph, ns)?;
+                let nested_property: Option<String> = Some(format!("{}{}", prefix, key));
+                process_value(subject_stack, &nested_property, val, graph, prefix)?;
             }
             subject_stack.pop_back();
         }
         Value::Array(arr) => {
             for val in arr {
-                process_value(subject_stack, property, val, graph, ns)?;
+                process_value(subject_stack, property, val, graph, prefix)?;
             }
         }
     }
diff --git a/tests/integration_test.rs b/tests/integration_test.rs
@@ -4,7 +4,7 @@
 // - BSD 3-Clause License (https://opensource.org/licenses/BSD-3-Clause)
 // at your option.
 
-use json2rdf::json_to_rdf;
+use json2rdf::{json_to_rdf, Json2RdfError};
 use oxrdfio::{RdfFormat, RdfParser};
 use std::fs::{self, File};
 
@@ -19,7 +19,6 @@ fn test_graph_triple_count() {
 #[test]
 fn test_graph_write() {
     let output = "out.nt".to_string();
-    let _ = fs::remove_file(output.clone());
 
     let res = json_to_rdf(
         &"tests/airplane.json".to_string(),
@@ -39,3 +38,101 @@ fn test_graph_write() {
     assert_eq!(quads.len(), 23);
     let _ = fs::remove_file(output.clone());
 }
+
+#[test]
+fn test_graph_write_truncates_existing() {
+    let output = "out_truncate.nt".to_string();
+
+    // Pre-populate with junk to prove truncation happens.
+    fs::write(&output, "stale garbage\n").expect("unable to seed stale output");
+
+    // Two writes in a row should not accumulate; final file should hold one run's worth.
+    for _ in 0..2 {
+        let res = json_to_rdf(
+            &"tests/airplane.json".to_string(),
+            &None,
+            &Some(output.clone()),
+        );
+        assert!(res.is_ok());
+    }
+
+    let f = File::open(&output).expect("unable to open output file for result verification");
+    let quads = RdfParser::from_format(RdfFormat::NTriples)
+        .for_reader(f)
+        .collect::<Result<Vec<_>, _>>()
+        .expect("failed to parse generated output file");
+
+    assert_eq!(quads.len(), 23);
+    let _ = fs::remove_file(&output);
+}
+
+#[test]
+fn test_root_array() {
+    let graph = json_to_rdf(&"tests/root_array.json".to_string(), &None, &None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 2);
+}
+
+#[test]
+fn test_root_primitive_errors() {
+    let result = json_to_rdf(&"tests/root_primitive.json".to_string(), &None, &None);
+    assert!(matches!(
+        result,
+        Err(Json2RdfError::UnsupportedRootValue { kind: "number" })
+    ));
+}
+
+#[test]
+fn test_ndjson_stream_isolated() {
+    let graph = json_to_rdf(&"tests/ndjson.json".to_string(), &None, &None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 2);
+}
+
+#[test]
+fn test_hash_namespace_not_mangled() {
+    let graph = json_to_rdf(
+        &"tests/airplane.json".to_string(),
+        &Some("http://example.com/ns#".to_string()),
+        &None,
+    )
+    .expect("conversion failed")
+    .expect("expected graph");
+
+    let serialized = graph.to_string();
+    assert!(
+        serialized.contains("<http://example.com/ns#aircraft>"),
+        "expected predicate to use hash namespace without injected '/', got:\n{}",
+        serialized
+    );
+    assert!(
+        !serialized.contains("<http://example.com/ns#/"),
+        "hash namespace should not have '/' appended, got:\n{}",
+        serialized
+    );
+}
+
+#[test]
+fn test_slash_namespace_no_double_slash() {
+    let graph = json_to_rdf(
+        &"tests/airplane.json".to_string(),
+        &Some("http://example.com/ns/".to_string()),
+        &None,
+    )
+    .expect("conversion failed")
+    .expect("expected graph");
+
+    let serialized = graph.to_string();
+    assert!(
+        !serialized.contains("<http://example.com/ns//"),
+        "trailing-slash namespace should not double the slash, got:\n{}",
+        serialized
+    );
+    assert!(
+        serialized.contains("<http://example.com/ns/aircraft>"),
+        "expected predicate to use slash namespace without double slash, got:\n{}",
+        serialized
+    );
+}
diff --git a/tests/ndjson.json b/tests/ndjson.json
@@ -0,0 +1,2 @@
+{"a": 1}
+{"b": 2}
diff --git a/tests/root_array.json b/tests/root_array.json
@@ -0,0 +1 @@
+[{"a": 1}, {"b": 2}]
diff --git a/tests/root_primitive.json b/tests/root_primitive.json
@@ -0,0 +1 @@
+42
