Fixed return types, and method of opening files

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<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(graph)
     } else {
-        Ok(GraphOrMessage::Graph(graph))
+        return Ok(graph);
     }
 }
 

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,10 @@ 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) => {
+            println!("Graph created with {} triples", res.len());
+            assert_eq!(res.len(), 23)
+        }
         Err(e) => eprintln!("Error writing: {}", e),
     }
 }