Allow both &text and $value fields in the same struct

failures:
    fixed_name::variable_size::text_and_value
    variable_name::variable_size::text_and_value

Author: Mingun

Changelog.md

@@ -33,6 +33,9 @@ XML specification. See the updated `custom_entities` example!
 
 ### Bug Fixes
 
+- [#868]: Allow to have both `$text` and `$value` special fields in one struct. Previously
+  any text will be recognized as `$value` field even when `$text` field is also presented.
+
 ### Misc Changes
 
 - [#863]: Remove `From<QName<'a>> for BytesStart<'a>` because now `BytesStart` stores the
@@ -42,6 +45,7 @@ XML specification. See the updated `custom_entities` example!
 
 [#766]: https://github.com/tafia/quick-xml/pull/766
 [#863]: https://github.com/tafia/quick-xml/pull/863
+[#868]: https://github.com/tafia/quick-xml/pull/868
 [general entity]: https://www.w3.org/TR/xml11/#gen-entity
 
 

src/de/map.rs

@@ -192,6 +192,8 @@ where
     /// <tag>value for VALUE_KEY field<tag>
     /// ```
     has_value_field: bool,
+    /// Determines if struct have [`VALUE_KEY`], but not [`TEXT_KEY`] special fields.
+    text_as_value: bool,
 }
 
 impl<'de, 'd, R, E> ElementMapAccess<'de, 'd, R, E>
@@ -205,13 +207,16 @@ where
         start: BytesStart<'de>,
         fields: &'static [&'static str],
     ) -> Result<Self, DeError> {
+        let has_value_field = fields.contains(&VALUE_KEY);
         Ok(Self {
             de,
             iter: IterState::new(start.name().as_ref().len(), false),
             start,
             source: ValueSource::Unknown,
             fields,
-            has_value_field: fields.contains(&VALUE_KEY),
+            has_value_field,
+            // If we have dedicated "$text" field, it will not be passed to "$value" field
+            text_as_value: has_value_field && !fields.contains(&TEXT_KEY),
         })
     }
 
@@ -264,10 +269,7 @@ where
         } else {
             // try getting from events (<key>value</key>)
             match self.de.peek()? {
-                // We shouldn't have both `$value` and `$text` fields in the same
-                // struct, so if we have `$value` field, the we should deserialize
-                // text content to `$value`
-                DeEvent::Text(_) if self.has_value_field => {
+                DeEvent::Text(_) if self.text_as_value => {
                     self.source = ValueSource::Content;
                     // Deserialize `key` from special attribute name which means
                     // that value should be taken from the text content of the

src/de/mod.rs

@@ -1506,6 +1506,28 @@
 //! The only difference is in how complex types and sequences are serialized.
 //! If you doubt which one you should select, begin with [`$value`](#value).
 //!
+//! If you have both `$text` and `$value` in you struct, then text events will be
+//! mapped to the `$text` field:
+//!
+//! ```
+//! # use serde::Deserialize;
+//! # use quick_xml::de::from_str;
+//! #[derive(Deserialize, PartialEq, Debug)]
+//! struct TextAndValue {
+//!     #[serde(rename = "$text")]
+//!     text: Option<String>,
+//!
+//!     #[serde(rename = "$value")]
+//!     value: Option<String>,
+//! }
+//!
+//! let object: TextAndValue = from_str("<AnyName>text <![CDATA[and CDATA]]></AnyName>").unwrap();
+//! assert_eq!(object, TextAndValue {
+//!     text: Some("text and CDATA".to_string()),
+//!     value: None,
+//! });
+//! ```
+//!
 //! ## `$text`
 //! `$text` is used when you want to write your XML as a text or a CDATA content.
 //! More formally, field with that name represents simple type definition with
@@ -1744,12 +1766,6 @@
 //! assert_eq!(object, obj);
 //! ```
 //!
-//! ----------------------------------------------------------------------------
-//!
-//! You can have either `$text` or `$value` field in your structs. Unfortunately,
-//! that is not enforced, so you can theoretically have both, but you should
-//! avoid that.
-//!
 //!
 //!
 //! Frequently Used Patterns

tests/serde-de-seq.rs

@@ -821,6 +821,28 @@ mod fixed_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                item: [(); 2],
+            }
+
+            from_str::<List>(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by [`xs:list`s](https://www.w3schools.com/xml/el_list.asp)
         mod xs_list {
@@ -1656,6 +1678,36 @@ mod fixed_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                item: Vec<()>,
+            }
+
+            let data: List = from_str(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+
+            assert_eq!(
+                data,
+                List {
+                    text: (),
+                    item: vec![(); 2],
+                }
+            );
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {
@@ -2883,6 +2935,29 @@ mod variable_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                #[serde(rename = "$value")]
+                value: [(); 2],
+            }
+
+            from_str::<List>(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {
@@ -3929,6 +4004,37 @@ mod variable_name {
             .unwrap_err();
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                #[serde(rename = "$value")]
+                value: Vec<()>,
+            }
+
+            let data: List = from_str(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+
+            assert_eq!(
+                data,
+                List {
+                    text: (),
+                    value: vec![(); 2],
+                }
+            );
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {