TTL syntax

Author: Porges

Cargo.lock

@@ -6,29 +6,32 @@ license.workspace = true
 authors.workspace = true
 
 [features]
-default = ["miette-highlighting", "kdl"]
-miette-highlighting = ["miette/fancy-no-backtrace"]
-legacy-encodings = ["dep:oem_cp"]
+default = ["miette-highlighting", "kdl", "turtle"]
 kdl = ["dep:kdl"]
+legacy-encodings = ["dep:oem_cp"]
+miette-highlighting = ["miette/fancy-no-backtrace"]
+turtle = ["dep:sophia_api", "dep:sophia_turtle"]
 
 [dependencies]
 ascii = "1.1.0"
 complex-indifference = { path = "../complex-indifference" }
 derive_more = { version = "2.0.1", features = ["from", "display"] }
-errful = { path = "../errful" }
+dunce = "1.0.5"
 encoding_rs = "0.8.34"
+errful = { path = "../errful" }
+itertools = "0.14.0"
 kdl = { version = "4.6.0", optional = true }
+memmap2 = "0.9.5"
 miette = { version = "7.4.0", features = ["fancy-no-backtrace"] }
 oem_cp = { version = "2.0.0", optional = true }
 owo-colors = { version = "4.0.0", features = ["supports-colors"] }
 paste = "1.0.15"
+sophia_api = { version = "0.9.0", optional = true }
+sophia_turtle = { version = "0.9.0", optional = true }
+thiserror = "2.0.12"
 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"
-thiserror = "2.0.12"
 
 
 [dev-dependencies]

gedcomfy/Cargo.toml

@@ -47,6 +47,7 @@ pub trait GEDCOMSource: ascii::AsAsciiStr + PartialEq<AsciiStr> {
     fn span_of(&self, source: &Self) -> SourceSpan;
     fn starts_with(&self, char: AsciiChar) -> bool;
     fn ends_with(&self, char: AsciiChar) -> bool;
+    fn except_start_and_end(&self) -> &Self;
     fn is_empty(&self) -> bool;
     fn slice_from(&self, offset: usize) -> &Self;
 }
@@ -90,6 +91,10 @@ impl GEDCOMSource for str {
     fn split_once(&self, char: AsciiChar) -> Option<(&Self, &Self)> {
         (*self).split_once(char.as_char())
     }
+
+    fn except_start_and_end(&self) -> &Self {
+        &self[1..self.len() - 1]
+    }
 }
 
 impl GEDCOMSource for [u8] {
@@ -133,6 +138,10 @@ impl GEDCOMSource for [u8] {
         let (before, after) = self.split_at(ix);
         Some((before, &after[1..]))
     }
+
+    fn except_start_and_end(&self) -> &Self {
+        &self[1..self.len() - 1]
+    }
 }
 
 /// A value that is sourced from a specific location in a GEDCOM file.
@@ -610,6 +619,15 @@ impl Reader {
         self.build_result::<modes::kdl::Mode>(input)
     }
 
+    #[cfg(feature = "turtle")]
+    /// Parses a GEDCOM file into Turtle format.
+    pub fn parse_ttl<'i, 's>(
+        &self,
+        input: &'i (impl Input<'s> + ?Sized),
+    ) -> Result<Vec<u8>, WithSourceCode<'s, ReaderError>> {
+        self.build_result::<modes::ttl::Mode>(input)
+    }
+
     #[instrument(skip_all)]
     fn build_result<'i, 's, M: ReadMode<'i>>(
         &self,

gedcomfy/src/reader.rs

@@ -1,13 +1,14 @@
-use std::{borrow::Cow, ops::Deref};
+use std::{borrow::Cow, io::Read, ops::Deref};
 
 use ascii::AsAsciiStr;
+use itertools::Itertools;
 use miette::SourceSpan;
 use owo_colors::{OwoColorize, Stream};
 use vec1::Vec1;
 
 use super::{
     encodings::{ansel, EncodingError, EncodingReason, SupportedEncoding},
-    lines::LineSyntaxError,
+    lines::{self, LineSyntaxError},
     records::RecordStructureError,
     versions::VersionError,
 };
@@ -19,17 +20,26 @@ pub enum DecodingError {
     #[diagnostic(transparent)]
     VersionError(#[from] VersionError),
 
-    #[error("Unable to determine encoding of GEDCOM file")]
-    #[diagnostic(transparent)]
-    EncodingError(#[from] EncodingError),
+    #[error("A problem was found while trying to determine the encoding of the GEDCOM file")]
+    EncodingError(
+        #[from]
+        #[diagnostic_source]
+        EncodingError,
+    ),
 
     #[error("GEDCOM file contained data which was invalid in the detected encoding")]
-    #[diagnostic(transparent)]
-    InvalidDataForEncoding(#[from] InvalidDataForEncodingError),
+    InvalidDataForEncoding(
+        #[from]
+        #[diagnostic_source]
+        InvalidDataForEncodingError,
+    ),
 
     #[error("GEDCOM file structure is invalid")]
-    #[diagnostic(transparent)]
-    FileStructureError(#[from] FileStructureError),
+    FileStructureError(
+        #[from]
+        #[diagnostic_source]
+        FileStructureError,
+    ),
 
     #[error(transparent)]
     #[diagnostic(transparent)]
@@ -131,7 +141,24 @@ pub fn detect_external_encoding(input: &[u8]) -> Result<Option<DetectedEncoding>
         // otherwise it’s probably not a GEDCOM file (at least in supported versions)
         // TODO: it could be the non-first GEDCOM file in a volume?
         //       - check for '0 ' and then produce an error about that?
-        _ => return Err(EncodingError::NotGedcomFile {}),
+        _ => {
+            let line = input
+                .split(|c| matches!(c, b'\r' | b'\n'))
+                .next()
+                .unwrap_or(input);
+
+            let span_until = if line.len() < 100 { line.len() } else { 0 };
+
+            if lines::parse_line(input, line).is_ok() {
+                return Err(EncodingError::MultiVolume {
+                    start: SourceSpan::from((0, span_until)),
+                });
+            }
+
+            return Err(EncodingError::NotGedcomFile {
+                start: SourceSpan::from((0, span_until)),
+            });
+        }
     };
 
     Ok(Some(result))