Merge pull request #20 from facet-rs/gh-17

fix: support enums as XML attribute values

Author: fasterthanlime

facet-dom/src/deserializer/mod.rs

@@ -869,13 +869,40 @@ where
     ///
     /// # Type Handling
     ///
-    /// Delegates to `facet_dessert::set_string_value` which handles parsing the string
-    /// into the appropriate scalar type (String, &str, integers, floats, bools, etc.).
+    /// For enums, matches the string against variant names using lowerCamelCase conversion
+    /// (matching the serialization behavior). For other types, delegates to
+    /// `facet_dessert::set_string_value` which handles parsing the string into the
+    /// appropriate scalar type (String, &str, integers, floats, bools, etc.).
     pub(crate) fn set_string_value(
         &mut self,
-        wip: Partial<'de, BORROW>,
+        mut wip: Partial<'de, BORROW>,
         value: Cow<'de, str>,
     ) -> Result<Partial<'de, BORROW>, DomDeserializeError<P::Error>> {
+        // Handle enums specially - match variant names with lowerCamelCase conversion
+        if let Type::User(UserType::Enum(enum_def)) = &wip.shape().ty {
+            // Find matching variant
+            for (idx, variant) in enum_def.variants.iter().enumerate() {
+                // Only unit variants can be deserialized from a plain string
+                if variant.data.kind != StructKind::Unit {
+                    continue;
+                }
+
+                // Compute the expected string for this variant (same logic as serialization)
+                let variant_str: Cow<'_, str> = if variant.rename.is_some() {
+                    Cow::Borrowed(variant.effective_name())
+                } else {
+                    to_element_name(variant.name)
+                };
+
+                if value == variant_str {
+                    wip = wip.select_nth_variant(idx)?;
+                    return Ok(wip);
+                }
+            }
+
+            // No match found - fall through to facet_dessert which will give a proper error
+        }
+
         Ok(facet_dessert::set_string_value(
             wip,
             value,

facet-xml/src/serializer.rs

@@ -39,6 +39,22 @@ fn write_scalar_value(
             write!(out, "{}", value)?;
             return Ok(true);
         }
+
+        // Handle enums - unit variants serialize to their variant name
+        if let Ok(enum_) = value.into_enum()
+            && let Ok(variant) = enum_.active_variant()
+            && variant.data.kind == facet_core::StructKind::Unit
+        {
+            // Use effective_name() if there's a rename, otherwise convert to lowerCamelCase
+            let variant_name = if variant.rename.is_some() {
+                Cow::Borrowed(variant.effective_name())
+            } else {
+                facet_dom::naming::to_element_name(variant.name)
+            };
+            out.write_all(variant_name.as_bytes())?;
+            return Ok(true);
+        }
+
         return Ok(false);
     };
 

facet-xml/tests/eenum.rs

@@ -204,6 +204,77 @@ fn enum_as_attribute_value_with_option() {
     assert_eq!(task2.priority, None);
 }
 
+// ============================================================================
+// Enum attribute roundtrip tests (issue #17)
+// ============================================================================
+
+#[test]
+fn enum_as_attribute_value_roundtrip() {
+    // Issue #17: enums as attribute values should serialize to variant name
+
+    #[derive(Debug, Clone, Copy, PartialEq, Facet)]
+    #[repr(C)]
+    enum Status {
+        #[facet(rename = "active")]
+        Active,
+        #[facet(rename = "inactive")]
+        Inactive,
+    }
+
+    #[derive(Debug, Clone, PartialEq, Facet)]
+    #[facet(rename = "Item")]
+    struct Item {
+        #[facet(xml::attribute)]
+        id: u32,
+        #[facet(xml::attribute)]
+        status: Status,
+    }
+
+    let item = Item {
+        id: 42,
+        status: Status::Active,
+    };
+
+    let xml = facet_xml::to_string(&item).unwrap();
+    assert!(xml.contains(r#"status="active""#), "xml was: {}", xml);
+
+    // Roundtrip
+    let parsed: Item = facet_xml::from_str(&xml).unwrap();
+    assert_eq!(parsed.id, 42);
+    assert_eq!(parsed.status, Status::Active);
+}
+
+#[test]
+fn enum_as_attribute_without_rename() {
+    // Test that enums without rename use lowerCamelCase and roundtrip correctly
+
+    #[derive(Debug, Clone, Copy, PartialEq, Facet)]
+    #[repr(C)]
+    enum MyStatus {
+        IsActive,
+        IsInactive,
+    }
+
+    #[derive(Debug, Clone, PartialEq, Facet)]
+    #[facet(rename = "Item")]
+    struct Item {
+        #[facet(xml::attribute)]
+        status: MyStatus,
+    }
+
+    let item = Item {
+        status: MyStatus::IsActive,
+    };
+
+    let xml = facet_xml::to_string(&item).unwrap();
+    // The variant name is converted to lowerCamelCase
+    assert!(xml.contains(r#"status="isActive""#), "xml was: {}", xml);
+
+    // Roundtrip works because deserializer also uses lowerCamelCase matching
+    let parsed: Item = facet_xml::from_str(&xml).unwrap();
+    assert_eq!(parsed.status, MyStatus::IsActive);
+}
+
 // ============================================================================
 // Enum variant fields with xml::attribute (issue #1855)
 // ============================================================================