From 098e374e4d947598b12b7f409a248831a6f4b1ad Mon Sep 17 00:00:00 2001 From: Lennart <18233294+lennart-k@users.noreply.github.com> Date: Tue, 31 Dec 2024 18:20:02 +0100 Subject: [PATCH] xml: namespace serialization --- crates/carddav/src/address_object/resource.rs | 2 +- crates/carddav/src/addressbook/resource.rs | 4 +- crates/carddav/src/principal/mod.rs | 4 +- crates/dav/src/namespace.rs | 54 +++---------------- crates/dav/src/privileges.rs | 8 +-- crates/dav/src/xml/multistatus.rs | 38 +++++++------ crates/dav/src/xml/propfind.rs | 2 +- crates/dav/src/xml/resourcetype.rs | 6 ++- crates/dav/src/xml/tag_list.rs | 7 ++- crates/xml/derive/src/attrs.rs | 5 +- crates/xml/derive/src/field.rs | 28 +++++++--- crates/xml/derive/src/variant.rs | 12 +++-- crates/xml/derive/src/xml_enum.rs | 25 ++++++--- crates/xml/derive/src/xml_struct.rs | 30 ++++++++--- crates/xml/src/de.rs | 6 +-- crates/xml/src/lib.rs | 27 +++++++--- crates/xml/src/se.rs | 15 ++++-- crates/xml/src/value.rs | 29 +++++++--- crates/xml/tests/de_struct.rs | 12 +++-- crates/xml/tests/se_struct.rs | 34 ++++++++++-- 20 files changed, 215 insertions(+), 133 deletions(-) diff --git a/crates/carddav/src/address_object/resource.rs b/crates/carddav/src/address_object/resource.rs index 1cf0ed6..82c6667 100644 --- a/crates/carddav/src/address_object/resource.rs +++ b/crates/carddav/src/address_object/resource.rs @@ -33,7 +33,7 @@ pub enum AddressObjectProp { Getcontenttype(String), // CalDAV (RFC 4791) - #[xml(ns = b"urn:ietf:params:xml:ns:carddav")] + #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")] AddressData(String), } diff --git a/crates/carddav/src/addressbook/resource.rs b/crates/carddav/src/addressbook/resource.rs index dfe153b..d11b76f 100644 --- a/crates/carddav/src/addressbook/resource.rs +++ b/crates/carddav/src/addressbook/resource.rs @@ -37,10 +37,10 @@ pub enum AddressbookProp { Getcontenttype(String), // CardDAV (RFC 6352) - #[xml(ns = b"urn:ietf:params:xml:ns:carddav")] + #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")] AddressbookDescription(Option), #[xml(skip_deserializing)] - #[xml(ns = b"urn:ietf:params:xml:ns:carddav")] + #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")] SupportedAddressData(SupportedAddressData), #[xml(skip_deserializing)] SupportedReportSet(SupportedReportSet), diff --git a/crates/carddav/src/principal/mod.rs b/crates/carddav/src/principal/mod.rs index 6843368..ac3d7ff 100644 --- a/crates/carddav/src/principal/mod.rs +++ b/crates/carddav/src/principal/mod.rs @@ -36,9 +36,9 @@ pub enum PrincipalProp { PrincipalUrl(HrefElement), // CardDAV (RFC 6352) - #[xml(ns = b"urn:ietf:params:xml:ns:carddav")] + #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")] AddressbookHomeSet(HrefElement), - #[xml(ns = b"urn:ietf:params:xml:ns:carddav")] + #[xml(ns = "rustical_dav::namespace::NS_CARDDAV")] PrincipalAddress(Option), } diff --git a/crates/dav/src/namespace.rs b/crates/dav/src/namespace.rs index c48707a..b1bf7b6 100644 --- a/crates/dav/src/namespace.rs +++ b/crates/dav/src/namespace.rs @@ -1,47 +1,9 @@ -use quick_xml::events::attributes::Attribute; +use quick_xml::name::Namespace; -// An enum keeping track of the XML namespaces used for WebDAV and its extensions -// -// Can also generate appropriate attributes for quick_xml -pub enum Namespace { - Dav, - DavPush, - CalDAV, - CardDAV, - ICal, - CServer, - Nextcloud, -} - -impl Namespace { - pub fn as_str(&self) -> &'static str { - match self { - Self::Dav => "DAV:", - Self::DavPush => "DAV:Push", - Self::CalDAV => "urn:ietf:params:xml:ns:caldav", - Self::CardDAV => "urn:ietf:params:xml:ns:carddav", - Self::ICal => "http://apple.com/ns/ical/", - Self::CServer => "http://calendarserver.org/ns/", - Self::Nextcloud => "http://nextcloud.com/ns", - } - } - - // Returns an opinionated namespace attribute name - pub fn xml_attr(&self) -> &'static str { - match self { - Self::Dav => "xmlns", - Self::DavPush => "xmlns:P", - Self::CalDAV => "xmlns:C", - Self::CardDAV => "xmlns:CARD", - Self::ICal => "xmlns:IC", - Self::CServer => "xmlns:CS", - Self::Nextcloud => "xmlns:NEXTC", - } - } -} - -impl From for Attribute<'static> { - fn from(value: Namespace) -> Self { - (value.xml_attr(), value.as_str()).into() - } -} +pub const NS_DAV: Namespace = Namespace(b"DAV:"); +pub const NS_DAVPUSH: Namespace = Namespace(b"DAV:Push"); +pub const NS_CALDAV: Namespace = Namespace(b"urn:ietf:params:xml:ns:caldav"); +pub const NS_CARDDAV: Namespace = Namespace(b"urn:ietf:params:xml:ns:carddav"); +pub const NS_ICAL: Namespace = Namespace(b"http://apple.com/ns/ical/"); +pub const NS_CALENDARSERVER: Namespace = Namespace(b"http://calendarserver.org/ns/"); +pub const NS_NEXTCLOUD: Namespace = Namespace(b"http://nextcloud.com/ns"); diff --git a/crates/dav/src/privileges.rs b/crates/dav/src/privileges.rs index 039bda6..a309245 100644 --- a/crates/dav/src/privileges.rs +++ b/crates/dav/src/privileges.rs @@ -1,5 +1,6 @@ +use quick_xml::name::Namespace; use rustical_xml::{XmlDeserialize, XmlSerialize}; -use std::collections::HashSet; +use std::collections::{HashMap, HashSet}; #[derive(Debug, Clone, XmlSerialize, XmlDeserialize, Eq, Hash, PartialEq)] pub enum UserPrivilege { @@ -16,8 +17,9 @@ pub enum UserPrivilege { impl XmlSerialize for UserPrivilegeSet { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { #[derive(XmlSerialize)] @@ -29,7 +31,7 @@ impl XmlSerialize for UserPrivilegeSet { FakeUserPrivilegeSet { privileges: self.privileges.iter().cloned().collect(), } - .serialize(ns, tag, writer) + .serialize(ns, tag, namespaces, writer) } #[allow(refining_impl_trait)] diff --git a/crates/dav/src/xml/multistatus.rs b/crates/dav/src/xml/multistatus.rs index 2ad00d3..b5a1a10 100644 --- a/crates/dav/src/xml/multistatus.rs +++ b/crates/dav/src/xml/multistatus.rs @@ -1,9 +1,12 @@ -use crate::{namespace::Namespace, xml::TagList}; +use std::collections::HashMap; + +use crate::xml::TagList; use actix_web::{ body::BoxBody, http::{header::ContentType, StatusCode}, HttpRequest, HttpResponse, Responder, ResponseError, }; +use quick_xml::name::Namespace; use rustical_xml::{XmlRootTag, XmlSerialize, XmlSerializeRoot}; // Intermediate struct because of a serde limitation, see following article: @@ -25,11 +28,12 @@ pub struct PropstatElement { fn xml_serialize_status( status: &StatusCode, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { - XmlSerialize::serialize(&format!("HTTP/1.1 {}", status), ns, tag, writer) + XmlSerialize::serialize(&format!("HTTP/1.1 {}", status), ns, tag, namespaces, writer) } #[derive(XmlSerialize)] @@ -53,14 +57,16 @@ pub struct ResponseElement { fn xml_serialize_optional_status( val: &Option, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { XmlSerialize::serialize( &val.map(|status| format!("HTTP/1.1 {}", status)), ns, tag, + namespaces, writer, ) } @@ -86,12 +92,12 @@ pub struct MultistatusElement>, // TODO: napespaces - pub ns_dav: &'static str, - pub ns_davpush: &'static str, - pub ns_caldav: &'static str, - pub ns_ical: &'static str, - pub ns_calendarserver: &'static str, - pub ns_carddav: &'static str, + // pub ns_dav: &'static str, + // pub ns_davpush: &'static str, + // pub ns_caldav: &'static str, + // pub ns_ical: &'static str, + // pub ns_calendarserver: &'static str, + // pub ns_carddav: &'static str, pub sync_token: Option, } @@ -100,12 +106,12 @@ impl Default for MultistatusElement Self { responses: vec![], member_responses: vec![], - ns_dav: Namespace::Dav.as_str(), - ns_davpush: Namespace::DavPush.as_str(), - ns_caldav: Namespace::CalDAV.as_str(), - ns_ical: Namespace::ICal.as_str(), - ns_calendarserver: Namespace::CServer.as_str(), - ns_carddav: Namespace::CardDAV.as_str(), + // ns_dav: Namespace::Dav.as_str(), + // ns_davpush: Namespace::DavPush.as_str(), + // ns_caldav: Namespace::CalDAV.as_str(), + // ns_ical: Namespace::ICal.as_str(), + // ns_calendarserver: Namespace::CServer.as_str(), + // ns_carddav: Namespace::CardDAV.as_str(), sync_token: None, } } diff --git a/crates/dav/src/xml/propfind.rs b/crates/dav/src/xml/propfind.rs index a401b85..c40fa29 100644 --- a/crates/dav/src/xml/propfind.rs +++ b/crates/dav/src/xml/propfind.rs @@ -2,7 +2,7 @@ use rustical_xml::XmlDeserialize; use rustical_xml::XmlRootTag; #[derive(Debug, Clone, XmlDeserialize, XmlRootTag, PartialEq)] -#[xml(root = b"propfind", ns = b"DAV:")] +#[xml(root = b"propfind", ns = "crate::namespace::NS_DAV")] pub struct PropfindElement { #[xml(ty = "untagged")] pub prop: PropfindType, diff --git a/crates/dav/src/xml/resourcetype.rs b/crates/dav/src/xml/resourcetype.rs index 05573f0..82e85ab 100644 --- a/crates/dav/src/xml/resourcetype.rs +++ b/crates/dav/src/xml/resourcetype.rs @@ -1,5 +1,8 @@ +use std::collections::HashMap; + use quick_xml::events::attributes::Attribute; use quick_xml::events::{BytesEnd, BytesStart, Event}; +use quick_xml::name::Namespace; use rustical_xml::XmlSerialize; #[derive(Debug, Clone, PartialEq)] @@ -8,8 +11,9 @@ pub struct Resourcetype(pub &'static [&'static str]); impl XmlSerialize for Resourcetype { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { let tag_str = tag.map(String::from_utf8_lossy); diff --git a/crates/dav/src/xml/tag_list.rs b/crates/dav/src/xml/tag_list.rs index f48dd4a..0c82fc9 100644 --- a/crates/dav/src/xml/tag_list.rs +++ b/crates/dav/src/xml/tag_list.rs @@ -1,5 +1,7 @@ use derive_more::derive::From; +use quick_xml::name::Namespace; use rustical_xml::XmlSerialize; +use std::collections::HashMap; #[derive(Clone, Debug, PartialEq, From)] pub struct TagList(Vec); @@ -7,8 +9,9 @@ pub struct TagList(Vec); impl XmlSerialize for TagList { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { #[derive(Debug, XmlSerialize, PartialEq)] @@ -25,7 +28,7 @@ impl XmlSerialize for TagList { Inner { tags: self.0.iter().map(|t| Tag { name: t.to_owned() }).collect(), } - .serialize(ns, tag, writer) + .serialize(ns, tag, namespaces, writer) } #[allow(refining_impl_trait)] diff --git a/crates/xml/derive/src/attrs.rs b/crates/xml/derive/src/attrs.rs index bc2f732..034464d 100644 --- a/crates/xml/derive/src/attrs.rs +++ b/crates/xml/derive/src/attrs.rs @@ -10,7 +10,8 @@ pub struct ContainerAttrs { pub struct TagAttrs { pub rename: Option, pub ns_strict: Flag, - pub ns: Option, + // pub ns: Option, + pub ns: Option, } #[derive(Default, FromVariant)] @@ -37,7 +38,7 @@ pub struct StructAttrs { pub container: ContainerAttrs, pub root: Option, - pub ns: Option, + pub ns: Option, pub allow_invalid: Flag, } diff --git a/crates/xml/derive/src/field.rs b/crates/xml/derive/src/field.rs index 783a054..4925bf6 100644 --- a/crates/xml/derive/src/field.rs +++ b/crates/xml/derive/src/field.rs @@ -148,8 +148,8 @@ impl Field { } let namespace_match = if self.ns_strict() { - if let Some(ns) = &self.attrs.common.ns { - quote! {quick_xml::name::ResolveResult::Bound(quick_xml::name::Namespace(#ns))} + if self.attrs.common.ns.is_some() { + quote! {quick_xml::name::ResolveResult::Bound(ns)} } else { quote! {quick_xml::name::ResolveResult::Unbound} } @@ -157,6 +157,16 @@ impl Field { quote! {_} }; + let namespace_condition = if self.ns_strict() { + self.attrs + .common + .ns + .as_ref() + .map(|ns| quote! { if ns == #ns }) + } else { + None + }; + let field_name = self.xml_name(); let field_ident = self.field_ident(); let deserializer = self.deserializer_type(); @@ -170,7 +180,7 @@ impl Field { }; Some(quote! { - (#namespace_match, #field_name) => { #assignment; } + (#namespace_match, #field_name) #namespace_condition => { #assignment; } }) } @@ -256,6 +266,10 @@ impl Field { } else { quote! { ::rustical_xml::XmlSerialize::serialize } }; + let ns = match &self.attrs.common.ns { + Some(ns) => quote! { Some(#ns) }, + None => quote! { None }, + }; match (&self.attrs.xml_ty, self.attrs.flatten.is_present()) { (FieldType::Attr, _) => None, @@ -269,19 +283,19 @@ impl Field { }), (FieldType::Tag, true) => Some(quote! { for item in self.#field_ident.iter() { - #serializer(item, None, Some(#field_name), writer)?; + #serializer(item, #ns, Some(#field_name), namespaces, writer)?; } }), (FieldType::Tag, false) => Some(quote! { - #serializer(&self.#field_ident, None, Some(#field_name), writer)?; + #serializer(&self.#field_ident, #ns, Some(#field_name), namespaces, writer)?; }), (FieldType::Untagged, true) => Some(quote! { for item in self.#field_ident.iter() { - #serializer(item, None, None, writer)?; + #serializer(item, None, None, namespaces, writer)?; } }), (FieldType::Untagged, false) => Some(quote! { - #serializer(&self.#field_ident, None, None, writer)?; + #serializer(&self.#field_ident, None, None, namespaces, writer)?; }), // TODO: Think about what to do here (FieldType::TagName | FieldType::Namespace, _) => None, diff --git a/crates/xml/derive/src/variant.rs b/crates/xml/derive/src/variant.rs index 1bc6139..469ba24 100644 --- a/crates/xml/derive/src/variant.rs +++ b/crates/xml/derive/src/variant.rs @@ -176,6 +176,10 @@ impl Variant { pub fn se_branch(&self) -> proc_macro2::TokenStream { let ident = self.ident(); let variant_name = self.xml_name(); + let ns = match &self.attrs.common.ns { + Some(ns) => quote! { Some(#ns) }, + None => quote! { None }, + }; match &self.variant.fields { Fields::Named(_) => { @@ -190,9 +194,9 @@ impl Variant { quote! { if let Self::#ident(val) = &self { if !enum_untagged { - ::rustical_xml::XmlSerialize::serialize(val, None, Some(#variant_name), writer)?; + ::rustical_xml::XmlSerialize::serialize(val, #ns, Some(#variant_name), namespaces, writer)?; } else { - ::rustical_xml::XmlSerialize::serialize(val, None, None, writer)?; + ::rustical_xml::XmlSerialize::serialize(val, None, None, namespaces, writer)?; }; } } @@ -201,9 +205,9 @@ impl Variant { quote! { if let Self::#ident = &self { if !enum_untagged { - ::rustical_xml::XmlSerialize::serialize(&(), None, Some(#variant_name), writer)?; + ::rustical_xml::XmlSerialize::serialize(&(), #ns, Some(#variant_name), namespaces, writer)?; } else { - ::rustical_xml::XmlSerialize::serialize(&(), None, None, writer)?; + ::rustical_xml::XmlSerialize::serialize(&(), None, None, namespaces, writer)?; }; } } diff --git a/crates/xml/derive/src/xml_enum.rs b/crates/xml/derive/src/xml_enum.rs index 71af739..af0a5f2 100644 --- a/crates/xml/derive/src/xml_enum.rs +++ b/crates/xml/derive/src/xml_enum.rs @@ -99,24 +99,37 @@ impl Enum { impl #impl_generics ::rustical_xml::XmlSerialize for #ident #type_generics #where_clause { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option<::quick_xml::name::Namespace>, tag: Option<&[u8]>, + namespaces: &::std::collections::HashMap<::quick_xml::name::Namespace, &[u8]>, writer: &mut ::quick_xml::Writer ) -> ::std::io::Result<()> { use ::quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; - let tag_str = tag.map(String::from_utf8_lossy); + let prefix = ns + .map(|ns| namespaces.get(&ns)) + .unwrap_or(None) + .map(|prefix| [*prefix, b":"].concat()); + let has_prefix = prefix.is_some(); + let tagname = tag.map(|tag| [&prefix.unwrap_or_default(), tag].concat()); + let qname = tagname.as_ref().map(|tagname| ::quick_xml::name::QName(tagname)); + const enum_untagged: bool = #enum_untagged; - if let Some(tag) = &tag_str { - let bytes_start = BytesStart::new(tag.to_owned()); + if let Some(qname) = &qname { + let mut bytes_start = BytesStart::from(qname.to_owned()); + if !has_prefix { + if let Some(ns) = &ns { + bytes_start.push_attribute((b"xmlns".as_ref(), ns.as_ref())); + } + } writer.write_event(Event::Start(bytes_start))?; } #(#variant_serializers);* - if let Some(tag) = &tag_str { - writer.write_event(Event::End(BytesEnd::new(tag.to_owned())))?; + if let Some(qname) = &qname { + writer.write_event(Event::End(BytesEnd::from(qname.to_owned())))?; } Ok(()) } diff --git a/crates/xml/derive/src/xml_struct.rs b/crates/xml/derive/src/xml_struct.rs index 21b5c4f..0054105 100644 --- a/crates/xml/derive/src/xml_struct.rs +++ b/crates/xml/derive/src/xml_struct.rs @@ -60,7 +60,7 @@ impl NamedStruct { quote! { impl #impl_generics ::rustical_xml::XmlRootTag for #ident #type_generics #where_clause { fn root_tag() -> &'static [u8] { #root } - fn root_ns() -> Option<&'static [u8]> { #ns } + fn root_ns() -> Option<::quick_xml::name::Namespace<'static>> { #ns } } } } @@ -217,7 +217,8 @@ impl NamedStruct { .map(|field| { let field_ident = field.field_ident(); quote! { - let tag_str = Some(tag_str.unwrap_or(self.#field_ident.to_string())); + let tag_str = self.#field_ident.to_string(); + let tag = Some(tag.unwrap_or(tag_str.as_bytes())); } }); @@ -227,17 +228,30 @@ impl NamedStruct { impl #impl_generics ::rustical_xml::XmlSerialize for #ident #type_generics #where_clause { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option<::quick_xml::name::Namespace>, tag: Option<&[u8]>, + namespaces: &::std::collections::HashMap<::quick_xml::name::Namespace, &[u8]>, writer: &mut ::quick_xml::Writer ) -> ::std::io::Result<()> { use ::quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; - let tag_str = tag.map(|a| String::from_utf8_lossy(a).to_string()); #tag_name_field; - if let Some(tag) = &tag_str { - let mut bytes_start = BytesStart::new(tag.to_owned()); + let prefix = ns + .map(|ns| namespaces.get(&ns)) + .unwrap_or(None) + .map(|prefix| [*prefix, b":"].concat()); + let has_prefix = prefix.is_some(); + let tagname = tag.map(|tag| [&prefix.unwrap_or_default(), tag].concat()); + let qname = tagname.as_ref().map(|tagname| ::quick_xml::name::QName(tagname)); + + if let Some(qname) = &qname { + let mut bytes_start = BytesStart::from(qname.to_owned()); + if !has_prefix { + if let Some(ns) = &ns { + bytes_start.push_attribute((b"xmlns".as_ref(), ns.as_ref())); + } + } if let Some(attrs) = self.attributes() { bytes_start.extend_attributes(attrs); } @@ -250,8 +264,8 @@ impl NamedStruct { } if !#is_empty { #(#tag_writers);* - if let Some(tag) = &tag_str { - writer.write_event(Event::End(BytesEnd::new(tag.to_owned())))?; + if let Some(qname) = &qname { + writer.write_event(Event::End(BytesEnd::from(qname.to_owned())))?; } } Ok(()) diff --git a/crates/xml/src/de.rs b/crates/xml/src/de.rs index bfae62e..0c761cb 100644 --- a/crates/xml/src/de.rs +++ b/crates/xml/src/de.rs @@ -54,11 +54,7 @@ impl XmlDocument for T { // Wrong tag (_, _, name) if name.as_ref() != Self::root_tag() => false, // Wrong namespace - (Some(root_ns), ns, _) - if &ResolveResult::Bound(Namespace(root_ns)) != ns => - { - false - } + (Some(root_ns), ns, _) if &ResolveResult::Bound(root_ns) != ns => false, _ => true, }; if !matches { diff --git a/crates/xml/src/lib.rs b/crates/xml/src/lib.rs index 562606e..e21993e 100644 --- a/crates/xml/src/lib.rs +++ b/crates/xml/src/lib.rs @@ -1,5 +1,6 @@ -use quick_xml::events::BytesEnd; use quick_xml::events::{BytesStart, Event}; +use quick_xml::name::{Namespace, QName}; +use std::collections::HashMap; use std::io::BufRead; pub mod de; @@ -38,14 +39,26 @@ impl XmlDeserialize for () { impl XmlSerialize for () { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { - let tag_str = tag.map(String::from_utf8_lossy); - - if let Some(tag) = &tag_str { - writer.write_event(Event::Empty(BytesStart::new(tag.clone())))?; + let prefix = ns + .map(|ns| namespaces.get(&ns)) + .unwrap_or(None) + .map(|prefix| [*prefix, b":"].concat()); + let has_prefix = prefix.is_some(); + let tagname = tag.map(|tag| [&prefix.unwrap_or_default(), tag].concat()); + let qname = tagname.as_ref().map(|tagname| QName(tagname)); + if let Some(qname) = &qname { + let mut bytes_start = BytesStart::from(qname.to_owned()); + if !has_prefix { + if let Some(ns) = &ns { + bytes_start.push_attribute((b"xmlns".as_ref(), ns.as_ref())); + } + } + writer.write_event(Event::Empty(bytes_start))?; } Ok(()) } @@ -84,5 +97,5 @@ impl XmlDeserialize for Unparsed { pub trait XmlRootTag { fn root_tag() -> &'static [u8]; - fn root_ns() -> Option<&'static [u8]>; + fn root_ns() -> Option>; } diff --git a/crates/xml/src/se.rs b/crates/xml/src/se.rs index 58b9d62..ba57d7d 100644 --- a/crates/xml/src/se.rs +++ b/crates/xml/src/se.rs @@ -1,4 +1,6 @@ -use quick_xml::events::attributes::Attribute; +use std::collections::HashMap; + +use quick_xml::{events::attributes::Attribute, name::Namespace}; pub use xml_derive::XmlSerialize; use crate::XmlRootTag; @@ -6,8 +8,9 @@ use crate::XmlRootTag; pub trait XmlSerialize { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()>; @@ -17,12 +20,13 @@ pub trait XmlSerialize { impl XmlSerialize for Option { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { if let Some(some) = self { - some.serialize(ns, tag, writer) + some.serialize(ns, tag, namespaces, writer) } else { Ok(()) } @@ -46,6 +50,7 @@ impl XmlSerializeRoot for T { &self, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { - self.serialize(Self::root_ns(), Some(Self::root_tag()), writer) + let namespaces = HashMap::new(); + self.serialize(Self::root_ns(), Some(Self::root_tag()), &namespaces, writer) } } diff --git a/crates/xml/src/value.rs b/crates/xml/src/value.rs index 4fe514b..6f9f80a 100644 --- a/crates/xml/src/value.rs +++ b/crates/xml/src/value.rs @@ -1,4 +1,6 @@ use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event}; +use quick_xml::name::{Namespace, QName}; +use std::collections::HashMap; use std::num::{ParseFloatError, ParseIntError}; use std::{convert::Infallible, io::BufRead}; use thiserror::Error; @@ -93,19 +95,30 @@ impl XmlDeserialize for T { impl XmlSerialize for T { fn serialize( &self, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut quick_xml::Writer, ) -> std::io::Result<()> { - let tag_str = tag.map(String::from_utf8_lossy); - - if let Some(tag) = &tag_str { - writer.write_event(Event::Start(BytesStart::new(tag.clone())))?; + let prefix = ns + .map(|ns| namespaces.get(&ns)) + .unwrap_or(None) + .map(|prefix| [*prefix, b":"].concat()); + let has_prefix = prefix.is_some(); + let tagname = tag.map(|tag| [&prefix.unwrap_or_default(), tag].concat()); + let qname = tagname.as_ref().map(|tagname| QName(tagname)); + if let Some(qname) = &qname { + let mut bytes_start = BytesStart::from(qname.to_owned()); + if !has_prefix { + if let Some(ns) = &ns { + bytes_start.push_attribute((b"xmlns".as_ref(), ns.as_ref())); + } + } + writer.write_event(Event::Start(bytes_start))?; } writer.write_event(Event::Text(BytesText::new(&self.serialize())))?; - - if let Some(tag) = &tag_str { - writer.write_event(Event::End(BytesEnd::new(tag.clone())))?; + if let Some(qname) = &qname { + writer.write_event(Event::End(BytesEnd::from(qname.to_owned())))?; } Ok(()) } diff --git a/crates/xml/tests/de_struct.rs b/crates/xml/tests/de_struct.rs index c8e6315..04bf581 100644 --- a/crates/xml/tests/de_struct.rs +++ b/crates/xml/tests/de_struct.rs @@ -1,6 +1,6 @@ +use quick_xml::name::Namespace; use rustical_xml::de::XmlDocument; -use rustical_xml::XmlRootTag; -use rustical_xml::{Unparsed, XmlDeserialize}; +use rustical_xml::{Unparsed, XmlDeserialize, XmlRootTag}; use std::collections::HashSet; #[test] @@ -151,10 +151,12 @@ fn test_struct_set() { #[test] fn test_struct_ns() { + const NS_HELLO: Namespace = Namespace(b"hello"); + #[derive(Debug, XmlDeserialize, XmlRootTag, PartialEq)] #[xml(root = b"document", ns_strict)] struct Document { - #[xml(ns = b"hello")] + #[xml(ns = "NS_HELLO")] child: (), } @@ -164,10 +166,12 @@ fn test_struct_ns() { #[test] fn test_struct_attr() { + const NS_HELLO: Namespace = Namespace(b"hello"); + #[derive(Debug, XmlDeserialize, XmlRootTag, PartialEq)] #[xml(root = b"document", ns_strict)] struct Document { - #[xml(ns = b"hello")] + #[xml(ns = "NS_HELLO")] child: (), #[xml(ty = "attr", default = "Default::default")] test: String, diff --git a/crates/xml/tests/se_struct.rs b/crates/xml/tests/se_struct.rs index 5990761..04d6dc9 100644 --- a/crates/xml/tests/se_struct.rs +++ b/crates/xml/tests/se_struct.rs @@ -1,5 +1,9 @@ -use std::borrow::{Borrow, Cow}; +use std::{ + borrow::{Borrow, Cow}, + collections::HashMap, +}; +use quick_xml::name::Namespace; use quick_xml::Writer; use rustical_xml::{XmlDocument, XmlRootTag, XmlSerialize, XmlSerializeRoot}; use xml_derive::XmlDeserialize; @@ -135,11 +139,12 @@ fn test_struct_serialize_with() { fn serialize_href( val: &str, - ns: Option<&[u8]>, + ns: Option, tag: Option<&[u8]>, + namespaces: &HashMap, writer: &mut Writer, ) -> std::io::Result<()> { - val.to_uppercase().serialize(ns, tag, writer) + val.to_uppercase().serialize(ns, tag, namespaces, writer) } let mut buf = Vec::new(); @@ -188,3 +193,26 @@ fn test_struct_tag_list() { let out = String::from_utf8(buf).unwrap(); dbg!(out); } + +#[test] +fn test_struct_ns() { + // const NS: Namespace = Namespace(b"TEST", quick_xml::name::Namespace(b"NS:TEST:")); + const NS: Namespace = quick_xml::name::Namespace(b"NS:TEST:"); + + #[derive(Debug, XmlRootTag, XmlSerialize)] + #[xml(root = b"document")] + struct Document { + #[xml(ns = "NS", rename = b"okay")] + child: String, + } + + let mut buf = Vec::new(); + let mut writer = quick_xml::Writer::new(&mut buf); + Document { + child: "hello!".to_string(), + } + .serialize_root(&mut writer) + .unwrap(); + let out = String::from_utf8(buf).unwrap(); + dbg!(out); +}