first pass

Author: GregHanson

Cargo.lock

@@ -0,0 +1,12 @@
+[package]
+name = "csv2rdf"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clap = { version = "4.5.21", features = ["derive","cargo"] }
+convert_case = "0.6.0"
+csv = "1.3.1"
+log = "0.4.22"
+oxrdf = "0.2.3"
+oxrdfio = "0.1.3"

Cargo.toml

@@ -1,2 +1,4 @@
 # csv2rdf
-Library for converting CSV files into NTriple RDF
+Library for converting CSV files into RDF
+
+This Rust-based tool converts CSV data into RDF format, utilizing the `oxrdf` crate for RDF graph handling and `csv` for efficient CSV parsing. Generated triples can either be added to an `oxrdf::Graph` or written directly to file.

README.md

@@ -0,0 +1,65 @@
+use std::collections::HashMap;
+
+use crate::writer::RdfWriter;
+use convert_case::{Case, Casing};
+use csv::ReaderBuilder;
+use log::error;
+use oxrdf::{NamedNode, TermRef, TripleRef};
+
+const C2R: &'static str = "https://decisym.ai/csv2rdf/model#";
+
+pub fn parse_csv(
+    files: Vec<String>,
+    output: &mut dyn RdfWriter,
+    namespace: &str,
+) -> std::io::Result<()> {
+    // ensure namespace is ready for appending
+    let ns = if namespace.ends_with("/") {
+        namespace
+    } else {
+        &([namespace, "/"].join(""))
+    };
+
+    for file in files.into_iter() {
+        let mut rdr = ReaderBuilder::new()
+            .has_headers(true)
+            .from_path(file.to_string())?;
+
+        let mut headers: HashMap<i32, String> = HashMap::new();
+        let mut column_index = 0;
+        match rdr.headers() {
+            Ok(h) => {
+                for val in h.iter() {
+                    headers.insert(column_index, val.to_case(Case::Camel));
+                    column_index += 1;
+                }
+            }
+            Err(e) => {
+                error!("expected first row of CSV data to contain headers");
+                return Err(e.into());
+            }
+        }
+
+        for result in rdr.records() {
+            let record = result.unwrap();
+            let mut row_id = "".to_string();
+            column_index = 0;
+            for field in record.iter() {
+                if column_index == 0 {
+                    row_id = field.trim().replace(" ", "");
+                }
+                // do not append empty cells
+                else if field != "" {
+                    let column_id = headers.get(&column_index).unwrap();
+                    let subject = NamedNode::new(format!("{}{}", ns, row_id)).unwrap();
+                    let predicate = NamedNode::new(format!("{}{}", C2R, column_id)).unwrap();
+                    let object = TermRef::Literal(field.into());
+                    let csv_triple = TripleRef::new(subject.as_ref(), predicate.as_ref(), object);
+                    output.add_triple(csv_triple)?
+                }
+                column_index += 1;
+            }
+        }
+    }
+    Ok(())
+}

src/convert.rs

@@ -0,0 +1,2 @@
+pub mod convert;
+pub mod writer;

src/lib.rs

