Merge pull request #2 from DeciSym/bharathselvaraj/json2rdf-fixes

bharathselvaraj/json2rdf fixes

Author: bharath181

src/lib.rs

@@ -12,19 +12,15 @@
 //! - Allows specifying a custom RDF namespace for generated predicates and objects.
 //! - Outputs the RDF data to a specified file or prints it to the console.
 
+use clap::Error;
 use oxrdf::vocab::xsd;
 use oxrdf::{BlankNode, Graph, Literal, NamedNodeRef, TripleRef};
 
 use serde_json::{Deserializer, Value};
 use std::collections::VecDeque;
-use std::fs::File;
+use std::fs::{File, OpenOptions};
 use std::io::{BufReader, Write};
 
-pub enum GraphOrMessage {
-    Graph(Graph),
-    Message(String),
-}
-
 /// Converts JSON data to RDF format.
 ///
 /// This function reads JSON data from the specified file, processes it into RDF triples,
@@ -47,7 +43,7 @@ pub fn json_to_rdf(
     file_path: &String,
     namespace: &Option<String>,
     output_file: &Option<String>,
-) -> Result<GraphOrMessage, String> {
+) -> Result<Option<Graph>, Error> {
     let rdf_namespace: String = if namespace.is_some() {
         namespace.clone().unwrap()
     } else {
@@ -109,14 +105,16 @@ pub fn json_to_rdf(
     }
 
     if let Some(output_path) = output_file {
-        let mut file = File::create(output_path).expect("Error creating file");
-        writeln!(file, "{}", graph).expect("Error writing to file");
-        Ok(GraphOrMessage::Message(format!(
-            "RDF created at: {}",
-            output_path
-        )))
+        let mut file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(output_path)
+            .expect("Error opening file");
+
+        writeln!(file, "{}", graph).expect("Error writing json2rdf data to file");
+        Ok(None)
     } else {
-        Ok(GraphOrMessage::Graph(graph))
+        return Ok(Some(graph));
     }
 }
 
@@ -164,18 +162,21 @@ fn process_value(
                     ));
                 }
                 Value::Number(num) => {
-                    let literal = if let Some(int) = num.as_i64() {
-                        int.to_string()
-                    } else if let Some(float) = num.as_f64() {
-                        float.to_string()
+                    if num.as_i64().is_some() {
+                        graph.insert(TripleRef::new(
+                            subject_stack.back().unwrap(),
+                            NamedNodeRef::new(prop.as_str()).unwrap(),
+                            &Literal::new_typed_literal(num.to_string(), xsd::INT),
+                        ));
+                    } else if num.as_f64().is_some() {
+                        graph.insert(TripleRef::new(
+                            subject_stack.back().unwrap(),
+                            NamedNodeRef::new(prop.as_str()).unwrap(),
+                            &Literal::new_typed_literal(num.to_string(), xsd::FLOAT),
+                        ));
                     } else {
                         return;
-                    };
-                    graph.insert(TripleRef::new(
-                        subject_stack.back().unwrap(),
-                        NamedNodeRef::new(prop.as_str()).unwrap(),
-                        &Literal::new_typed_literal(literal, xsd::INT),
-                    ));
+                    }
                 }
                 Value::String(s) => {
                     graph.insert(TripleRef::new(
@@ -199,7 +200,7 @@ fn process_value(
 
                     for (key, val) in obj {
                         let nested_property: Option<String> =
-                            Some(format!("{}/{}/", namespace, key));
+                            Some(format!("{}/{}", namespace, key));
                         process_value(subject_stack, &nested_property, val, graph, namespace);
                     }
                     subject_stack.pop_back();

src/main.rs

@@ -21,7 +21,7 @@
 //! ```
 //! This will take `data.json`, apply the specified namespace, and save the RDF output in `output.nt`.
 use clap::{Parser, Subcommand};
-mod lib;
+use json2rdf::*;
 
 /// Command-line interface for JSON2RDF Converter
 ///
@@ -73,21 +73,10 @@ fn main() {
             namespace,
             json_files,
             output_file,
-        }) => {
-            match lib::json_to_rdf(json_files, namespace, output_file) {
-                Ok(res) => match res {
-                    lib::GraphOrMessage::Graph(graph) => {
-                        // Handle the case where the function returns a Graph
-                        println!("Graph created with {} triples", graph.len());
-                    }
-                    lib::GraphOrMessage::Message(message) => {
-                        // Handle the case where the function returns a success message
-                        println!("{}", message);
-                    }
-                },
-                Err(e) => eprintln!("Error writing: {}", e),
-            }
-        }
+        }) => match json_to_rdf(json_files, namespace, output_file) {
+            Ok(_) => {}
+            Err(e) => eprintln!("Error writing: {}", e),
+        },
         None => {}
     }
 }

tests/integration_test.rs

@@ -5,16 +5,9 @@ fn test_graph_triple_count() {
     let triple_count_string = json_to_rdf(&"tests/airplane.json".to_string(), &None, &None);
 
     match triple_count_string {
-        Ok(res) => match res {
-            json2rdf::GraphOrMessage::Graph(graph) => {
-                // Handle the case where the function returns a Graph
-                println!("Graph created with {} triples", graph.len());
-                assert_eq!(graph.len(), 23)
-            }
-            json2rdf::GraphOrMessage::Message(message) => {
-                println!("{}", message);
-            }
-        },
+        Ok(res) => {
+            assert_eq!(res.unwrap().len(), 23)
+        }
         Err(e) => eprintln!("Error writing: {}", e),
     }
 }