Hello,

I have an xml compatible file, however, it does not use the namespace associations in all scopes. Is it possible to still retain the namespace value, but not associate the namespace with a struct?

For example: I have this file (will skip for brevity)

<MPD mediaPresentationDuration="PT1H50M47S" minBufferTime="PT19S" profiles="urn:mpeg:dash:profile:isoff-live:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
<!-- skip for brevity ... -->
</MPD>

the xmlns="urn:mpeg:dash:schema:mpd:2011" is signaled within the library, and appropriately asked to be used. However, I would like to not have such association, if possible. At the moment, I'm signaling the struct with

#[yaserde(root="MPD", prefix="mpd", namespace="mpd: urn:mpeg:dash:schema:mpd:2011")]

and all the underlying associated structs.

I then get the following output

<mpd:MPD xmlns:mpd="urn:mpeg:dash:schema:mpd:2011" mediaPresentationDuration="PT1H50M47S" minBufferTime="PT19S" profiles="urn:mpeg:dash:profile:isoff-live:2011" type="static"><ProgramInformation moreInformationURL="www.castLabs.com" />
<!-- skip for brevity ... -->
</mpd:MPD>

I'd, however, and, if possible, to have the same output as original. The reason for such, is that I sometimes get a file where I need to only modify one element without changing anything else. To avoid any inconsistancies or structural changes, I'd like to output the same as original only with changed value.

Additionally, is it possible to signal retention of attribute positioning in the order they were originally in? At the moment, the attributes appear to serialize in an unordered fashion.

(De)serialization of this type is not implemented yet:

struct Test {
    Empty,
    Full(String)
}

An XML (de)serialization library could really make a difference in Rust. There are only a few languages that have good ADT support. But in XML they are common, e.g. xsd:choice.

I'm getting an error

for the following:

#[derive(Default, Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
#[yaserde(root = "layout")]
pub struct Layout {
	#[yaserde(attribute)]
	pub version: u32,
	#[yaserde(attribute)]
	pub mode: u32,
	#[yaserde(attribute)]
	pub w: u32,
	#[yaserde(attribute)]
	pub h: u32,
	#[yaserde(attribute)]
	pub orientation: Orientation,
	pub tabpage: Tabpage,
}

#[derive(Default, Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
pub struct Tabpage {
	#[yaserde(attribute)]
	pub name: String,
	#[yaserde(attribute)]
	pub scalef: f32,
	#[yaserde(attribute)]
	pub scalet: f32,
	#[yaserde(attribute)]
	pub li_t: String,
	#[yaserde(attribute)]
	pub li_c: String,
	#[yaserde(attribute)]
	pub li_s: String,
	#[yaserde(attribute)]
	pub li_o: String,
	#[yaserde(attribute)]
	pub li_b: String,
	#[yaserde(attribute)]
	pub la_t: String,
	#[yaserde(attribute)]
	pub la_c: String,
	#[yaserde(attribute)]
	pub la_s: String,
	#[yaserde(attribute)]
	pub la_o: String,
	#[yaserde(attribute)]
	pub la_b: String,
	pub control: Vec<Control>,
}

