xee-interpreter 0.2.0

Interpreter for XPath and XSLT
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

// https://www.w3.org/TR/xpath-functions-31/#parsing-and-serializing

use xee_xpath_macros::xpath_fn;

use crate::{context, error, function, interpreter::Interpreter, sequence, wrap_xpath_fn};

use super::StaticFunctionDescription;

#[xpath_fn("fn:parse-xml($arg as xs:string?) as document-node(element(*))?")]
fn parse_xml(
    context: &context::DynamicContext,
    interpreter: &mut Interpreter,
    arg: Option<&str>,
) -> error::Result<Option<xot::Node>> {
    if let Some(arg) = arg {
        let documents = context.documents();
        let handle = documents
            .borrow_mut()
            .add_string(interpreter.xot_mut(), None, arg)
            .map_err(|_| error::Error::FODC0006)?;
        let doc = documents
            .borrow()
            .get_node_by_handle(handle)
            .ok_or(error::Error::FODC0006)?;
        Ok(Some(doc))
    } else {
        Ok(None)
    }
}

#[xpath_fn("fn:parse-xml-fragment($arg as xs:string?) as document-node()?")]
fn parse_xml_fragment(
    context: &context::DynamicContext,
    interpreter: &mut Interpreter,
    arg: Option<&str>,
) -> error::Result<Option<xot::Node>> {
    if let Some(arg) = arg {
        let documents = context.documents();
        let handle = documents
            .borrow_mut()
            .add_fragment_string(interpreter.xot_mut(), arg)
            .map_err(|_| error::Error::FODC0006)?;
        let doc = documents
            .borrow()
            .get_node_by_handle(handle)
            .ok_or(error::Error::FODC0006)?;
        Ok(Some(doc))
    } else {
        Ok(None)
    }
}

#[xpath_fn("fn:serialize($arg as item()*) as xs:string")]
fn serialize1(
    context: &context::DynamicContext,
    interpreter: &mut Interpreter,
    arg: &sequence::Sequence,
) -> error::Result<String> {
    let map = function::Map::new(vec![])?;
    let serialization_parameters = sequence::SerializationParameters::from_map(
        map,
        context.static_context(),
        interpreter.xot_mut(),
    )?;
    arg.serialize(serialization_parameters, interpreter.xot_mut())
}

#[xpath_fn("fn:serialize($arg as item()*, $params as item()?) as xs:string")]
fn serialize2(
    context: &context::DynamicContext,
    interpreter: &mut Interpreter,
    arg: &sequence::Sequence,
    params: Option<sequence::Item>,
) -> error::Result<String> {
    let map = if let Some(params) = params {
        if let sequence::Item::Function(function::Function::Map(map)) = params {
            map.clone()
        } else {
            // TODO: handle element(output::serialization-parameters)
            return Err(error::Error::XPTY0004);
        }
    } else {
        function::Map::new(vec![])?
    };
    let serialization_parameters = sequence::SerializationParameters::from_map(
        map,
        context.static_context(),
        interpreter.xot_mut(),
    )?;
    arg.serialize(serialization_parameters, interpreter.xot_mut())
}

pub(crate) fn static_function_descriptions() -> Vec<StaticFunctionDescription> {
    vec![
        wrap_xpath_fn!(parse_xml),
        wrap_xpath_fn!(parse_xml_fragment),
        wrap_xpath_fn!(serialize1),
        wrap_xpath_fn!(serialize2),
    ]
}