clayers-xml 0.2.0

Domain-agnostic XML utilities for clayers (C14N, hashing, RNC, catalog)
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
100
101
102
103
104
105
106
107
108
109
110
111

//! OASIS XML Catalog parsing (domain-agnostic).

use std::path::Path;

use xot::Xot;

/// A single entry from an OASIS XML Catalog `<uri>` element.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CatalogEntry {
    /// The namespace URI (`name` attribute).
    pub namespace: String,
    /// The relative file path (`uri` attribute).
    pub path: String,
}

/// Parse an OASIS XML Catalog file, returning namespace-to-path mappings.
///
/// Reads `<uri name="..." uri="..."/>` elements from the catalog.
///
/// # Errors
///
/// Returns an error if the file cannot be read or parsed as XML.
pub fn parse_catalog(catalog_path: &Path) -> Result<Vec<CatalogEntry>, crate::Error> {
    let content = std::fs::read_to_string(catalog_path)?;
    let mut xot = Xot::new();
    let doc = xot.parse(&content).map_err(xot::Error::from)?;
    let root = xot.document_element(doc)?;

    let catalog_ns = xot.add_namespace("urn:oasis:names:tc:entity:xmlns:xml:catalog");
    let uri_el = xot.add_name_ns("uri", catalog_ns);
    let name_attr = xot.add_name("name");
    let uri_attr = xot.add_name("uri");

    let mut entries = Vec::new();
    for child in xot.children(root) {
        if !xot.is_element(child) {
            continue;
        }
        let Some(el) = xot.element(child) else {
            continue;
        };
        if el.name() != uri_el {
            continue;
        }
        let Some(name) = xot.get_attribute(child, name_attr) else {
            continue;
        };
        let Some(uri) = xot.get_attribute(child, uri_attr) else {
            continue;
        };
        entries.push(CatalogEntry {
            namespace: name.to_string(),
            path: uri.to_string(),
        });
    }

    Ok(entries)
}

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

    #[test]
    fn parse_catalog_extracts_entries() {
        let dir = tempfile::tempdir().unwrap();
        let catalog = r#"<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
  <uri name="urn:test:foo" uri="foo.xsd"/>
  <uri name="urn:test:bar" uri="bar.xsd"/>
</catalog>"#;
        let path = dir.path().join("catalog.xml");
        std::fs::write(&path, catalog).unwrap();

        let entries = parse_catalog(&path).unwrap();
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].namespace, "urn:test:foo");
        assert_eq!(entries[0].path, "foo.xsd");
        assert_eq!(entries[1].namespace, "urn:test:bar");
        assert_eq!(entries[1].path, "bar.xsd");
    }

    #[test]
    fn parse_catalog_skips_non_uri_elements() {
        let dir = tempfile::tempdir().unwrap();
        let catalog = r#"<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
  <!-- A comment -->
  <uri name="urn:test:only" uri="only.xsd"/>
</catalog>"#;
        let path = dir.path().join("catalog.xml");
        std::fs::write(&path, catalog).unwrap();

        let entries = parse_catalog(&path).unwrap();
        assert_eq!(entries.len(), 1);
        assert_eq!(entries[0].namespace, "urn:test:only");
    }

    #[test]
    fn parse_catalog_empty_catalog() {
        let dir = tempfile::tempdir().unwrap();
        let catalog = r#"<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
</catalog>"#;
        let path = dir.path().join("catalog.xml");
        std::fs::write(&path, catalog).unwrap();

        let entries = parse_catalog(&path).unwrap();
        assert!(entries.is_empty());
    }
}