#[derive(Default, Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
pub struct Control {
	#[yaserde(attribute)]
	pub name: String,
	#[yaserde(attribute)]
	pub x: u32,
	#[yaserde(attribute)]
	pub y: u32,
	#[yaserde(attribute)]
	pub w: u32,
	#[yaserde(attribute)]
	pub h: u32,
	#[yaserde(attribute)]
	pub color: String,
	#[yaserde(attribute)]
	pub scalef: f32,
	#[yaserde(attribute)]
	pub scalet: f32,
	#[yaserde(attribute)]
	pub local_off: Option<bool>,
	#[yaserde(attribute)]
	pub sp: Option<String>,
	#[yaserde(attribute)]
	pub sr: Option<String>,
	pub midi: Option<Midi>,
	#[yaserde(attribute)]
	pub response: Option<Response>,
	#[yaserde(attribute)]
	pub inverted: Option<bool>,
	#[yaserde(attribute)]
	pub centered: Option<bool>,
	#[yaserde(attribute)]
	pub norollover: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
pub enum Response { absolute, relative }

#[derive(Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
pub enum Orientation { vertical, horizontal }

#[derive(Default, Debug, Clone, PartialEq, YaSerialize, YaDeserialize)]
pub struct Midi {
	#[yaserde(attribute)]
	pub var: String,
	#[yaserde(attribute)]
	#[yaserde(rename = "type")]
	pub typ: String,
	#[yaserde(attribute)]
	pub channel: u8,
	#[yaserde(attribute)]
	pub data1: u8,
	#[yaserde(attribute)]
	pub data2f: u8,
	#[yaserde(attribute)]
	pub data2t: u8,
	#[yaserde(attribute)]
	pub sysex: String,
}

wrong number of type arguments: expected 1, found 0 expected 1 type argument

Btw, my goal is to serialize xml docs in this format:

<?xml version="1.0" encoding="UTF-8"?>
<layout version="16" mode="3" w="460" h="736" orientation="vertical">
    <tabpage name="MQ==" scalef="0.0" scalet="1.0" li_t="" li_c="gray" li_s="14" li_o="false" li_b="false" la_t="" la_c="gray" la_s="14" la_o="false" la_b="false">
        <control name="cHVzaDI1" x="114" y="680" w="45" h="45" color="red" scalef="0.0" scalet="1.0" type="push" local_off="false" sp="true" sr="true">
            <midi var="x" type="1" channel="1" data1="25" data2f="0" data2t="127" sysex="" />
        </control>
        <control name="cm90YXJ5MA==" x="14" y="569" w="100" h="100" color="red" scalef="0.0" scalet="1.0" type="rotaryh" response="absolute" inverted="false" centered="false" norollover="true">
            <midi var="x" type="0" channel="1" data1="0" data2f="0" data2t="127" sysex="" />
        </control>
        <control name="ZmFkZXIz" x="0" y="151" w="120" h="40" color="blue" scalef="0.0" scalet="1.0" type="faderh" response="relative" inverted="false" centered="false" />
    </tabpage>
</layout>

How can I do this with yaserde? :)

I have an XML "schema" (extremely ad-hoc, which I did not design) that can be one of two things:

<body>
  <usefulData />
</body>

or:

<Extension version="1.1">
  <binaryData>1</binaryData>
</Extension>

I need to be able to deserialize either one of these, and I don't know which one will arrive from the network connection. So, I wrote an enum:

#[derive(PartialEq, Eq, Debug, YaDeserialize)]
pub(super) enum AllTopXmls {
    #[yaserde(rename="body")]
    Body(Body),
    Extension(Extension),
}

// Required for YaDeserialize
impl Default for AllTopXmls {
    fn default() -> Self {
        AllTopXmls::BcXml(Default::default())
    }
}

struct Body { /* ... */ }

#[derive(PartialEq, Eq, Default, Debug, YaDeserialize)]
pub struct Extension {
    #[yaserde(rename="binaryData")]
    pub binary_data: u32,
}

Unfortunately, deserializing this does not work:

[DEBUG bc::xml] Enum: start to parse "Extension"
[DEBUG bc::xml] Struct: start to parse "Extension"
[DEBUG yaserde::de] Fetched StartElement(Extension, {"": "", "xml": "http://www.w3.org/XML/1998/namespace", "xmlns": "http://www.w3.org/2000/xmlns/"}, [version -> 1.1])
[DEBUG yaserde::de] Fetched StartElement(binaryData, {"": "", "xml": "http://www.w3.org/XML/1998/namespace", "xmlns": "http://www.w3.org/2000/xmlns/"})
[DEBUG yaserde::de] Fetched Characters(1)
[DEBUG yaserde::de] Fetched EndElement(binaryData)
[DEBUG yaserde::de] Fetched EndElement(Extension)
thread 'bc::xml::test_binary_deser' panicked at 'called `Result::unwrap()` on an `Err` value: "unknown event EndDocument"', src/bc/xml.rs:258:13

Invoking the deserializer on Body or Extension explicitly works fine. But I want yaserde to choose.

Thank you very much for this library. It is the only serde-like library that knows how to correctly serialize nested structs and it saved my sanity.

Sorry for the issue name :) please see the example

Input:

<DOMSymbolItem name="dagger" last_modified="1414141442">
  <timeline>
    <DOMTimeline name="dagger timeline name" current_frame="7" guides="11">
      <layers>
        <DOMLayer name="Layer 2" name2="Lalayer 2">
        </DOMLayer>
        <DOMLayer name="Layer 1" name2="Lalayer 1">
        </DOMLayer>
      </layers>
    </DOMTimeline>
  </timeline>
</DOMSymbolItem>

Structs:

#[derive(YaDeserialize, Debug)]
struct Level {
    #[yaserde(attribute)]
    last_modified: u64,
    #[yaserde(attribute, rename = "name")]
    named: String,
    timeline: DOMTimeline,
}

#[derive(YaDeserialize, Debug, Default)]
struct DOMTimeline {
    #[yaserde(attribute, rename = "name")]
    named: String,
    #[yaserde(attribute)]
    name2: String,
    #[yaserde(attribute)]
    current_frame: String,
    #[yaserde(attribute)]
    guides: String,
}

Output:

Level {
    last_modified: 1414141442,
    named: "dagger",
    timeline: DOMTimeline {
        named: "Layer 1",
        name2: "Lalayer 1",
        current_frame: "7",
        guides: "11"
    }
}

Hello,

I've various attributes and structs that are optionally present based on the context. I see that "skip_serializing_if" is not checked as supported. Before I consider rewriting my codebase to use your code, would you be kind to let me know if "skip_serializing_if" is supported?

Highest Regards, Max

I need to parse the following

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root xmlns="http://www.w3c.org/abc" date="2020">
  <buecher>
    <buch id="123">
      <iban>123</iban>
    </buch>
    <buch id="456">
      <iban>456</iban>
    </buch>
  </buecher>
</root>

but i get the error "bad namespace for iban, found http://www.w3c.org/abc"

extern crate yaserde;

#[macro_use]
extern crate yaserde_derive;

use std::io::Read;
use yaserde::YaDeserialize;

use std::fs::File;
use std::io::BufReader;

#[yaserde(
  prefix = "ns",
  namespace = "ns: http://www.w3c.org/abc"
)]
#[derive(Debug, YaDeserialize)]
struct Root {
  date: String,
  buecher: Option<Buecher>,
}

#[derive(Debug, YaDeserialize)]
struct Buecher {
  buch: Vec<Buch>,
}

#[derive(Debug, YaDeserialize)]
struct Buch {
  id: String,
  iban: String,
}

fn main() {
  let src_file = File::open("data/test.xml");
  if src_file.is_ok() {
    let _buf_reader = BufReader::new(src_file.unwrap());
    let _data: Root = yaserde::de::from_reader(_buf_reader).unwrap();
    println!("{:#?}", _data);
  }
}

also duplicating the yaserde definition to every struct does not help

Hey everybody. Compilation fails if I specify field name along with namespace. Without namespace std::string:: everything is fine.

use std::io::Read;
use yaserde::YaDeserialize;
use yaserde_derive::YaDeserialize;
use log::debug;

#[derive(YaDeserialize, Debug)]
struct MyRoot {
    my_field: std::string::String,
}

fn main() {
    let config: MyRoot = yaserde::de::from_str("").unwrap();
    println!("{:#?}", config);
}

Error message:

error[E0063]: missing field `my_field` in initializer of `MyRoot`
 --> src/main.rs:7:8
  |
