mif-rh 0.2.0

Compiled ontology resolution/review engine for research-harness-template corpora
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
98
99

//! rht's ontology catalog (`.claude/enabled-packs.json`).

use std::path::Path;

use serde::Deserialize;

use crate::error::MifRhError;

/// One cataloged ontology: its id, cataloged version, source path, and
/// whether it is a core ontology (implicitly allowed for every topic).
#[derive(Debug, Clone, Deserialize)]
pub struct CatalogEntry {
    /// The ontology's id.
    pub id: String,
    /// The cataloged version.
    pub version: String,
    /// Repo-relative path to the ontology's YAML definition.
    #[serde(default)]
    pub source: Option<String>,
    /// Whether this ontology is implicitly allowed for every topic.
    #[serde(default)]
    pub core: bool,
}

/// rht's ontology catalog: which ontologies are enabled, and which are core.
#[derive(Debug, Clone, Deserialize)]
pub struct Catalog {
    /// The cataloged ontologies.
    pub ontologies: Vec<CatalogEntry>,
}

impl Catalog {
    /// Reads and parses the catalog file at `path`.
    ///
    /// # Errors
    ///
    /// Returns [`MifRhError::CatalogMissing`] if `path` does not exist, or
    /// [`MifRhError::Json`] if it exists but is not valid JSON.
    pub fn load(path: &Path) -> Result<Self, MifRhError> {
        if !path.exists() {
            return Err(MifRhError::CatalogMissing {
                path: path.display().to_string(),
            });
        }
        let contents = std::fs::read_to_string(path).map_err(|source| MifRhError::Io {
            path: path.display().to_string(),
            source,
        })?;
        serde_json::from_str(&contents).map_err(|source| MifRhError::Json {
            path: path.display().to_string(),
            source,
        })
    }

    /// Looks up a cataloged entry by id.
    #[must_use]
    pub fn find(&self, id: &str) -> Option<&CatalogEntry> {
        self.ontologies.iter().find(|entry| entry.id == id)
    }

    /// Every core ontology's id.
    pub fn core_ids(&self) -> impl Iterator<Item = &str> {
        self.ontologies
            .iter()
            .filter(|entry| entry.core)
            .map(|entry| entry.id.as_str())
    }
}

#[cfg(test)]
mod tests {
    use std::io::Write as _;

    use super::Catalog;

    #[test]
    fn loads_and_finds_entries() {
        let mut file = tempfile::NamedTempFile::new().unwrap();
        file.write_all(
            br#"{"ontologies":[
                {"id":"mif-generic","version":"1.0.0","core":true},
                {"id":"edu-fixture","version":"0.1.0","source":"x.yaml"}
            ]}"#,
        )
        .unwrap();

        let catalog = Catalog::load(file.path()).unwrap();
        assert_eq!(catalog.core_ids().collect::<Vec<_>>(), ["mif-generic"]);
        assert_eq!(catalog.find("edu-fixture").unwrap().version, "0.1.0");
        assert!(catalog.find("missing").is_none());
    }

    #[test]
    fn reports_missing_catalog() {
        let error =
            Catalog::load(std::path::Path::new("/nonexistent/enabled-packs.json")).unwrap_err();
        assert!(matches!(error, super::MifRhError::CatalogMissing { .. }));
    }
}