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

refactoring code to better support

Browse Source
This commit is contained in:
Marc-Antoine Arnaud
2018-05-13 09:51:28 +02:00
parent 6adbd71ebb
commit 0540b127bd
14 changed files with 782 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
yaserde/Cargo.toml
View File

@@ -14,6 +14,7 @@ readme = "../README.md"
yaserde_derive = { version = "0.1", path = "../yaserde_derive", optional = true }
regex = "0.2"
xml-rs = "0.7.0"
log = "0.4.1"
[dev-dependencies]
yaserde_derive = { version = "0.1", path = "../yaserde_derive" }

150
yaserde/src/de/mod.rs Normal file
View File

@@ -0,0 +1,150 @@
use std::io::Read;
use xml::reader::{EventReader, ParserConfig, XmlEvent};
use xml::name::OwnedName;
use YaDeserialize;
pub fn from_str<T: YaDeserialize>(s: &str) -> Result<T, String> {
from_reader(s.as_bytes())
}
pub fn from_reader<R: Read, T: YaDeserialize>(reader: R) -> Result<T, String> {
T::deserialize(&mut Deserializer::new_from_reader(reader))
}
pub struct Deserializer<R: Read> {
depth: usize,
reader: EventReader<R>,
peeked: Option<XmlEvent>,
is_map_value: bool,
}
impl<'de, R: Read> Deserializer<R> {
pub fn new(reader: EventReader<R>) -> Self {
Deserializer {
depth: 0,
reader: reader,
peeked: None,
is_map_value: false,
}
}
pub fn new_from_reader(reader: R) -> Self {
let config = ParserConfig::new()
.trim_whitespace(true)
.whitespace_to_characters(true)
.cdata_to_characters(true)
.ignore_comments(true)
.coalesce_characters(true);
Self::new(EventReader::new_with_config(reader, config))
}
pub fn peek(&mut self) -> Result<&XmlEvent, String> {
if self.peeked.is_none() {
self.peeked = Some(self.inner_next()?);
}
if let Some(ref next) = self.peeked {
Ok(&next)
} else {
Err(String::from("unable to peek next item"))
}
}
pub fn inner_next(&mut self) -> Result<XmlEvent, String> {
loop {
if let Ok(next) = self.reader.next() {
match next {
XmlEvent::StartDocument { .. } |
XmlEvent::ProcessingInstruction { .. } |
XmlEvent::Comment(_) => { /* skip */ },
other => return Ok(other),
}
} else {
println!("{:?}", self.peeked);
return Err(String::from("bad content"));
}
}
}
pub fn next(&mut self) -> Result<XmlEvent, String> {
let next = if let Some(peeked) = self.peeked.take() {
peeked
} else {
self.inner_next()?
};
match next {
XmlEvent::StartElement { .. } => {
self.depth += 1;
},
XmlEvent::EndElement { .. } => {
self.depth -= 1;
},
_ => {},
}
debug!("Fetched {:?}", next);
Ok(next)
}
pub fn set_map_value(&mut self) {
self.is_map_value = true;
}
pub fn unset_map_value(&mut self) -> bool {
::std::mem::replace(&mut self.is_map_value, false)
}
pub fn read_inner_value<T, F: FnOnce(&mut Self) -> Result<T, String>>(
&mut self,
f: F,
) -> Result<T, String> {
if self.unset_map_value() {
if let Ok(XmlEvent::StartElement { name, .. }) = self.next() {
let result = f(self)?;
self.expect_end_element(name)?;
Ok(result)
} else {
Err(format!("Internal error: Bad Event"))
}
} else {
f(self)
}
}
pub fn expect_end_element(&mut self, start_name: OwnedName) -> Result<(), String> {
if let XmlEvent::EndElement{ name, .. } = self.next()? {
if name == start_name {
Ok(())
} else {
Err(format!(
"End tag </{}> didn't match the start tag <{}>",
name.local_name,
start_name.local_name
))
}
} else {
Err(String::from(format!(
"Unexpected token </{}>",
start_name.local_name
)))
}
}
// fn prepare_parse_type<V: de::Visitor<'de>>(&mut self) -> Result<String> {
// if let XmlEvent::StartElement { .. } = *self.peek()? {
// self.set_map_value()
// }
// self.read_inner_value::<V, String, _>(|this| {
// if let XmlEvent::EndElement { .. } = *this.peek()? {
// return Err(
// ErrorKind::UnexpectedToken("EndElement".into(), "Characters".into()).into(),
// );
// }
// expect!(this.next()?, XmlEvent::Characters(s) => {
// return Ok(s)
// })
// })
// }
}

28
yaserde/src/lib.rs
View File