7 | struct MyRoot {
  |        ^^^^^^ missing `my_field`

I'm using 1.37 stable with 2018 edition enabled, and I found I needed to add the xml-rs and log dependencies in order to fix some build issues. This may just be my own misunderstanding of how rust dependencies work.

[package]
name = "minimum-yaserde"
version = "0.1.0"
authors = ["Me"]
edition = "2018"

[dependencies]
yaserde = "0.3"
yaserde_derive = "0.3"

# I wouldn't expect to have to add these myself
xml-rs = ""
log = ""

Without adding xml-rs as a dependency:

src/main.rs|6 col 10 error 433| failed to resolve: could not find `xml` in `{{root}}`
||   |
|| 6 | #[derive(YaDeserialize, Debug)]
||   |          ^^^^^^^^^^^^^ could not find `xml` in `{{root}}`
src/main.rs|6 col 10 error 433| failed to resolve: use of undeclared type or module `XmlEvent`
||   |
|| 6 | #[derive(YaDeserialize, Debug)]
||   |          ^^^^^^^^^^^^^ use of undeclared type or module `XmlEvent`

Without adding log as a dependency:

src/main.rs|5 col 10 error| cannot find macro `debug!` in this scope
||   |
|| 5 | #[derive(YaDeserialize, Debug)]
||   |          ^^^^^^^^^^^^^

Support can be enable like this:

#[derive(YaDeserialize, PartialEq, Debug)]
#[yaserde(strict, root = "root")]
pub struct XmlStruct {
  expected_tag: String,
}

Enabling this will cause errors when:

• [x] The root tag has an unexpected name
• [x] Any unexpected tag appears in the xml
• [x] Any unexpected attribute appears in the xml
• [ ] An expected tag is missing in the xml (ignore default)
• [ ] An expected attribute is missing in the xml (ignore default)

Before that change skip_serializing_if won't work for struct fields that marked as attribute. I changed ser_wrap_default_attribute func and added test for that change.

I'm having some trouble trying to find the best way of deserializing the following XML. Inside TaskList the Task tags are the same but their inner children are different. Is there any way of parsing this in order to differentiate between 2 tasks based on their class attribute?

I was playing around with Enums and such but I don't see any way of doing this except implementing the deserialize method manually. Was trying to find a similar example in the examples folder but I don't see nothing like this.

Thanks in advance (I'm quite new to rust so I am sorry if this question seems silly)

<tasklist>
<task class="Aggregator" documentation="" name="Task Aggregator" taskkey="TaskAggregator" x="4000" y="640">
    <parameter name="Entity" type="Map">
        <parameter name="key" type="String">xxx</parameter>
        <parameter name="value" type="String">xxx</parameter>
    </parameter>
</task>
<task class="Transform" documentation="" name="Transform" taskkey="Transform" x="1440" y="560">
    <parameter name="Rules" type="Xml">
        <root advancedmode="false">\n    <set in="Flow" toValue="123" varType="String" variable="asd"></set>\n</root>
    </parameter>
</task>
</tasklist>

Updates the requirements on env_logger to permit the latest version.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

use yaserde_derive::YaSerialize;

#[derive(Default, YaSerialize)]
struct A
{
    #[yaserde(attribute)]
    val: u8
}
#[derive(Default, YaSerialize)]
struct B
{
    val: u8
}
#[derive(YaSerialize)]
enum MainNode
{
    A(A),
    B(B),
}

#[derive(Default, YaSerialize)]
struct Main
{
    #[yaserde(child, flatten)]
    m: Vec<MainNode>
}

fn sample() -> Main {
    Main {
        m: vec![
            MainNode::A(
                A{val: 1}
                ),
            MainNode::B(
                B{val: 2}
                )
        ]
    }
}
fn main()
{
    let node = sample();
    println!("{}", yaserde::ser::to_string(&node).unwrap());
}

#[cfg(test)]
mod tests {
    const XML: &str = r##"<?xml version="1.0" encoding="utf-8"?><Main><A val="1" /><B><val>2</val></B></Main>"##;
    use crate::sample;
    #[test]
    fn attribute() {
        let node = sample();
        let data = yaserde::ser::to_string(&node).unwrap();
        assert_eq!(data, XML);
    }
}

the A::val is not serialized from Main structure.

~I am baffled. I can run the examples crate tests just fine.~

~However, when I run this on my own code, deriving YaDeserialize fails because the constraint of T: YaDeserialize isn't met because T doesn't implement YaDeserialize.~

~This is for types like i32, String, etc.~

~I have looked through the code and I don't see anywhere where YaDeserialize is implemented for anything, so I have no idea how the examples crate works, where it has some fields which are String.~

*Edit*

I ran cargo-expand, and now understand how it avoids needing to impl YaDeserialize for primitive types. It bakes the from_str directly into the struct's deserialization routine (that seems like it'd cause a lot of unnecessary code duplication, but I guess that pertains to the RFC for the API redesign)

I guess my more fundamental question is:

How can I impl YaDeserialize for a custom type which I basically want to treat as a String it's a specially formatted Timestamp which will always serialize to a String-ish type, and always be parsed from a String-ish type. So it shouldn't have any properties, etc.

At the moment, I'm attempting to duplicate the impl for i32 and string members that I find.

However, I'm not sure how I can direct yaserde_derive::YaDeserialize to fetch the type correctly, since I basically want to treat it as a primitive.

Implements #144.

Not happy yet with how some of the error handling is taking place. Most notably optional structs are set to None if they do not parse successfully.

Secondly this change is a major move from the current semantics of the crate. There should be a discussion on whether this is acceptable at all, and how to communicate clearly to users that whilst their code may still compile, input data will be rejected unless #[yaserde(default)] is added here and there.

When deriving YaDeserialize the macro requires that all member types implement the Default trait. I suppose this is to instantiate a value even when the XML document is missing that child or attribute.

As a consumer of this crate I would have to either make all fields Option, or implement Default for all of them. However I would rather that YaDeserialize would throw an error if that child or attribute is missing from the XML, and have an attribute #[yaserde(default)] for the current behaviour.