Some initial work on xml parsing

2025-12-22 15:09:31 +00:00 · 2024-11-24 15:09:34 +01:00
parent 7dfa0c9062
commit a9ef680c30
14 changed files with 1132 additions and 0 deletions
--- a/crates/xml/tests/propfind.rs
+++ b/crates/xml/tests/propfind.rs
@@ -0,0 +1,123 @@
+use quick_xml::events::{BytesStart, Event};
+use rustical_xml::{Unit, XmlDeserialize, XmlError, XmlRoot};
+
+#[derive(Debug, XmlDeserialize)]
+#[xml(rename_all = "kebab-case")]
+pub enum Prop {
+    #[xml(rename = "displayname")]
+    Displayname(String),
+    #[xml(ns = "DAV:Push", rename = "transports")]
+    Transports,
+}
+
+#[derive(Debug)]
+pub struct PropfindElement<T: XmlDeserialize> {
+    // child with name propfind and namespace DAV:
+    pub prop: Vec<T>,
+    pub test: Option<Prop>,
+}
+
+impl<T: XmlDeserialize> XmlDeserialize for PropfindElement<T> {
+    fn deserialize<R: std::io::BufRead>(
+        reader: &mut quick_xml::NsReader<R>,
+        start: &BytesStart,
+        empty: bool,
+    ) -> Result<Self, XmlError> {
+        // init values for the struct attributes
+        let mut attr_prop: Option<Vec<T>> = None;
+        let mut attr_test: Option<Prop> = None;
+
+        if !empty {
+            let mut buf = Vec::new();
+            loop {
+                match reader.read_event_into(&mut buf)? {
+                    Event::End(e) if e.name() == start.name() => {
+                        break;
+                    }
+                    Event::Eof => return Err(XmlError::Eof),
+                    Event::Start(start) => {
+                        let (_ns, name) = reader.resolve_element(start.name());
+                        match name.as_ref() {
+                            b"prop" => {
+                                if attr_prop.is_none() {
+                                    attr_prop = Some(Vec::<T>::deserialize(reader, &start, false)?);
+                                }
+                            }
+                            b"test" => {
+                                if attr_test.is_none() {
+                                    attr_test = Some(Prop::deserialize(reader, &start, false)?);
+                                }
+                            }
+                            _ => {
+                                return Err(XmlError::InvalidTag(
+                                    String::from_utf8_lossy(name.as_ref()).to_string(),
+                                    "prop".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                    Event::Empty(start) => {
+                        let (_ns, name) = reader.resolve_element(start.name());
+                        match name.as_ref() {
+                            b"prop" => {
+                                if attr_prop.is_none() {
+                                    attr_prop = Some(Vec::<T>::deserialize(reader, &start, true)?);
+                                }
+                            }
+                            b"test" => {
+                                if attr_test.is_none() {
+                                    attr_test = Some(Prop::deserialize(reader, &start, true)?);
+                                }
+                            }
+                            _ => {
+                                return Err(XmlError::InvalidTag(
+                                    String::from_utf8_lossy(name.as_ref()).to_string(),
+                                    "prop".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                    a => {
+                        dbg!(a);
+                    }
+                };
+            }
+        }
+
+        let attr_prop = attr_prop.ok_or(XmlError::MissingField("prop"))?;
+        Ok(Self {
+            prop: attr_prop,
+            test: None,
+        })
+    }
+}
+
+impl<T: XmlDeserialize> XmlRoot for PropfindElement<T> {
+    fn root_tag() -> &'static [u8] {
+        b"propfind"
+    }
+}
+
+#[test]
+fn test_propfind() {
+    let propfind: PropfindElement<Prop> = PropfindElement::parse_str(
+        r#"
+        <propfind xmlns="DAV:" xmlns:P="DAV:Push">
+            <P:prop>
+                <displayname>Hello!</displayname>
+                <transports xmlns="DAV:Push" />
+                <transports xmlns="DAV:Push"></transports>
+            </P:prop>
+            <test>
+                <displayname>Okay wow!</displayname>
+            </test>
+        </propfind>
+    "#,
+    )
+    .unwrap();
+    dbg!(propfind);
+}
+
+fn asd() {
+    let a: Option<String> = None;
+}