ical/tree/param/
node.rs

1//! # Parameter node
2//!
3//! The raw, byte-faithful parameter on the syntax side.
4//!
5//! [`IcalParamNode`] is the syntactic peer of the decoded
6//! [`IcalParam`](crate::param::IcalParam): a name leaf and its raw value
7//! leaves, parsed from and serialized back to the wire verbatim. The per-name
8//! lens markers that give it meaning live alongside in [`crate::tree::param`].
9
10use core::fmt;
11
12use alloc::vec::Vec;
13
14use crate::tree::leaf::IcalLeaf;
15
16/// One raw parameter: a name and its `,`-separated raw values (empty when the
17/// parameter has no `=` list). The syntactic peer of the decoded
18/// [`IcalParam`](crate::param::IcalParam).
19#[derive(Clone, Debug)]
20pub struct IcalParamNode<'a> {
21    /// The parameter name leaf.
22    pub name: IcalLeaf<'a>,
23    /// The raw value leaves.
24    pub values: Vec<IcalLeaf<'a>>,
25}
26
27impl<'a> IcalParamNode<'a> {
28    /// Parse one `name=value,value` parameter (commas outside quotes split).
29    pub fn parse(param: &'a str) -> Self {
30        match param.split_once('=') {
31            Some((name, values)) => Self {
32                name: IcalLeaf::from(name),
33                values: split_param_values(values)
34                    .into_iter()
35                    .map(IcalLeaf::from)
36                    .collect(),
37            },
38            None => Self {
39                name: IcalLeaf::from(param),
40                values: Vec::new(),
41            },
42        }
43    }
44
45    /// Convert into an owned parameter node (`'static`).
46    pub(crate) fn into_static(self) -> IcalParamNode<'static> {
47        IcalParamNode {
48            name: self.name.into_static(),
49            values: self.values.into_iter().map(IcalLeaf::into_static).collect(),
50        }
51    }
52
53    /// Serialize the parameter (`name` or `name=value,value`) into `out`,
54    /// without the intermediate `String` a `Display`-based path would allocate.
55    pub(crate) fn write_bytes(&self, out: &mut Vec<u8>) {
56        out.extend_from_slice(self.name.get().as_bytes());
57
58        if let Some((first, rest)) = self.values.split_first() {
59            out.push(b'=');
60            out.extend_from_slice(first.get().as_bytes());
61            for value in rest {
62                out.push(b',');
63                out.extend_from_slice(value.get().as_bytes());
64            }
65        }
66    }
67}
68
69impl fmt::Display for IcalParamNode<'_> {
70    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
71        f.write_str(self.name.get())?;
72
73        if let Some((first, rest)) = self.values.split_first() {
74            write!(f, "={}", first.get())?;
75
76            for value in rest {
77                write!(f, ",{}", value.get())?;
78            }
79        }
80
81        Ok(())
82    }
83}
84
85/// Split a parameter value list on commas outside double quotes.
86fn split_param_values(values: &str) -> Vec<&str> {
87    let bytes = values.as_bytes();
88    let mut pieces = Vec::new();
89    let mut start = 0;
90    let mut quoted = false;
91
92    for (i, &byte) in bytes.iter().enumerate() {
93        match byte {
94            b'"' => quoted = !quoted,
95            b',' if !quoted => {
96                pieces.push(&values[start..i]);
97                start = i + 1;
98            }
99            _ => {}
100        }
101    }
102
103    pieces.push(&values[start..]);
104    pieces
105}
106
107#[cfg(test)]
108mod tests {
109    use alloc::string::ToString;
110
111    use crate::tree::param::node::IcalParamNode;
112
113    #[test]
114    fn parses_quoted_values_then_round_trips() {
115        let node = IcalParamNode::parse(r#"TYPE=work,"a,b""#);
116        assert_eq!(node.values.len(), 2);
117        assert_eq!(node.to_string(), r#"TYPE=work,"a,b""#);
118    }
119}
ical/tree/param/node.rs

ical/tree/param/
node.rs