@@ -1,4 +1,6 @@
#[macro_use]
extern crate log;
extern crate xml;
#[cfg(feature = "yaserde_derive")]
#[allow(unused_imports)]
@@ -6,13 +8,31 @@ extern crate xml;
extern crate yaserde_derive;
use std::io::{Read, Write};
use xml::{EventReader, EventWriter};
use xml::attribute::OwnedAttribute;
pub mod de;
pub mod ser;
pub trait YaDeserialize : Sized {
fn derive_deserialize<R: Read>(read: &mut EventReader<R>, parent_attributes: Option<&Vec<OwnedAttribute>>) -> Result<Self, String>;
fn deserialize<R: Read>(reader: &mut de::Deserializer<R>) -> Result<Self, String>;
}
pub trait YaSerialize : Sized {
fn derive_serialize<W: Write>(&self, read: &mut EventWriter<W>, skip_start_end: bool) -> Result<(), String>;
fn serialize<W: Write>(&self, writer: &mut ser::Serializer<W>) -> Result<(), String>;
}
pub trait Visitor<'de>: Sized {
/// The value produced by this visitor.
type Value;
fn visit_str(self, v: &str) -> Result<Self::Value, String>
{
Err(format!("Unexpected str {}", v))
}
#[inline]
#[cfg(any(feature = "std", feature = "alloc"))]
fn visit_string<String>(self, v: String) -> Result<Self::Value, String>
{
self.visit_str(&v)
}
}

83
yaserde/src/ser/mod.rs Normal file
View File

@@ -0,0 +1,83 @@
use std::str;
use std::io::{Cursor, Write};
use xml::{EmitterConfig, EventWriter};
use xml;
use xml::writer::XmlEvent;
use YaSerialize;
pub fn to_string<T: YaSerialize>(model: &T) -> Result<String, String> {
let buf = Cursor::new(Vec::new());
let cursor = serialize_with_writer(model, buf).unwrap();
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>(model: &T, writer: W) -> Result<W, String> {
let mut serializer = Serializer::new_from_writer(writer);
match model.serialize(&mut serializer) {
Ok(()) => Ok(serializer.into_inner()),
Err(msg) => Err(msg),
}
}
pub fn to_string_content<T: YaSerialize>(model: &T) -> Result<String, String> {
let buf = Cursor::new(Vec::new());
let cursor = serialize_with_writer_content(model, buf).unwrap();
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>(model: &T, writer: W) -> Result<W, String> {
let mut serializer = Serializer::new_for_inner(writer);
serializer.set_skip_start_end(true);
match model.serialize(&mut serializer) {
Ok(()) => Ok(serializer.into_inner()),
Err(msg) => Err(msg),
}
}
pub struct Serializer<W: Write> {
writer: EventWriter<W>,
skip_start_end: bool
}
impl<'de, W: Write> Serializer<W> {
pub fn new(writer: EventWriter<W>) -> Self {
Serializer {
writer: writer,
skip_start_end: false
}
}
pub fn new_from_writer(writer: W) -> Self {
let config = EmitterConfig::new()
.cdata_to_characters(true);
Self::new(EventWriter::new_with_config(writer, config))
}
pub fn new_for_inner(writer: W) -> Self {
let config = EmitterConfig::new()
.write_document_declaration(false);
Self::new(EventWriter::new_with_config(writer, config))
}
pub fn into_inner(self) -> W {
self.writer.into_inner()
}
pub fn skip_start_end(&self) -> bool {
self.skip_start_end
}
pub fn set_skip_start_end(&mut self, state: bool) {
self.skip_start_end = state;
}
pub fn write<'a, E>(&mut self, event: E) -> xml::writer::Result<()>
where E: Into<XmlEvent<'a>> {
self.writer.write(event)
}
}

140
yaserde/tests/deserializer.rs
View File

