xee-testrunner 0.1.6

Conformance testing for Xee's XPath and XSLT implementations
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
112

use anyhow::Result;

use xee_xpath::{context, Queries, Query};
use xee_xpath_load::{convert_string, ContextLoadable};

use crate::catalog::LoadContext;

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Metadata {
    pub(crate) description: Option<String>,
    pub(crate) created: Option<Attribution>,
    pub(crate) modified: Vec<Modification>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Modification {
    pub(crate) attribution: Attribution,
    pub(crate) description: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Attribution {
    pub(crate) by: String,
    pub(crate) on: String, // should be a date
}

impl ContextLoadable<LoadContext> for Metadata {
    fn static_context_builder(context: &LoadContext) -> context::StaticContextBuilder {
        let mut builder = context::StaticContextBuilder::default();
        builder.default_element_namespace(context.catalog_ns);
        builder
    }

    fn load_with_context(
        queries: &Queries,
        _context: &LoadContext,
    ) -> Result<impl Query<Metadata>> {
        let description_query = queries.option("description/string()", convert_string)?;
        let by_query = queries.one("@by/string()", convert_string)?;
        let on_query = queries.one("@on/string()", convert_string)?;
        let by_query2 = by_query.clone();
        let on_query2 = on_query.clone();
        let created_query = queries.option("created", move |session, item| {
            {
                {
                    Ok(Attribution {
                        by: by_query.execute(session, item)?,
                        on: on_query.execute(session, item)?,
                    })
                }
            }
        })?;

        let change_query = queries.option("@change/string()", convert_string)?;
        let modified_query = queries.many("modified", move |session, item| {
            let attribution = Attribution {
                by: by_query2.execute(session, item)?,
                on: on_query2.execute(session, item)?,
            };
            let description = change_query.execute(session, item)?;
            Ok(Modification {
                attribution,
                description: description.unwrap_or("".to_string()),
            })
        })?;

        let metadata_query = queries.one(".", move |session, item| {
            let description = description_query.execute(session, item)?;
            let created = created_query.execute(session, item)?;
            let modified = modified_query.execute(session, item)?;
            Ok(Metadata {
                description,
                created,
                modified,
            })
        })?;

        Ok(metadata_query)
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use crate::language::XPathLanguage;

    use super::*;

    #[test]
    fn test_load() {
        let xml = r#"
<container xmlns="http://www.w3.org/2010/09/qt-fots-catalog">
  <description>Description</description>
  <created by="Foo Barson" on="2024-01-01"/>
</container>"#;
        let context = LoadContext::new::<XPathLanguage>(PathBuf::new());
        let metadata = Metadata::load_from_xml_with_context(xml, &context).unwrap();
        assert_eq!(
            metadata,
            Metadata {
                description: Some("Description".to_string()),
                created: Some(Attribution {
                    by: "Foo Barson".to_string(),
                    on: "2024-01-01".to_string(),
                }),
                modified: vec![],
            }
        );
        // Metadata::load_fom_xml(&mut xot, xml, XPATH_NS).unwrap();
    }
}