mx20022-codegen 0.2.0

XSD-to-Rust code generator for ISO 20022 message types with constraint validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Emit [`EnumDef`] (choice types) as a Rust enum.

use proc_macro2::TokenStream;
use quote::quote;

use crate::ir::types::EnumDef;

use super::util::{make_ident, standard_derives, type_ref_tokens};

/// Emit a single [`EnumDef`] as a `pub enum` definition.
///
/// Each variant carries its inner type as a newtype-style tuple variant.
/// A `#[serde(rename = "XmlName")]` attribute is emitted for each variant
/// so that quick-xml can match the correct XML element name.
///
/// `#[allow(clippy::large_enum_variant)]` is emitted unconditionally because
/// ISO 20022 choice types often hold large structs; boxing the variants would
/// break the `quick-xml` serde mapping.
pub fn emit_enum(def: &EnumDef) -> TokenStream {
    let derives = standard_derives();
    let name = make_ident(&def.name);

    let variants: TokenStream = def
        .variants
        .iter()
        .map(|v| {
            let xml_name = &v.xml_name;
            let variant_name = make_ident(&v.rust_name);
            let inner_type = type_ref_tokens(&v.type_ref);
            quote! {
                #[serde(rename = #xml_name)]
                #variant_name(#inner_type),
            }
        })
        .collect();

    quote! {
        #[allow(clippy::large_enum_variant)]
        #derives
        pub enum #name {
            #variants
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ir::types::{EnumDef, RustType, TypeRef, VariantDef};

    fn variant(xml_name: &str, rust_name: &str, type_ref: TypeRef) -> VariantDef {
        VariantDef {
            xml_name: xml_name.to_owned(),
            rust_name: rust_name.to_owned(),
            type_ref,
        }
    }

    #[test]
    fn enum_named_variants() {
        let def = EnumDef {
            name: "AddressType3Choice".to_owned(),
            variants: vec![
                variant("Cd", "Cd", TypeRef::Named("AddressType2Code".to_owned())),
                variant(
                    "Prtry",
                    "Prtry",
                    TypeRef::Named("GenericIdentification30".to_owned()),
                ),
            ],
        };
        let ts = emit_enum(&def);
        let src = ts.to_string();
        assert!(src.contains("pub enum AddressType3Choice"), "src = {src}");
        assert!(src.contains("\"Cd\""), "src = {src}");
        assert!(src.contains("\"Prtry\""), "src = {src}");
        assert!(src.contains("Cd (AddressType2Code)"), "src = {src}");
        assert!(
            src.contains("Prtry (GenericIdentification30)"),
            "src = {src}"
        );
    }

    #[test]
    fn enum_builtin_variant() {
        let def = EnumDef {
            name: "MyChoice".to_owned(),
            variants: vec![variant("Val", "Val", TypeRef::Builtin(RustType::String))],
        };
        let ts = emit_enum(&def);
        let src = ts.to_string();
        assert!(src.contains("Val (String)"), "src = {src}");
    }

    #[test]
    fn enum_is_valid_rust() {
        let def = EnumDef {
            name: "Party51Choice".to_owned(),
            variants: vec![
                variant(
                    "OrgId",
                    "OrgId",
                    TypeRef::Named("PartyIdentification272".to_owned()),
                ),
                variant(
                    "FIId",
                    "FIId",
                    TypeRef::Named("BranchAndFinancialInstitutionIdentification8".to_owned()),
                ),
            ],
        };
        let ts = emit_enum(&def);
        let src = ts.to_string();
        syn::parse_file(&src).expect("must be parseable Rust");
    }

    #[test]
    fn enum_serde_rename_on_each_variant() {
        let def = EnumDef {
            name: "MyEnum".to_owned(),
            variants: vec![
                variant("XmlName1", "Variant1", TypeRef::Builtin(RustType::String)),
                variant("XmlName2", "Variant2", TypeRef::Builtin(RustType::Bool)),
            ],
        };
        let ts = emit_enum(&def);
        let src = ts.to_string();
        assert!(src.contains("\"XmlName1\""), "src = {src}");
        assert!(src.contains("\"XmlName2\""), "src = {src}");
    }
}