- New public rdf2hdt::Error enum with Io, Hdt, Parse variants. hdt::hdt::Error no longer appears in the public signature — it's wrapped in Error::Hdt.

  - build_hdt signature: fn build_hdt<P: AsRef<Path>, Q: AsRef<Path>>(inputs: &[P], dest: Q) -> Result<hdt::Hdt, Error>. Callers can pass &Vec<String>,
  &[PathBuf], &[&str], etc.

Author: GregHanson

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rdf2hdt"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Greg Hanson <g.isaac.hanson@gmail.com>"]
 edition = "2024"
 license = "BSD-3-Clause"

Cargo.toml

@@ -4,31 +4,72 @@
 use crate::rdf_reader::convert_to_nt;
 use log::{debug, error};
 use std::{
+    fmt,
     fs::OpenOptions,
     io::{self, BufWriter, Write},
     path::{Path, PathBuf},
 };
 
-pub fn build_hdt(file_paths: Vec<String>, dest_file: &str) -> Result<hdt::Hdt, hdt::hdt::Error> {
-    if file_paths.is_empty() {
+#[derive(Debug)]
+pub enum Error {
+    Io(io::Error),
+    Hdt(hdt::hdt::Error),
+    Parse(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Io(e) => write!(f, "I/O error: {e}"),
+            Error::Hdt(e) => write!(f, "HDT error: {e}"),
+            Error::Parse(e) => write!(f, "parse error: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Error::Io(e) => Some(e),
+            Error::Hdt(e) => Some(e),
+            Error::Parse(e) => Some(e.as_ref()),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Error::Io(e)
+    }
+}
+
+impl From<hdt::hdt::Error> for Error {
+    fn from(e: hdt::hdt::Error) -> Self {
+        Error::Hdt(e)
+    }
+}
+
+pub fn build_hdt<P: AsRef<Path>, Q: AsRef<Path>>(inputs: &[P], dest: Q) -> Result<hdt::Hdt, Error> {
+    if inputs.is_empty() {
         error!("no files provided");
         return Err(
-            io::Error::new(io::ErrorKind::InvalidData, "no files provided to convert").into(),
+            io::Error::new(io::ErrorKind::InvalidInput, "no files provided to convert").into(),
         );
     }
 
     let timer = std::time::Instant::now();
-    let is_nt = file_paths.len() == 1
-        && Path::new(&file_paths[0])
+    let first = inputs[0].as_ref();
+    let is_nt = inputs.len() == 1
+        && first
             .extension()
             .and_then(|e| e.to_str())
             .is_some_and(|e| e.eq_ignore_ascii_case("nt"));
 
     let (nt_path, _tmp_guard): (PathBuf, Option<tempfile::NamedTempFile>) = if is_nt {
-        (PathBuf::from(&file_paths[0]), None)
+        (first.to_path_buf(), None)
     } else {
         let tmp = tempfile::Builder::new().suffix(".nt").tempfile()?;
-        convert_to_nt(file_paths, tmp.reopen()?).map_err(|e| io::Error::other(e.to_string()))?;
+        convert_to_nt(inputs, tmp.reopen()?)?;
         (tmp.path().to_path_buf(), Some(tmp))
     };
 
@@ -40,7 +81,7 @@ pub fn build_hdt(file_paths: Vec<String>, dest_file: &str) -> Result<hdt::Hdt, h
         .write(true)
         .create(true)
         .truncate(true)
-        .open(dest_file)?;
+        .open(dest.as_ref())?;
     let mut writer = BufWriter::new(out_file);
     converted_hdt.write(&mut writer)?;
     writer.flush()?;
@@ -55,7 +96,7 @@ mod tests {
     use super::*;
     use walkdir::WalkDir;
 
-    fn run_sparql_suite(suite: &str) -> hdt::hdt::Result<()> {
+    fn run_sparql_suite(suite: &str) -> Result<(), Error> {
         let suite_dir = format!("tests/resources/rdf-tests/sparql/{suite}");
         assert!(
             std::path::Path::new(&suite_dir).exists(),
@@ -86,12 +127,9 @@ mod tests {
             let stem = p.file_stem().and_then(|s| s.to_str()).unwrap_or("out");
             let out = tmp
                 .path()
-                .join(format!("{}_{}.hdt", parent_name.unwrap_or("root"), stem,));
-            let out_str = out
-                .to_str()
-                .expect("tempdir path should be valid UTF-8 on test platforms");
+                .join(format!("{}_{}.hdt", parent_name.unwrap_or("root"), stem));
 
-            if let Err(e) = build_hdt(vec![f.to_string()], out_str) {
+            if let Err(e) = build_hdt(std::slice::from_ref(f), &out) {
                 failures.push(format!("{f}: {e}"));
             }
         }
@@ -106,17 +144,17 @@ mod tests {
     }
 
     #[test]
-    fn sparql10_tests() -> hdt::hdt::Result<()> {
+    fn sparql10_tests() -> Result<(), Error> {
         run_sparql_suite("sparql10")
     }
 
     #[test]
-    fn sparql11_tests() -> hdt::hdt::Result<()> {
+    fn sparql11_tests() -> Result<(), Error> {
         run_sparql_suite("sparql11")
     }
 
     #[test]
-    fn sparql12_tests() -> hdt::hdt::Result<()> {
+    fn sparql12_tests() -> Result<(), Error> {
         run_sparql_suite("sparql12")
     }
 

src/builder.rs

@@ -3,3 +3,5 @@
 
 pub mod builder;
 pub(crate) mod rdf_reader;
+
+pub use builder::{Error, build_hdt};

src/lib.rs

@@ -76,7 +76,7 @@ fn main() -> ExitCode {
         .init();
 
     match &cli.command {
-        Some(Commands::Convert { input, output }) => match build_hdt(input.clone(), output) {
+        Some(Commands::Convert { input, output }) => match build_hdt(input, output) {
             Ok(_) => ExitCode::SUCCESS,
             Err(e) => {
                 eprintln!("Error: {e}");

src/main.rs

@@ -1,6 +1,7 @@
 // Copyright (c) 2025, Decisym, LLC
 // Licensed under the BSD 3-Clause License (see LICENSE file in the project root).
 
+use crate::builder::Error;
 use log::{debug, error, warn};
 use oxrdfio::RdfSerializer;
 use oxrdfio::{
@@ -9,78 +10,73 @@ use oxrdfio::{
 };
 use std::io::Write;
 use std::{
-    error::Error,
-    io::{BufReader, BufWriter},
+    io::{self, BufReader, BufWriter},
     path::Path,
 };
 use url::Url;
 
-pub(crate) fn convert_to_nt(
-    file_paths: Vec<String>,
+pub(crate) fn convert_to_nt<P: AsRef<Path>>(
+    file_paths: &[P],
     output_file: std::fs::File,
-) -> Result<(), Box<dyn Error>> {
+) -> Result<(), Error> {
     let mut dest_writer = BufWriter::new(output_file);
     for file in file_paths {
-        let source = match std::fs::File::open(&file) {
-            Ok(f) => f,
-            Err(e) => {
-                error!("Error opening file {file:?}: {e:?}");
-                return Err(e.into());
-            }
-        };
+        let file = file.as_ref();
+        let source = std::fs::File::open(file).map_err(|e| {
+            error!("Error opening file {}: {e:?}", file.display());
+            e
+        })?;
         let source_reader = BufReader::new(source);
 
-        debug!("converting {} to nt format", &file);
+        debug!("converting {} to nt format", file.display());
 
         let mut serializer = RdfSerializer::from_format(NTriples).for_writer(dest_writer.by_ref());
         let v = std::time::Instant::now();
-        let ext = Path::new(&file)
-            .extension()
-            .and_then(|e| e.to_str())
-            .ok_or_else(|| {
-                std::io::Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    format!("file {file} has no usable extension"),
-                )
-            })?;
+        let ext = file.extension().and_then(|e| e.to_str()).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!("file {} has no usable extension", file.display()),
+            )
+        })?;
         let rdf_format = RdfFormat::from_extension(ext).ok_or_else(|| {
-            error!("unrecognized file extension for {file}");
-            std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                format!("unrecognized file extension for {file}"),
+            error!("unrecognized file extension for {}", file.display());
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("unrecognized file extension for {}", file.display()),
             )
         })?;
-        let abs_path = std::fs::canonicalize(&file)?;
+        let abs_path = std::fs::canonicalize(file)?;
         let base_iri = Url::from_file_path(&abs_path).map_err(|_| {
-            std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                format!("cannot build file:// URI for {file}"),
+            io::Error::new(
+                io::ErrorKind::InvalidInput,
+                format!("cannot build file:// URI for {}", file.display()),
             )
         })?;
         let quads = RdfParser::from_format(rdf_format)
-            .with_base_iri(base_iri.as_str())?
+            .with_base_iri(base_iri.as_str())
+            .map_err(|e| Error::Parse(Box::new(e)))?
             .for_reader(source_reader);
         let mut warned = false;
         for q in quads {
             let q = match q {
                 Ok(v) => v,
-                Err(e) => {
-                    match e {
-                        RdfParseError::Io(v) => {
-                            // I/O error while reading file
-                            error!("Error reading file {file}: {v}");
-                            return Err(v.into());
-                        }
-                        RdfParseError::Syntax(syn_err) => {
-                            error!("syntax error for RDF file {file}: {syn_err}");
-                            return Err(syn_err.into());
-                        }
+                Err(e) => match e {
+                    RdfParseError::Io(v) => {
+                        error!("Error reading file {}: {v}", file.display());
+                        return Err(v.into());
+                    }
+                    RdfParseError::Syntax(syn_err) => {
+                        error!("syntax error for RDF file {}: {syn_err}", file.display());
+                        return Err(Error::Parse(Box::new(syn_err)));
                     }
-                }
+                },
             };
             if !warned && q.graph_name != oxrdf::GraphName::DefaultGraph {
                 warned = true;
-                warn!("HDT does not support named graphs, merging triples for {file}");
+                warn!(
+                    "HDT does not support named graphs, merging triples for {}",
+                    file.display()
+                );
             }
             serializer.serialize_triple(oxrdf::TripleRef {
                 subject: q.subject.as_ref(),
@@ -106,7 +102,7 @@ mod tests {
         let tmp_file = tempfile::Builder::new().suffix(".nt").tempfile().expect("");
         assert!(
             (convert_to_nt(
-                vec!["tests/resources/apple.ttl".to_string()],
+                &["tests/resources/apple.ttl"],
                 tmp_file.reopen().expect("error opening tmp file")
             ))
             .is_ok()