NationTech/yaserde
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #82 from media-io/flatten_attribute

Browse Source 
support flatten attributes
This commit is contained in:
Marc-Antoine ARNAUD 2020-06-07 17:11:18 +02:00 committed by GitHub
commit 23098184f2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 272 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
yaserde/src/lib.rs
View File

@ -23,8 +23,20 @@ pub trait YaDeserialize: Sized {
}
/// A **data structure** that can be serialized into any data format supported by YaSerDe.
pub trait YaSerialize: Sized {
pub trait YaSerialize<'a>: Sized {
fn serialize<W: Write>(&self, writer: &mut ser::Serializer<W>) -> Result<(), String>;
fn serialize_attributes(
&self,
attributes: Vec<xml::attribute::OwnedAttribute>,
namespace: xml::namespace::Namespace,
) -> Result<
(
Vec<xml::attribute::OwnedAttribute>,
xml::namespace::Namespace,
),
String,
>;
}
/// A **visitor** that can be implemented to retrieve information from source file.
@ -83,13 +95,27 @@ pub trait Visitor<'de>: Sized {
macro_rules! serialize_type {
($type:ty) => {
impl YaSerialize for $type {
impl<'a> YaSerialize<'a> for $type {
fn serialize<W: Write>(&self, writer: &mut ser::Serializer<W>) -> Result<(), String> {
let content = format!("{}", self);
let event = XmlEvent::characters(&content);
let _ret = writer.write(event);
Ok(())
}
fn serialize_attributes(
&self,
attributes: Vec<xml::attribute::OwnedAttribute>,
namespace: xml::namespace::Namespace,
) -> Result<
(
Vec<xml::attribute::OwnedAttribute>,
xml::namespace::Namespace,
),
String,
> {
Ok((attributes, namespace))
}
}
};
}

13
yaserde/src/ser/mod.rs
View File

@ -7,21 +7,24 @@ use std::str;
use xml::writer::XmlEvent;
use xml::{EmitterConfig, EventWriter};
pub fn to_string<T: YaSerialize>(model: &T) -> Result<String, String> {
pub fn to_string<'a, T: YaSerialize<'a>>(model: &T) -> Result<String, String> {
let buf = Cursor::new(Vec::new());
let cursor = serialize_with_writer(model, buf, &Config::default())?;
let data = str::from_utf8(cursor.get_ref()).expect("Found invalid UTF-8");
Ok(String::from(data))
}
pub fn to_string_with_config<T: YaSerialize>(model: &T, config: &Config) -> Result<String, String> {
pub fn to_string_with_config<'a, T: YaSerialize<'a>>(
model: &T,
config: &Config,
) -> Result<String, String> {
let buf = Cursor::new(Vec::new());
let cursor = serialize_with_writer(model, buf, config)?;
let data = str::from_utf8(cursor.get_ref()).expect("Found invalid UTF-8");
Ok(String::from(data))
}
pub fn serialize_with_writer<W: Write, T: YaSerialize>(
pub fn serialize_with_writer<'a, W: Write, T: YaSerialize<'a>>(
model: &T,
writer: W,
_config: &Config,
@ -33,14 +36,14 @@ pub fn serialize_with_writer<W: Write, T: YaSerialize>(
}
}
pub fn to_string_content<T: YaSerialize>(model: &T) -> Result<String, String> {
pub fn to_string_content<'a, T: YaSerialize<'a>>(model: &T) -> Result<String, String> {
let buf = Cursor::new(Vec::new());
let cursor = serialize_with_writer_content(model, buf)?;
let data = str::from_utf8(cursor.get_ref()).expect("Found invalid UTF-8");
Ok(String::from(data))
}
pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(
pub fn serialize_with_writer_content<'a, W: Write, T: YaSerialize<'a>>(
model: &T,
writer: W,
) -> Result<W, String> {

40
yaserde/tests/flatten.rs
View File

@ -144,3 +144,43 @@ fn root_flatten_enum() {
let content = "<Data><string_data>string</string_data></Data>";
serialize_and_validate!(model, content);
}
#[test]
fn flatten_attribute() {
#[derive(Default, PartialEq, Debug, YaDeserialize, YaSerialize)]
struct HtmlText {
#[yaserde(flatten)]
text_attributes: TextAttributes,
#[yaserde(attribute)]
display: String,
}
#[derive(Default, PartialEq, Debug, YaDeserialize, YaSerialize)]
struct TextAttributes {
#[yaserde(attribute)]
bold: bool,
#[yaserde(flatten)]
font: FontAttributes,
}
#[derive(Default, PartialEq, Debug, YaDeserialize, YaSerialize)]
#[yaserde(namespace = "ns: http://www.sample.com/ns/domain")]
pub struct FontAttributes {
#[yaserde(attribute, prefix = "ns")]
size: u32,
}
let model = HtmlText {
text_attributes: TextAttributes {
bold: true,
font: FontAttributes { size: 24 },
},
display: "block".to_string(),
};
let content = r#"
<HtmlText xmlns:ns="http://www.sample.com/ns/domain" display="block" bold="true" ns:size="24" />"#;
serialize_and_validate!(model, content);
deserialize_and_validate!(content, model, HtmlText);
}

16
yaserde/tests/serializer.rs
View File

@ -293,7 +293,7 @@ fn ser_custom() {
value: i32,
}
impl YaSerialize for Day {
impl<'a> YaSerialize<'a> for Day {
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
let _ret = writer.write(xml::writer::XmlEvent::start_element("DoubleDay"));
let _ret = writer.write(xml::writer::XmlEvent::characters(
@ -302,6 +302,20 @@ fn ser_custom() {
let _ret = writer.write(xml::writer::XmlEvent::end_element());
Ok(())
}
fn serialize_attributes(
&self,
attributes: Vec<xml::attribute::OwnedAttribute>,
namespace: xml::namespace::Namespace,
) -> Result<
(
Vec<xml::attribute::OwnedAttribute>,
xml::namespace::Namespace,
),
String,
> {
Ok((attributes, namespace))
}
}
let model = Date {

4
yaserde_derive/src/ser/expand_enum.rs
View File

@ -1,5 +1,5 @@
use crate::common::{Field, YaSerdeAttribute, YaSerdeField};
use crate::ser::{implement_deserializer::implement_deserializer, label::build_label_name};
use crate::ser::{implement_serializer::implement_serializer, label::build_label_name};
use proc_macro2::TokenStream;
use syn::DataEnum;
use syn::Fields;
@ -13,7 +13,7 @@ pub fn serialize(
) -> TokenStream {
let inner_enum_inspector = inner_enum_inspector(data_enum, name, root_attributes);
implement_deserializer(
implement_serializer(
name,
root,
root_attributes,

54
yaserde_derive/src/ser/expand_struct.rs
View File

@ -1,6 +1,6 @@
use crate::common::{Field, YaSerdeAttribute, YaSerdeField};
use crate::ser::{element::*, implement_deserializer::implement_deserializer};
use crate::ser::{element::*, implement_serializer::implement_serializer};
use proc_macro2::TokenStream;
use syn::DataStruct;
use syn::Ident;
@ -11,13 +11,15 @@ pub fn serialize(
root: &str,
root_attributes: &YaSerdeAttribute,
) -> TokenStream {
let build_attributes: TokenStream = data_struct
let append_attributes: TokenStream = data_struct
.fields
.iter()
.map(|field| YaSerdeField::new(field.clone()))
.filter(|field| field.is_attribute())
.filter(|field| field.is_attribute() || field.is_flatten())
.map(|field| {
let label = field.label();
if field.is_attribute() {
let label_name = field.renamed_label(root_attributes);
match field.get_type() {
@ -32,14 +34,14 @@ pub fn serialize(
| Field::FieldI64
| Field::FieldU64
| Field::FieldF32
| Field::FieldF64 => Some(field.ser_wrap_default_attribute(
| Field::FieldF64 => field.ser_wrap_default_attribute(
Some(quote!(self.#label.to_string())),
quote!({
struct_start_event.attr(#label_name, &yaserde_inner)
}),
)),
),
Field::FieldOption { data_type } => match *data_type {
Field::FieldString => Some(field.ser_wrap_default_attribute(
Field::FieldString => field.ser_wrap_default_attribute(
None,
quote!({
if let Some(ref value) = self.#label {
@ -48,7 +50,7 @@ pub fn serialize(
struct_start_event
}
}),
)),
),
Field::FieldBool
| Field::FieldI8
| Field::FieldU8
@ -59,7 +61,7 @@ pub fn serialize(
| Field::FieldI64
| Field::FieldU64
| Field::FieldF32
| Field::FieldF64 => Some(field.ser_wrap_default_attribute(
| Field::FieldF64 => field.ser_wrap_default_attribute(
Some(quote!(self.#label.map_or_else(|| String::new(), |v| v.to_string()))),
quote!({
if let Some(ref value) = self.#label {
@ -68,12 +70,12 @@ pub fn serialize(
struct_start_event
}
}),
)),
),
Field::FieldVec { .. } => {
let item_ident = Ident::new("yaserde_item", field.get_span());
let inner = enclose_formatted_characters(&item_ident, label_name);
Some(field.ser_wrap_default_attribute(
field.ser_wrap_default_attribute(
None,
quote!({
if let Some(ref yaserde_list) = self.#label {
@ -82,9 +84,9 @@ pub fn serialize(
}
}
}),
))
)
}
Field::FieldStruct { .. } => Some(field.ser_wrap_default_attribute(
Field::FieldStruct { .. } => field.ser_wrap_default_attribute(
Some(quote!(self.#label
.as_ref()
.map_or_else(|| Ok(String::new()), |v| yaserde::ser::to_string_content(v))?)),
@ -95,19 +97,33 @@ pub fn serialize(
struct_start_event
}
}),
)),
),
Field::FieldOption { .. } => unimplemented!(),
},
Field::FieldStruct { .. } => Some(field.ser_wrap_default_attribute(
Field::FieldStruct { .. } => field.ser_wrap_default_attribute(
Some(quote!(yaserde::ser::to_string_content(&self.#label)?)),
quote!({
struct_start_event.attr(#label_name, &yaserde_inner)
}),
)),
Field::FieldVec { .. } => None,
),
Field::FieldVec { .. } => {
// TODO
quote!()
}
}
} else {
match field.get_type() {
Field::FieldStruct { .. } => {
quote!(
let (attributes, namespace) = self.#label.serialize_attributes(vec![], xml::namespace::Namespace::empty())?;
child_attributes_namespace.extend(&namespace);
child_attributes.extend(attributes);
)
}
_ => quote!()
}
}
})
.filter_map(|x| x)
.collect();
let struct_inspector: TokenStream = data_struct
@ -267,11 +283,11 @@ pub fn serialize(
.filter_map(|x| x)
.collect();
implement_deserializer(
implement_serializer(
name,
root,
root_attributes,
build_attributes,
append_attributes,
struct_inspector,
)
}

43
yaserde_derive/src/ser/implement_deserializer.rs
View File

@ -1,43 +0,0 @@
use crate::common::YaSerdeAttribute;
use crate::ser::namespace::generate_namespaces_definition;
use proc_macro2::Ident;
use proc_macro2::TokenStream;
pub fn implement_deserializer(
name: &Ident,
root: &str,
attributes: &YaSerdeAttribute,
attributes_inspector: TokenStream,
inner_inspector: TokenStream,
) -> TokenStream {
let namespaces_definition = generate_namespaces_definition(attributes);
let flatten = attributes.flatten;
quote! {
use xml::writer::XmlEvent;
impl YaSerialize for #name {
#[allow(unused_variables)]
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
-> Result<(), String> {
let skip = writer.skip_start_end();
if !#flatten && !skip {
let yaserde_label = writer.get_start_event_name().unwrap_or_else(|| #root.to_string());
let struct_start_event = XmlEvent::start_element(yaserde_label.as_ref())#namespaces_definition;
#attributes_inspector
writer.write(struct_start_event).map_err(|e| e.to_string())?;
}
#inner_inspector
if !#flatten && !skip {
let struct_end_event = XmlEvent::end_element();
writer.write(struct_end_event).map_err(|e| e.to_string())?;
}
Ok(())
}
}
}
}

87
yaserde_derive/src/ser/implement_serializer.rs Normal file
View File

@ -0,0 +1,87 @@
use crate::common::YaSerdeAttribute;
use crate::ser::namespace::generate_namespaces_definition;
use proc_macro2::Ident;
use proc_macro2::TokenStream;
pub fn implement_serializer(
name: &Ident,
root: &str,
attributes: &YaSerdeAttribute,
append_attributes: TokenStream,
inner_inspector: TokenStream,
) -> TokenStream {
let namespaces_definition = generate_namespaces_definition(attributes);
let flatten = attributes.flatten;
quote! {
use xml::writer::XmlEvent;
impl<'a> YaSerialize<'a> for #name {
#[allow(unused_variables)]
fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
-> Result<(), String> {
let skip = writer.skip_start_end();
if !#flatten && !skip {
let mut child_attributes = vec![];
let mut child_attributes_namespace = xml::namespace::Namespace::empty();
let yaserde_label = writer.get_start_event_name().unwrap_or_else(|| #root.to_string());
let struct_start_event = XmlEvent::start_element(yaserde_label.as_ref())#namespaces_definition;
#append_attributes
let event : xml::writer::events::XmlEvent = struct_start_event.into();
if let xml::writer::events::XmlEvent::StartElement{name, attributes, namespace} = event {
let mut attributes: Vec<xml::attribute::OwnedAttribute> = attributes.into_owned().to_vec().iter().map(|k| k.to_owned()).collect();
attributes.extend(child_attributes);
let all_attributes = attributes.iter().map(|ca| ca.borrow()).collect();
let mut all_namespaces = namespace.into_owned();
all_namespaces.extend(&child_attributes_namespace);
writer.write(xml::writer::events::XmlEvent::StartElement{
name,
attributes: std::borrow::Cow::Owned(all_attributes),
namespace: std::borrow::Cow::Owned(all_namespaces)
}).map_err(|e| e.to_string())?;
} else {
unreachable!()
}
}
#inner_inspector
if !#flatten && !skip {
let struct_end_event = XmlEvent::end_element();
writer.write(struct_end_event).map_err(|e| e.to_string())?;
}
Ok(())
}
fn serialize_attributes(&self, mut source_attributes: Vec<xml::attribute::OwnedAttribute>, mut source_namespace: xml::namespace::Namespace) -> Result<(Vec<xml::attribute::OwnedAttribute>, xml::namespace::Namespace), String> {
let mut child_attributes : Vec<xml::attribute::OwnedAttribute> = vec![];
let mut child_attributes_namespace = xml::namespace::Namespace::empty();
let struct_start_event = XmlEvent::start_element("temporary_element_to_generate_attributes")#namespaces_definition;
#append_attributes
let event : xml::writer::events::XmlEvent = struct_start_event.into();
if let xml::writer::events::XmlEvent::StartElement{attributes, namespace, ..} = event {
source_namespace.extend(&namespace.into_owned());
source_namespace.extend(&child_attributes_namespace);
let a: Vec<xml::attribute::OwnedAttribute> = attributes.into_owned().to_vec().iter().map(|k| k.to_owned()).collect();
source_attributes.extend(a);
source_attributes.extend(child_attributes);
Ok((source_attributes, source_namespace))
} else {
unreachable!();
}
}
}
}
}

2
yaserde_derive/src/ser/mod.rs
View File

@ -1,7 +1,7 @@
pub mod element;
pub mod expand_enum;
pub mod expand_struct;
pub mod implement_deserializer;
pub mod implement_serializer;
pub mod label;
pub mod namespace;