jolimail · jdrouet · Jan 17, 2023 · Jan 15, 2023 · Jan 15, 2023 · Jan 15, 2023
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,7 +18,7 @@ travis-ci = { repository = "jdrouet/mrml", branch = "main" }
 [features]
 default = ["json", "parse", "print", "render"]
 json = ["serde", "serde_json"]
-parse = ["xmlparser"]
+parse = ["mrml-parse-macros", "xmlparser"]
 print = ["mrml-print-macros"]
 render = ["rand"]
 orderedmap = ["indexmap", "rustc-hash"]
@@ -35,14 +35,21 @@ serde_json = { version = "1.0", optional = true }
 xmlparser = { version = "0.13", optional = true }
 indexmap = { version = "1.9", features = ["serde-1"], optional = true }
 rustc-hash = { version = "1.1", optional = true }
+
+# macros
 mrml-macros = { path = "./lib/mrml-macros" }
+mrml-parse-macros = { path = "./lib/mrml-parse-macros", optional = true }
 mrml-print-macros = { path = "./lib/mrml-print-macros", optional = true }
 
 [dev-dependencies]
 criterion = "0.4"
 
 [workspace]
-members = ["./lib/mrml-macros", "./lib/mrml-print-macros"]
+members = [
+  "./lib/mrml-macros",
+  "./lib/mrml-parse-macros",
+  "./lib/mrml-print-macros",
+]
 
 [[bench]]
 name = "basic"

