change in stack implementation, multi-file support clarity/bug, more integ tests

Author: GregHanson

Makefile

@@ -5,7 +5,7 @@
 # at your option.
 
 lint:
-	cargo install  cargo-machete
+	@command -v cargo-machete >/dev/null 2>&1 || cargo install cargo-machete
 	cargo fmt --check
 	cargo machete
 	cargo clippy --benches --tests --bins --no-deps --all-features

README.md

@@ -42,10 +42,13 @@ The conversion functionality can also be called directly in Rust. The library su
 use json2rdf::json_to_rdf;
 
 // capture conversion results to file
-let results = json_to_rdf(&"tests/airplane.json".to_string(), &Some("http://example.com/ns#".to_string()), &Some("output.nt".to_string()));
+let results = json_to_rdf(&["tests/airplane.json"], Some("http://example.com/ns#"), Some("output.nt"));
 
 // capture conversion results to an oxrdf::Graph
-let results = json_to_rdf(&"tests/airplane.json".to_string(), &Some("http://example.com/ns#".to_string()), &None);
+let results = json_to_rdf(&["tests/airplane.json"], Some("http://example.com/ns#"), None);
+
+// multiple input files are merged into a single graph
+let results = json_to_rdf(&["a.json", "b.json"], Some("http://example.com/ns#"), None);
 ```
 
 ## License

src/lib.rs

@@ -22,7 +22,6 @@ use oxrdf::vocab::xsd;
 use oxrdf::{BlankNode, Graph, IriParseError, Literal, NamedNodeRef, TripleRef};
 
 use serde_json::{Deserializer, Value};
-use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{BufReader, Write};
 use thiserror::Error;
@@ -58,49 +57,50 @@ pub enum Json2RdfError {
 /// an output file for saving the generated RDF data.
 ///
 /// # Arguments
-/// - `file_path`: Path to the JSON file.
+/// - `file_paths`: One or more paths to input JSON files. All files are merged into a single graph.
 /// - `namespace`: Optional custom namespace for RDF predicates.
 /// - `output_file`: Optional output file path for writing RDF data.
 ///
 /// # Errors
-/// Returns [`Json2RdfError`] if the input file cannot be read, the JSON cannot be parsed,
+/// Returns [`Json2RdfError`] if any input file cannot be read, the JSON cannot be parsed,
 /// the output file cannot be written, or a JSON key produces an invalid IRI.
 ///
 /// # Example
 /// ```rust
 /// use json2rdf::json_to_rdf;
 ///
-/// json_to_rdf(
-///     &"tests/airplane.json".to_string(),
-///     &Some("http://example.com/ns#".to_string()),
-///     &Some("output.nt".to_string()),
-/// ).expect("conversion failed");
+/// let graph = json_to_rdf(
+///     &["tests/airplane.json"],
+///     Some("http://example.com/ns#"),
+///     None,
+/// )
+/// .expect("conversion failed")
+/// .expect("expected a graph");
+/// assert!(!graph.is_empty());
 /// ```
 pub fn json_to_rdf(
-    file_path: &String,
-    namespace: &Option<String>,
-    output_file: &Option<String>,
+    file_paths: &[&str],
+    namespace: Option<&str>,
+    output_file: Option<&str>,
 ) -> Result<Option<Graph>, Json2RdfError> {
-    let mut prefix: String = if namespace.is_some() {
-        namespace.clone().unwrap()
-    } else {
-        "https://decisym.ai/json2rdf/model".to_owned()
-    };
+    let mut prefix: String = namespace
+        .map(str::to_owned)
+        .unwrap_or_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);
-    let stream = Deserializer::from_reader(reader).into_iter::<Value>();
-
     let mut graph = Graph::default(); // oxrdf Graph object