@@ -0,0 +1,97 @@
+//! # XML2RDF Converter
+//!
+//! This is a Rust-based tool that converts XML data into RDF format. It uses the `xml-rs` crate
+//! for XML parsing and the `oxrdf` crate to construct RDF triples and graphs.
+//!
+//! ## Features
+//! - Parses XML input and converts it to RDF triples
+//! - Supports specifying a custom namespace for generated RDF nodes
+//! - Outputs RDF data to a specified file, oxrdf::Graph or stdout
+//!
+//! ## Usage
+//! Run the XML2RDF converter from the command line. For detailed usage information, run:
+//! ```
+//! xml2rdf --help
+//! ```
+//!
+//! ## Example
+//! To convert a XML file to RDF format with a specified namespace and output file:
+//! ```
+//! xml2rdf convert --namespace http://example.com/ns# --xml data.xml --output-file output.nt
+//! ```
+//! This will take `data.xml`, apply the specified namespace, and save the RDF output in `output.nt`.
+
+use clap::{Parser, Subcommand};
+use csv2rdf::*;
+
+/// Command-line interface for XML2RDF Converter
+///
+/// This struct defines the command-line interface (CLI) for interacting with the XML2RDF converter.
+#[derive(Parser)]
+#[command(version, about = "Converts XML data into RDF format.")]
+struct Cli {
+    /// CLI command selection
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+/// Supported Commands
+///
+/// Contains the available commands for the XML2RDF converter.
+#[derive(Subcommand)]
+enum Commands {
+    /// Convert XML to RDF format.
+    ///
+    /// The `convert` command parses a XML file, converts it to RDF triples using `xml-rs` for parsing
+    /// and `oxrdf` to construct the graph, and saves the output.
+    Convert {
+        /// Namespace for RDF graph generation.
+        ///
+        /// A custom namespace to prefix RDF resources created from XML keys and values.
+        #[arg(short, long, default_value = "https://decisym.ai/csv2rdf/data")]
+        namespace: String,
+
+        /// Path to input XML file(s).
+        ///
+        /// Provide the path to one or more XML files that will be parsed and converted.
+        #[arg(short, long, num_args = 1..)]
+        input: Vec<String>,
+
+        /// Path to output file.
+        ///
+        /// Optional: Specify the path to save the generated RDF data. If not provided, data will be written
+        /// to stdout
+        #[arg(short, long)]
+        output: Option<String>,
+    },
+}
+
+fn main() {
+    let cli = Cli::parse();
+
+    match &cli.command {
+        Some(Commands::Convert {
+            namespace,
+            input,
+            output,
+        }) => {
+            let mut w: Box<dyn writer::RdfWriter> = if let Some(file) = output {
+                match writer::FileWriter::to_file(file.clone()) {
+                    Err(e) => {
+                        eprintln!("Error opening file for writing: {e}");
+                        return;
+                    }
+                    Ok(v) => Box::new(v),
+                }
+            } else {
+                Box::new(writer::FileWriter::to_stdout())
+            };
+
+            match convert::parse_csv(input.clone(), w.as_mut(), namespace) {
+                Ok(_) => {}
+                Err(e) => eprintln!("Error writing: {}", e),
+            }
+        }
+        None => {}
+    }
+}

src/main.rs

@@ -0,0 +1,66 @@
+//! # XML2RDF Writer Library
+//!
+//! This library provides functionality for writing covnerted XML2RDF data.
+//! It uses `oxrdf` to build and manage RDF graphs or output the data direct to a file.
+//!
+//! ## Overview
+//! - Adds XML RDF triples to a graph or file.
+
+use oxrdf::{Graph, TripleRef};
+use std::fs::File;
+use std::fs::OpenOptions;
+use std::io::{self, BufWriter, Write};
+
+pub trait RdfWriter {
+    fn add_triple(&mut self, triple: TripleRef) -> std::io::Result<()>;
+}
+
+pub struct FileWriter<W: Write> {
+    writer: BufWriter<W>,
+}
+
+impl FileWriter<io::Stdout> {
+    pub fn to_stdout() -> Self {
+        FileWriter {
+            writer: BufWriter::new(io::stdout()),
+        }
+    }
+}
+
+impl FileWriter<File> {
+    pub fn to_file(output_file: String) -> io::Result<Self> {
+        let file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(output_file)?;
+        Ok(FileWriter {
+            writer: BufWriter::new(file),
+        })
+    }
+}
+
+impl<W: Write> RdfWriter for FileWriter<W> {
+    fn add_triple(&mut self, triple: TripleRef) -> std::io::Result<()> {
+        self.writer.write_all(triple.to_string().as_bytes())?;
+        self.writer.write_all(b" .\n")?;
+        let _ = self.writer.flush();
+        Ok(())
+    }
+}
+
+pub struct GraphWriter<'a> {
+    graph: &'a mut Graph,
+}
+
+impl<'a> GraphWriter<'a> {
+    pub fn new(graph: &'a mut Graph) -> Self {
+        Self { graph }
+    }
+}
+
+impl<'a> RdfWriter for GraphWriter<'a> {
+    fn add_triple(&mut self, triple: TripleRef) -> std::io::Result<()> {
+        self.graph.insert(triple.clone());
+        Ok(())
+    }
+}

src/writer.rs

@@ -0,0 +1,42 @@
+use csv2rdf::*;
+use oxrdf::Graph;
+use oxrdfio::{RdfFormat, RdfParser};
+use std::fs;
+use std::fs::File;
+
+#[test]
+fn test_graph_writer() {
+    let mut g = Graph::new();
+    let mut w = writer::GraphWriter::new(&mut g);
+
+    let res = convert::parse_csv(
+        vec!["tests/resources/people.csv".to_string()],
+        &mut w,
+        "https://decisym.ai/xml2rdf/data",
+    );
+    assert!(res.is_ok());
+
+    assert_eq!(g.len(), 23)
+}
+
+#[test]
+fn test_file_writer() {
+    let output = "out.nt".to_string();
+    let _ = fs::remove_file(output.clone());
+
+    let mut w = writer::FileWriter::to_file(output.clone()).expect("Failed to open output file");
+
+    let res = convert::parse_csv(
+        vec!["tests/resources/people.csv".to_string()],
+        &mut w,
+        "https://decisym.ai/csv2rdf/data",
+    );
+    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)
+}

tests/integration.rs

@@ -0,0 +1,5 @@
+Name,Address,Place,Country,Age,Hobby,Favourite Colour 
+John,Dam 52,Amsterdam,The Netherlands,32,Fishing,Blue
+Jenny,Leidseplein 2,Amsterdam,The Netherlands,12,,Mauve
+Jill,52W Street 5,Amsterdam,United States of America,28,Carpentry,Cyan
+Jake,12E Street 98,Amsterdam,United States of America,42,Ballet,Purple