aethellib 0.9.6

Composable text generation primitives over target-specific TOML corpora with provenance tracking.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! unified loader error types used across all load entrypoints.

use std::path::Path;

use thiserror::Error;

use crate::corpus::types::Target;

#[derive(Debug, Error)]
/// errors returned by all load entrypoints.
pub enum CorpusLoaderError {
    /// file system read failure with explicit source path context.
    #[error("unable to read toml file '{path}': {source}")]
    Read {
        /// source file path when available.
        path: String,
        /// underlying io source error.
        source: std::io::Error,
    },
    /// toml deserialization or structural parse failure with explicit source path context.
    #[error("unable to parse toml file '{path}': {source}")]
    Parse {
        /// source file path when available.
        path: String,
        /// underlying parse source error.
        source: toml::de::Error,
    },
    /// file target does not match the expected target.
    #[error("target mismatch: expected '{expected}', got '{found}'")]
    TargetMismatch { expected: Target, found: Target },
    /// a load option constraint was violated.
    #[error("{0}")]
    OptionViolation(String),
    /// invalid arguments supplied to a load entrypoint.
    #[error("{0}")]
    InvalidInput(String),
}

impl CorpusLoaderError {
    pub(crate) fn read_for_path(path: impl AsRef<Path>, source: std::io::Error) -> Self {
        CorpusLoaderError::Read {
            path: path.as_ref().to_string_lossy().to_string(),
            source,
        }
    }

    pub(crate) fn parse_for_path(path: impl AsRef<Path>, source: toml::de::Error) -> Self {
        CorpusLoaderError::Parse {
            path: path.as_ref().to_string_lossy().to_string(),
            source,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_display_formats_target_mismatch() {
        let error = CorpusLoaderError::TargetMismatch {
            expected: "weapon".to_string(),
            found: "person".to_string(),
        };

        assert_eq!(
            error.to_string(),
            "target mismatch: expected 'weapon', got 'person'"
        );
        assert!(matches!(error, CorpusLoaderError::TargetMismatch { .. }));
    }

    #[test]
    fn test_read_for_path_includes_path_in_message() {
        let error = CorpusLoaderError::read_for_path(
            "custom-file.toml",
            std::io::Error::new(std::io::ErrorKind::NotFound, "missing"),
        );

        assert!(error.to_string().contains("custom-file.toml"));
        assert!(matches!(error, CorpusLoaderError::Read { .. }));
    }

    #[test]
    fn test_option_violation_variant() {
        let error = CorpusLoaderError::OptionViolation("some constraint".to_string());
        assert_eq!(error.to_string(), "some constraint");
        assert!(matches!(error, CorpusLoaderError::OptionViolation(_)));
    }

    #[test]
    fn test_invalid_input_variant() {
        let error = CorpusLoaderError::InvalidInput("bad input".to_string());
        assert_eq!(error.to_string(), "bad input");
        assert!(matches!(error, CorpusLoaderError::InvalidInput(_)));
    }
}