Add reserved name #content to flatten element hierarchies.

Author: adamreichold

Cargo.toml

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/adamreichold/serde-roxmltree"
 documentation = "https://docs.rs/serde-roxmltree"
 readme = "README.md"
-version = "0.8.4"
+version = "0.8.5"
 edition = "2021"
 
 [dependencies]

src/lib.rs

@@ -122,6 +122,39 @@
 //! # Ok::<(), Box<dyn std::error::Error>>(())
 //! ```
 //!
+//! The reserved name `#content` is used to flatten one level of the hierarchy and
+//! revisit those nodes and attributes as if embedded inside another struct. This can
+//! useful to handle partial alternatives:
+//!
+//! ```
+//! use serde::Deserialize;
+//! use serde_roxmltree::from_str;
+//!
+//! #[derive(Debug, PartialEq, Deserialize)]
+//! #[serde(rename_all = "lowercase")]
+//! enum Alternative {
+//!     Float(f32),
+//!     Integer(i32),
+//! }
+//!
+//! #[derive(Debug, PartialEq, Deserialize)]
+//! struct Record {
+//!     #[serde(rename = "#content")]
+//!     alternative: Alternative,
+//!     string: String,
+//! }
+//!
+//! let record = from_str::<Record>("<record><float>42.0</float><string>foo</string></record>")?;
+//! assert_eq!(record.alternative, Alternative::Float(42.0));
+//! assert_eq!(record.string, "foo");
+//!
+//! let record = from_str::<Record>("<record><integer>23</integer><string>bar</string></record>")?;
+//! assert_eq!(record.alternative, Alternative::Integer(23));
+//! assert_eq!(record.string, "bar");
+//! #
+//! # Ok::<(), Box<dyn std::error::Error>>(())
+//! ```
+//!
 //! Optionally, attribute names can be prefixed by `@` to distinguish them from tag names:
 //!
 //! ```
@@ -362,6 +395,7 @@ enum Source<'de, 'input> {
     Node(Node<'de, 'input>),
     Attribute(Attribute<'de, 'input>),
     Text(&'de str),
+    Content(Node<'de, 'input>),
 }
 
 #[derive(Default)]
@@ -440,12 +474,13 @@ where
                 }
             }
             Source::Text(_) => "$text",
+            Source::Content(_) => "#content",
         }
     }
 
     fn node(&self) -> Result<&Node<'de, 'input>, Error> {
         match &self.source {
-            Source::Node(node) => Ok(node),
+            Source::Node(node) | Source::Content(node) => Ok(node),
             Source::Attribute(_) | Source::Text(_) => Err(Error::MissingNode),
         }
     }
@@ -473,7 +508,9 @@ where
 
         let text = once(Source::Text(node.text().unwrap_or_default()));
 
-        Ok(children.chain(attributes).chain(text))
+        let content = once(Source::Content(*node));
+
+        Ok(children.chain(attributes).chain(text).chain(content))
     }
 
     fn siblings(&self) -> Result<impl Iterator<Item = Node<'de, 'de>>, Error> {
@@ -494,7 +531,7 @@ where
 
     fn text(&self) -> &'de str {
         match self.source {
-            Source::Node(node) => node.text().unwrap_or_default(),
+            Source::Node(node) | Source::Content(node) => node.text().unwrap_or_default(),
             Source::Attribute(attr) => attr.value(),
             Source::Text(text) => text,
         }
@@ -1174,6 +1211,51 @@ mod tests {
         assert_eq!(val, Root::Bar(42));
     }
 
+    #[test]
+    fn mixed_enum_and_struct_children() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        enum Foobar {
+            Foo(u32),
+            Bar(i64),
+        }
+
+        #[derive(Deserialize)]
+        struct Root {
+            #[serde(rename = "#content")]
+            foobar: Foobar,
+            qux: f32,
+        }
+
+        let val = from_str::<Root>(r#"<root><Foo>23</Foo><qux>42.0</qux></root>"#).unwrap();
+        assert_eq!(val.foobar, Foobar::Foo(23));
+        assert_eq!(val.qux, 42.0);
+    }
+
+    #[test]
+    fn mixed_enum_and_repeated_struct_children() {
+        #[derive(Debug, PartialEq, Deserialize)]
+        enum Foobar {
+            Foo(u32),
+            Bar(i64),
+        }
+
+        #[derive(Deserialize)]
+        struct Root {
+            #[serde(rename = "#content")]
+            foobar: Foobar,
+            qux: Vec<f32>,
+            baz: String,
+        }
+
+        let val = from_str::<Root>(
+            r#"<root><Bar>42</Bar><qux>1.0</qux><baz>baz</baz><qux>2.0</qux><qux>3.0</qux></root>"#,
+        )
+        .unwrap();
+        assert_eq!(val.foobar, Foobar::Bar(42));
+        assert_eq!(val.qux, [1.0, 2.0, 3.0]);
+        assert_eq!(val.baz, "baz");
+    }
+
     #[test]
     fn borrowed_str() {
         let doc = Document::parse("<root><child>foobar</child></root>").unwrap();