@@ -3,16 +3,16 @@ extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::io::Read;
use xml::reader::EventReader;
use yaserde::YaDeserialize;
use yaserde::de::from_str;
macro_rules! convert_and_validate {
($content:expr, $struct:tt, $model:expr) => {
let mut parser = EventReader::from_str($content);
let loaded = $struct::derive_deserialize(&mut parser, None);
let loaded : Result<$struct, String> = from_str($content);
assert_eq!(loaded, Ok($model));
}
}
@@ -20,54 +20,59 @@ macro_rules! convert_and_validate {
#[test]
fn de_basic() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct XmlStruct {
item: String
#[yaserde(root="book")]
pub struct Book {
author: String,
title: String,
}
let content = "<base><item>something</item></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
item: "something".to_string()
let content = "<book><author>Antoine de Saint-Exupéry</author><title>Little prince</title></book>";
convert_and_validate!(content, Book, Book{
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince")
});
let content = "<book><title>Little prince</title><author>Antoine de Saint-Exupéry</author></book>";
convert_and_validate!(content, Book, Book{
author: String::from("Antoine de Saint-Exupéry"),
title: String::from("Little prince")
});
}
#[test]
fn de_list_of_items() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct XmlStruct {
items: Vec<String>
#[yaserde(root="library")]
pub struct Library {
books: Vec<String>
}
let content = "<base><items>something1</items><items>something2</items></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
items: vec![
"something1".to_string(),
"something2".to_string()
let content = "<library><books>Little Prince</books><books>Harry Potter</books></library>";
convert_and_validate!(content, Library, Library{
books: vec![
String::from("Little Prince"),
String::from("Harry Potter")
]
});
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct XmlStructOfStruct {
items: Vec<SubStruct>
#[yaserde(root="libraries")]
pub struct Libraries {
library: Vec<Library>
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="items")]
pub struct SubStruct {
field: String
}
let content = "<base><items><field>something1</field></items><items><field>something2</field></items></base>";
convert_and_validate!(content, XmlStructOfStruct, XmlStructOfStruct{
items: vec![
SubStruct{
field: "something1".to_string()
let content = "<libraries><library><books>Little Prince</books></library><library><books>Harry Potter</books></library></libraries>";
convert_and_validate!(content, Libraries, Libraries{
library: vec![
Library{
books: vec![
String::from("Little Prince")
]
},
SubStruct{
field: "something2".to_string()
Library{
books: vec![
String::from("Harry Potter")
]
}
]
});
@@ -189,6 +194,12 @@ fn de_enum() {
background: Color
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct Colors {
items: Vec<Color>
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="color")]
pub enum Color {
@@ -219,20 +230,59 @@ fn de_enum() {
}
}
#[derive(YaDeserialize, PartialEq, Debug)]
pub enum Alpha {
Transparent,
Opaque,
}
// #[derive(YaDeserialize, PartialEq, Debug)]
// pub enum Alpha {
// Transparent,
// Opaque,
// }
impl Default for Alpha {
fn default() -> Alpha {
Alpha::Transparent
}
}
// impl Default for Alpha {
// fn default() -> Alpha {
// Alpha::Transparent
// }
// }
// let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
// convert_and_validate!(content, XmlStruct, XmlStruct{
// background: Color::Black
// });
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
convert_and_validate!(content, XmlStruct, XmlStruct{
background: Color::Black
});
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>Black</items><items>White</items></base>";
convert_and_validate!(content, Colors, Colors{
items: vec![Color::Black, Color::White]
});
}
#[test]
fn de_attribute_enum() {
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct XmlStruct {
#[yaserde(attribute)]
background: Color
}
#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(root="color")]
pub enum Color {
White,
Black,
}
impl Default for Color {
fn default() -> Color {
Color::White
}
}
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base background=\"Black\" />";
convert_and_validate!(content, XmlStruct, XmlStruct{
background: Color::Black
});
}

46
yaserde/tests/serializer.rs
View File

@@ -3,24 +3,17 @@ extern crate yaserde;
#[macro_use]
extern crate yaserde_derive;
extern crate xml;
#[macro_use]
extern crate log;
use std::str;
use std::io::Cursor;
use std::io::Write;
use xml::writer::EventWriter;
use yaserde::YaSerialize;
use yaserde::ser::to_string;
macro_rules! convert_and_validate {
($model:expr, $content:expr) => (
let mut buf = Cursor::new(Vec::new());
let mut writer = EventWriter::new(&mut buf);
let _status = $model.derive_serialize(&mut writer, false);
let buffer = writer.into_inner();
let cursor = buffer.get_ref();
let data = str::from_utf8(cursor).expect("Found invalid UTF-8");
assert_eq!(data, $content);
let data : Result<String, String> = to_string(&$model);
assert_eq!(data, Ok(String::from($content)));
)
}
@@ -36,7 +29,7 @@ fn ser_basic() {
item: "something".to_string()
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><item>something</item></base>".to_string();
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><item>something</item></base>";
convert_and_validate!(model, content);
}
@@ -55,7 +48,7 @@ fn ser_list_of_items() {
]
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>something1</items><items>something2</items></base>".to_string();
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>something1</items><items>something2</items></base>";
convert_and_validate!(model, content);
@@ -265,3 +258,28 @@ fn ser_enum() {
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><color><custom><enabled>true</enabled><color><red>0</red><green>128</green><blue>255</blue></color><alpha>Opaque</alpha><alphas>Opaque</alphas><alphas>Transparent</alphas></custom></color></base>";
convert_and_validate!(model, content);
}
#[test]
fn ser_attribute_enum() {
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="base")]
pub struct XmlStruct {
#[yaserde(attribute)]
color: Color
}
#[derive(YaSerialize, PartialEq, Debug)]
#[yaserde(root="color")]
pub enum Color {
#[yaserde(rename="pink")]
Pink,
}
let model = XmlStruct{
color: Color::Pink
};
let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base color=\"pink\" />";
convert_and_validate!(model, content);
}