-
-    let mut subject_stack: VecDeque<BlankNode> = VecDeque::new();
-
-    for value in stream {
-        process_top_level(&mut subject_stack, value?, &mut graph, &prefix)?;
+    let mut subject_stack: Vec<BlankNode> = Vec::new();
+
+    for path in file_paths {
+        let file = File::open(path)?;
+        let reader = BufReader::new(file);
+        let stream = Deserializer::from_reader(reader).into_iter::<Value>();
+        for value in stream {
+            process_top_level(&mut subject_stack, value?, &mut graph, &prefix)?;
+        }
     }
 
     if let Some(output_path) = output_file {
@@ -118,22 +118,22 @@ pub fn json_to_rdf(
 /// 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>,
+    subject_stack: &mut Vec<BlankNode>,
     value: Value,
     graph: &mut Graph,
-    prefix: &String,
+    prefix: &str,
 ) -> Result<(), Json2RdfError> {
     match value {
         Value::Object(obj) => {
             let subject = BlankNode::default();
-            subject_stack.push_back(subject);
+            subject_stack.push(subject);
 
             for (key, val) in obj {
                 let property = Some(format!("{}{}", prefix, key));
                 process_value(subject_stack, &property, val, graph, prefix)?;
             }
 
-            subject_stack.pop_back();
+            subject_stack.pop();
             Ok(())
         }
         Value::Array(arr) => {
@@ -176,13 +176,13 @@ fn process_top_level(
 /// - **Boolean**: Converts to `xsd:boolean` literal.
 /// - **Number**: Converts to `xsd:integer` for whole numbers, `xsd:double` for floating-point values.
 fn process_value(
-    subject_stack: &mut VecDeque<BlankNode>,
+    subject_stack: &mut Vec<BlankNode>,
     property: &Option<String>,
     value: Value,
     graph: &mut Graph,
-    prefix: &String,
+    prefix: &str,
 ) -> Result<(), Json2RdfError> {
-    let Some(last_subject) = subject_stack.back().cloned() else {
+    let Some(last_subject) = subject_stack.last().cloned() else {
         return Ok(());
     };
     let Some(prop) = property else {
@@ -226,13 +226,13 @@ fn process_value(
         Value::Object(obj) => {
             let new_subject = BlankNode::default();
             graph.insert(TripleRef::new(&last_subject, predicate, &new_subject));
-            subject_stack.push_back(new_subject);
+            subject_stack.push(new_subject);
 
             for (key, val) in obj {
                 let nested_property: Option<String> = Some(format!("{}{}", prefix, key));
                 process_value(subject_stack, &nested_property, val, graph, prefix)?;
             }
-            subject_stack.pop_back();
+            subject_stack.pop();
         }
         Value::Array(arr) => {
             for val in arr {

src/main.rs

@@ -59,8 +59,9 @@ enum Commands {
         /// Path to input JSON file(s).
         ///
         /// Provide the path to one or more JSON files that will be parsed and converted.
-        #[arg(short, long)]
-        json_files: String,
+        /// All files are merged into a single RDF graph.
+        #[arg(short, long, required = true, num_args = 1..)]
+        json_files: Vec<String>,
 
         /// Path to output file.
         ///
@@ -80,7 +81,8 @@ fn main() {
             json_files,
             output_file,
         }) => {
-            if let Err(e) = json_to_rdf(json_files, namespace, output_file) {
+            let paths: Vec<&str> = json_files.iter().map(String::as_str).collect();
+            if let Err(e) = json_to_rdf(&paths, namespace.as_deref(), output_file.as_deref()) {
                 eprintln!("json2rdf: {}", e);
                 std::process::exit(1);
             }

tests/empty_file.json

@@ -0,0 +1 @@
+{}

tests/empty_object.json

@@ -10,73 +10,65 @@ use std::fs::{self, File};
 
 #[test]
 fn test_graph_triple_count() {
-    let triple_count_string = json_to_rdf(&"tests/airplane.json".to_string(), &None, &None);
+    let triple_count_string = json_to_rdf(&["tests/airplane.json"], None, None);
 
     assert!(triple_count_string.is_ok());
     assert_eq!(triple_count_string.unwrap().unwrap().len(), 23);
 }
 
 #[test]
 fn test_graph_write() {
-    let output = "out.nt".to_string();
+    let output = "out.nt";
 
-    let res = json_to_rdf(
-        &"tests/airplane.json".to_string(),
-        &None,
-        &Some(output.clone()),
-    );
+    let res = json_to_rdf(&["tests/airplane.json"], None, Some(output));
 
     assert!(res.is_ok());
     assert!(res.unwrap().is_none());
 
-    let f = File::open(output.clone()).expect("unable to open output file for result verification");
+    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.clone());
+    let _ = fs::remove_file(output);
 }
 
 #[test]
 fn test_graph_write_truncates_existing() {
-    let output = "out_truncate.nt".to_string();
+    let output = "out_truncate.nt";
 
     // Pre-populate with junk to prove truncation happens.
-    fs::write(&output, "stale garbage\n").expect("unable to seed stale output");
+    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()),
-        );
+        let res = json_to_rdf(&["tests/airplane.json"], None, Some(output));
         assert!(res.is_ok());
     }
 
-    let f = File::open(&output).expect("unable to open output file for result verification");
+    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);
+    let _ = fs::remove_file(output);
 }
 
 #[test]
 fn test_root_array() {
-    let graph = json_to_rdf(&"tests/root_array.json".to_string(), &None, &None)
+    let graph = json_to_rdf(&["tests/root_array.json"], 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);
+    let result = json_to_rdf(&["tests/root_primitive.json"], None, None);
     assert!(matches!(
         result,
         Err(Json2RdfError::UnsupportedRootValue { kind: "number" })
@@ -85,18 +77,103 @@ fn test_root_primitive_errors() {
 
 #[test]
 fn test_ndjson_stream_isolated() {
-    let graph = json_to_rdf(&"tests/ndjson.json".to_string(), &None, &None)
+    let graph = json_to_rdf(&["tests/ndjson.json"], None, None)
         .expect("conversion failed")
         .expect("expected graph");
     assert_eq!(graph.len(), 2);
 }
 
+#[test]
+fn test_multi_file_merges_graphs() {
+    // root_array.json → 2 triples; ndjson.json → 2 triples; merged = 4.
+    let graph = json_to_rdf(&["tests/root_array.json", "tests/ndjson.json"], None, None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 4);
+}
+
+#[test]
+fn test_large_integers_preserve_precision() {
+    let graph = json_to_rdf(&["tests/large_int.json"], None, None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    let serialized = graph.to_string();
+    assert!(
+        serialized.contains("\"9223372036854775807\"^^<http://www.w3.org/2001/XMLSchema#integer>"),
+        "i64::MAX should round-trip as xsd:integer, got:\n{}",
+        serialized
+    );
+    assert!(
+        serialized.contains("\"18446744073709551615\"^^<http://www.w3.org/2001/XMLSchema#integer>"),
+        "u64::MAX should round-trip as xsd:integer (not xsd:double), got:\n{}",
+        serialized
+    );
+}
+
+#[test]
+fn test_empty_file_returns_empty_graph() {
+    let graph = json_to_rdf(&["tests/empty_file.json"], None, None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 0);
+}
+
+#[test]
+fn test_empty_object_at_root_produces_no_triples() {
+    let graph = json_to_rdf(&["tests/empty_object.json"], None, None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 0);
+}
+
+#[test]
+fn test_malformed_json_returns_error() {
+    let result = json_to_rdf(&["tests/malformed.json"], None, None);
+    assert!(
+        matches!(result, Err(Json2RdfError::Json(_))),
+        "expected Json2RdfError::Json, got {:?}",
+        result.err()
+    );
+}
+
+#[test]
+fn test_missing_file_returns_error() {
+    let result = json_to_rdf(&["tests/does_not_exist.json"], None, None);
+    assert!(
+        matches!(result, Err(Json2RdfError::Io(_))),
+        "expected Json2RdfError::Io, got {:?}",
+        result.err()
+    );
+}
+
+#[test]
+fn test_invalid_iri_key_returns_error() {
+    let result = json_to_rdf(&["tests/invalid_iri_key.json"], None, None);
+    assert!(
+        matches!(result, Err(Json2RdfError::InvalidIri { .. })),
+        "expected Json2RdfError::InvalidIri, got {:?}",
+        result.err()
+    );
+}
+
+#[test]
+fn test_unicode_key_in_iri_range() {
+    let graph = json_to_rdf(&["tests/unicode_key.json"], None, None)
+        .expect("conversion failed")
+        .expect("expected graph");
+    assert_eq!(graph.len(), 1);
+    assert!(
+        graph.to_string().contains("中文"),
+        "expected unicode predicate in output"
+    );
+}
+
 #[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,
+        &["tests/airplane.json"],
+        Some("http://example.com/ns#"),
+        None,
     )
     .expect("conversion failed")
     .expect("expected graph");
@@ -117,9 +194,9 @@ fn test_hash_namespace_not_mangled() {
 #[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,
+        &["tests/airplane.json"],
+        Some("http://example.com/ns/"),
+        None,
     )
     .expect("conversion failed")
     .expect("expected graph");