Trying to figure out a nicer API

Author: Porges

Cargo.lock

@@ -15,15 +15,18 @@ use sea_orm::{
 #[derive(derive_more::Display, errful::Error, derive_more::From, Debug)]
 enum Error {
     #[display("I/O error")]
-    Io { source: std::io::Error },
+    Io {
+        source: std::io::Error,
+    },
 
     #[display("Database error")]
-    Database { source: sea_orm::DbErr },
-
-    #[display("Parse error")]
-    Parse {
-        source: gedcomfy::parser::ParseError,
+    Database {
+        source: sea_orm::DbErr,
     },
+
+    Parse(gedcomfy::parser::ParserError<'static>),
+
+    FileLoad(gedcomfy::parser::FileLoadError),
 }
 
 #[tokio::main(flavor = "current_thread")]
@@ -34,8 +37,8 @@ async fn main() -> ExitResult<Error> {
     let opts = ParseOptions::default().force_encoding(SupportedEncoding::Windows1252);
     let file_size = { std::fs::File::open(&path)?.metadata()?.len() };
     let start_time = Instant::now();
-    let mut parser = Parser::read_file(path, opts)?;
-    let records = parser.parse_raw()?;
+    let mut parser = Parser::with_options(opts).load_file(&path)?;
+    let records = parser.raw_records().map_err(|e| e.to_static())?;
     let elapsed = start_time.elapsed().as_secs_f64();
     println!(
         "parsed {filename} in {}s: ({} bytes, {} records, {} records/s)",

gedcomesque/examples/gogogo.rs

@@ -26,6 +26,8 @@ tracing = { version = "0.1", features = ["attributes"] }
 vec1 = "1.12.1"
 yoke = { version = "0.7.4", features = ["derive"] }
 itertools = "0.14.0"
+memmap2 = "0.9.5"
+dunce = "1.0.5"
 
 
 [dev-dependencies]

gedcomfy/Cargo.toml

@@ -1,7 +1,6 @@
 //! This is a library for parsing and validating GEDCOM files.
 
 use core::str;
-use std::path::Path;
 
 use miette::{Context, IntoDiagnostic, SourceSpan};
 use parser::{
@@ -16,6 +15,8 @@ pub mod parser;
 pub mod schemas;
 pub mod versions;
 
+pub use parser::Parser;
+
 #[derive(
     derive_more::Error, derive_more::Display, derive_more::From, Debug, miette::Diagnostic,
 )]
@@ -42,28 +43,6 @@ impl<S: GEDCOMSource + ?Sized> RawRecord<'_, S> {
     }
 }
 
-pub fn validate_file(
-    path: &Path,
-    parse_options: ParseOptions,
-) -> Result<parser::ValidationResult, miette::Report> {
-    let mut parser = parser::Parser::read_file(path, parse_options)
-        .into_diagnostic()
-        .with_context(|| format!("Parsing file {}", path.display()))?;
-
-    Ok(parser.validate()?)
-}
-
-pub fn parse_file(
-    path: &Path,
-    parse_options: ParseOptions,
-) -> Result<parser::ParseResult, miette::Report> {
-    let mut parser = parser::Parser::read_file(path, parse_options)
-        .into_diagnostic()
-        .with_context(|| format!("Parsing file {}", path.display()))?;
-
-    Ok(parser.parse()?)
-}
-
 #[derive(derive_more::Error, derive_more::Display, Debug, miette::Diagnostic)]
 pub enum FileStructureError {
     #[display("Missing HEAD record")]

gedcomfy/src/lib.rs

@@ -82,21 +82,21 @@ pub enum EncodingReason {
     BOMDetected { bom_length: usize },
 
     #[display(
-        "this encoding was detected from start of file content (no byte-order mark was present)"
+        "this encoding was detected from the start of the file content (no byte-order mark was present)"
     )]
     #[diagnostic(severity(Advice), code(gedcom::encoding_reason::sniffed))]
     Sniffed {},
 
-    #[display("this encoding was specified in the GEDCOM header")]
+    #[display("this encoding was used because it was specified in the GEDCOM header")]
     #[diagnostic(severity(Advice), code(gedcom::encoding_reason::header))]
     SpecifiedInHeader {
         #[label("encoding was specified here")]
         span: SourceSpan,
     },
 
     #[display(
-        "this encoding was used because it is required by GEDCOM version {version}{}",
-        if span.is_none() { " (this version was forced by parsing options)" } else { "" }
+        "this encoding was used because it is required by the GEDCOM version used: {version}{}",
+        if span.is_none() { " (this version was selected explicitly in the options)" } else { "" }
     )]
     #[diagnostic(severity(Advice))]
     DeterminedByVersion {
@@ -131,7 +131,7 @@ pub enum EncodingError {
 
     #[display(
         "GEDCOM version {version}{} requires the encoding to be {version_encoding}, but the file encoding was determined to be {external_encoding}",
-        if version_span.is_none() { " (this version was forced by parsing options)" } else { "" }
+        if version_span.is_none() { " (this version was selected explicitly in the options)" } else { "" }
     )]
     #[diagnostic(code(gedcom::encoding::version_encoding_mismatch))]
     VersionEncodingMismatch {
@@ -252,7 +252,7 @@ impl DetectedEncoding {
         match self.encoding {
             SupportedEncoding::Ascii => {
                 let ascii_err = match data.as_ascii_str() {
-                    Ok(str) => return Ok(str.as_str().into()),
+                    Ok(ascii_str) => return Ok(ascii_str.as_str().into()),
                     Err(err) => err,
                 };
 
@@ -279,7 +279,10 @@ impl DetectedEncoding {
                         .copied(),
                 );
 
-                tracing::debug!("data to decode is {}", String::from_utf8_lossy(&to_show));
+                tracing::debug!(
+                    data_as_utf8 = String::from_utf8_lossy(&to_show).as_ref(),
+                    "data failed to decode"
+                );
 
                 let mut possible_encodings = Vec::new();
                 for encoding in [SupportedEncoding::Windows1252, SupportedEncoding::Utf8] {
@@ -295,7 +298,7 @@ impl DetectedEncoding {
                         Ok(decoded) => {
                             // if we decoded to something containing control characters,
                             // it’s not valid
-                            if decoded.as_ref().chars().all(|c| !c.is_control()) {
+                            if decoded.chars().all(|c| !c.is_control()) {
                                 possible_encodings.push(PossibleEncoding {
                                     encoding,
                                     data_in_encoding: decoded.into_owned(),