diff --git a/lib/mrml-parse-macros/Cargo.toml b/lib/mrml-parse-macros/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "mrml-parse-macros"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+darling = "0.14"
+Inflector = "0.11"
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "1.0", features = ["full", "fold"] }
diff --git a/lib/mrml-parse-macros/src/attributes.rs b/lib/mrml-parse-macros/src/attributes.rs
@@ -0,0 +1,101 @@
+use crate::common::{as_path, get_fields, is_option};
+use inflector::cases::kebabcase::to_kebab_case;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Field, Ident};
+
+fn create_builder_struct_field(field: &Field) -> Option<proc_macro2::TokenStream> {
+    if let Some(ref field_ident) = field.ident {
+        if as_path(field).map(is_option).unwrap_or(false) {
+            let ty = &field.ty;
+            Some(quote! {
+                #field_ident: #ty,
+            })
+        } else {
+            let ty = &field.ty;
+            Some(quote! {
+                #field_ident: Option<#ty>,
+            })
+        }
+    } else {
+        None
+    }
+}
+
+fn create_builder_build_field(field: &Field) -> Option<proc_macro2::TokenStream> {
+    if let Some(ref field_ident) = field.ident {
+        if as_path(field).map(is_option).unwrap_or(false) {
+            Some(quote! {
+                #field_ident: self.#field_ident,
+            })
+        } else {
+            Some(quote! {
+                #field_ident: self.#field_ident
+                    .ok_or_else(|| crate::prelude::parse::Error::MissingAttribute(stringify!(#field_ident)))?,
+            })
+        }
+    } else {
+        None
+    }
+}
+
+fn create_builder_insert_field(field: &Field) -> Option<proc_macro2::TokenStream> {
+    if let Some(ref field_ident) = field.ident {
+        let attribute = to_kebab_case(&field_ident.to_string());
+        Some(quote! {
+            #attribute => {
+                self.#field_ident = Some(value.to_string());
+            }
+        })
+    } else {
+        None
+    }
+}
+
+fn create_builder(ast: &DeriveInput) -> proc_macro2::TokenStream {
+    let ident = &ast.ident;
+
+    let builder_name = format!("{ident}Builder");
+    let builder_ident = Ident::new(&builder_name, ident.span());
+
+    let struct_fields = get_fields(ast)
+        .iter()
+        .filter_map(create_builder_struct_field);
+
+    let build_fields = get_fields(ast)
+        .iter()
+        .filter_map(create_builder_build_field);
+
+    let insert_fields = get_fields(ast)
+        .iter()
+        .filter_map(create_builder_insert_field);
+
+    quote! {
+        #[derive(Debug, Default)]
+        struct #builder_ident {
+            #(#struct_fields)*
+        }
+
+        impl #builder_ident {
+            fn build(self) -> Result<#ident, crate::prelude::parse::Error> {
+                Ok(#ident {
+                    #(#build_fields)*
+                })
+            }
+
+            fn insert<'a>(&mut self, name: xmlparser::StrSpan<'a>, value: xmlparser::StrSpan<'a>) -> Result<(), crate::prelude::parse::Error> {
+                match name.as_str() {
+                    #(#insert_fields)*
+                    _ => return Err(crate::prelude::parse::Error::UnexpectedAttribute(name.start())),
+                };
+                Ok(())
+            }
+        }
+    }
+}
+
+pub fn derive(input: TokenStream) -> TokenStream {
+    let ast: DeriveInput = parse_macro_input!(input as DeriveInput);
+
+    create_builder(&ast).into()
+}
diff --git a/lib/mrml-parse-macros/src/children.rs b/lib/mrml-parse-macros/src/children.rs
@@ -0,0 +1,6 @@
+use proc_macro::TokenStream;
+use quote::quote;
+
+pub fn derive(_input: TokenStream) -> TokenStream {
+    quote! {}.into()
+}
diff --git a/lib/mrml-parse-macros/src/common.rs b/lib/mrml-parse-macros/src/common.rs
@@ -0,0 +1,137 @@
+use proc_macro2::Span;
+use syn::{
+    punctuated::Punctuated, token::Comma, Data, DataStruct, DeriveInput, Field, Fields,
+    FieldsNamed, GenericArgument, Path, PathArguments, Type, TypePath,
+};
+
+pub fn is_vec(path: &Path) -> bool {
+    path.segments
+        .first()
+        // TODO make sure that it's a Vec<T>
+        .map(|s| s.ident == "Vec")
+        .unwrap_or(false)
+}
+
+fn get_vec_type(path: &Path) -> Type {
+    let res = &path.segments.first().unwrap().arguments;
+    let res = if let PathArguments::AngleBracketed(arg) = res {
+        arg
+    } else {
+        panic!("expected path arguments of kind angle bracketed {res:?}");
+    };
+    let res = res.args.first().unwrap();
+    let res = if let GenericArgument::Type(ty) = res {
+        ty
+    } else {
+        panic!("expected generic argument of kind Type {res:?}");
+    };
+    res.to_owned()
+}
+
+pub fn is_map(path: &Path) -> bool {
+    path.segments
+        .first()
+        // TODO make sure that it's a Vec<String, String>
+        .map(|s| s.ident == "Map")
+        .unwrap_or(false)
+}
+
+pub fn is_option(path: &Path) -> bool {
+    path.segments
+        .first()
+        // TODO make sure that it's a Option<T>
+        .map(|s| s.ident == "Option")
+        .unwrap_or(false)
+}
+
+pub fn as_data_struct(ast: &DeriveInput) -> Option<&DataStruct> {
+    if let Data::Struct(inner) = &(ast.data) {
+        Some(inner)
+    } else {
+        None
+    }
+}
+
+pub fn as_fields_named(input: &DataStruct) -> Option<&FieldsNamed> {
+    if let Fields::Named(inner) = &input.fields {
+        Some(inner)
+    } else {
+        None
+    }
+}
+
+pub fn get_fields(ast: &DeriveInput) -> &Punctuated<Field, Comma> {
+    as_data_struct(ast)
+        .and_then(as_fields_named)
+        .map(|f| &f.named)
+        .expect("MrmlParseComponent only supports structs.")
+}
+
+pub fn get_children_field(ast: &DeriveInput) -> Option<&Field> {
+    get_fields(ast).into_iter().find(|f| {
+        f.ident
+            .as_ref()
+            .map(|id| *id == "children")
+            .unwrap_or(false)
+    })
+}
+
+pub enum ChildrenKind {
+    String,
+    List(Type),
+    None,
+}
+
+pub fn get_children_kind(ast: &DeriveInput) -> ChildrenKind {
+    if let Some(field) = get_children_field(ast) {
+        match &field.ty {
+            Type::Path(TypePath { path, .. }) if path.is_ident("String") => ChildrenKind::String,
+            Type::Path(TypePath { path, .. }) if is_vec(path) => {
+                ChildrenKind::List(get_vec_type(path))
+            }
+            _ => panic!("Incompatible type for children field {:?}", field.ident),
+        }
+    } else {
+        ChildrenKind::None
+    }
+}
+
+pub fn get_attributes_field(ast: &DeriveInput) -> Option<&Field> {
+    get_fields(ast).into_iter().find(|f| {
+        f.ident
+            .as_ref()
+            .map(|id| *id == "attributes")
+            .unwrap_or(false)
+    })
+}
+
+pub fn as_path(field: &Field) -> Option<&Path> {
+    match &field.ty {
+        Type::Path(TypePath { path, .. }) => Some(path),
+        _ => None,
+    }
+}
+
+pub fn get_attributes_kind(ast: &DeriveInput) -> AttributesKind {
+    if let Some(field) = get_attributes_field(ast) {
+        match &field.ty {
+            Type::Path(TypePath { path, .. }) if is_map(path) => AttributesKind::Map,
+            Type::Path(TypePath { path, .. }) => {
+                if let Some(ref ident) = path.get_ident() {
+                    AttributesKind::Struct(ident.to_string(), ident.span())
+                } else {
+                    AttributesKind::None
+                }
+            }
+            _ => AttributesKind::None,
+        }
+    } else {
+        AttributesKind::None
+    }
+}
+
+pub enum AttributesKind {
+    Map,
+    Struct(String, Span),
+    None,
+}