Implement support for custom generator code

Types defined by the user using `CustomMeta` type variant may want to execute
additional code, once the type is executed by the generator. This commits
adds a new `CustomGenerator` trait that can be added to the `CustomMeta`
and is executed by the generator when the type is executed. This allows users
to instruct the generator to generate other dependent types, use the generator
context to resolve type paths or to just execute any kind of custom code.

Author: Bergmann89

xsd-parser/src/config/mod.rs

@@ -841,6 +841,17 @@ impl IdentQuadruple {
     }
 }
 
+impl From<TypeIdent> for IdentQuadruple {
+    fn from(value: TypeIdent) -> Self {
+        Self {
+            ns: Some(NamespaceIdent::Id(value.ns)),
+            schema: Some(SchemaIdent::Id(value.schema)),
+            name: value.name.into(),
+            type_: value.type_,
+        }
+    }
+}
+
 impl<X> From<(IdentType, X)> for IdentQuadruple
 where
     X: AsRef<str>,

xsd-parser/src/models/code/ident_path.rs

@@ -273,6 +273,12 @@ impl ToTokens for IdentPath {
 }
 
 impl ModulePath {
+    /// Creates a new [`ModulePath`] instance that represents the root module.
+    #[must_use]
+    pub fn root() -> Self {
+        Self::default()
+    }
+
     /// Create a new [`ModulePath`] instance from the passed namespace id `ns` and the
     /// `types` information.
     ///

xsd-parser/src/models/meta/custom.rs

@@ -6,7 +6,9 @@ use std::hash::{Hash, Hasher};
 use xsd_parser_types::misc::Namespace;
 
 use crate::config::NamespaceId;
-use crate::pipeline::generator::{ValueGenerator, ValueGeneratorBox};
+use crate::pipeline::generator::{
+    CustomGenerator, CustomGeneratorBox, ValueGenerator, ValueGeneratorBox,
+};
 
 /// Type information for a custom defined type.
 pub struct CustomMeta {
@@ -24,6 +26,11 @@ pub struct CustomMeta {
     /// to suitable rust code.
     pub default: Option<ValueGeneratorBox>,
 
+    /// The generator step that is execute if a custom type is processed by the generator.
+    ///
+    /// This can be used to add custom code to the generated code for a custom type.
+    pub generator: Option<CustomGeneratorBox>,
+
     /// The namespaces needed by this custom type.
     pub namespaces: Vec<CustomMetaNamespace>,
 
@@ -42,6 +49,7 @@ impl CustomMeta {
             name: name.into(),
             include: None,
             default: None,
+            generator: None,
             namespaces: Vec::new(),
             allow_any: false,
         }
@@ -80,6 +88,14 @@ impl CustomMeta {
         self
     }
 
+    /// Set the generator step that is execute if a custom type is processed by the generator.
+    #[must_use]
+    pub fn with_generator<X: CustomGenerator>(mut self, x: X) -> Self {
+        self.generator = Some(Box::new(x));
+
+        self
+    }
+
     /// Add a namespace that is needed by this custom type.
     ///
     /// The namespace may be added to the root element during serialization.
@@ -120,6 +136,10 @@ impl Clone for CustomMeta {
             name: self.name.clone(),
             include: self.include.clone(),
             default: self.default.as_ref().map(|x| ValueGenerator::clone(&**x)),
+            generator: self
+                .generator
+                .as_ref()
+                .map(|x| CustomGenerator::clone(&**x)),
             namespaces: self.namespaces.clone(),
             allow_any: self.allow_any,
         }
@@ -132,6 +152,7 @@ impl Debug for CustomMeta {
             .field("name", &self.name)
             .field("include", &self.include)
             .field("default", &self.default.is_some())
+            .field("generator", &self.generator.is_some())
             .field("namespaces", &self.namespaces)
             .field("allow_any", &self.allow_any)
             .finish()

xsd-parser/src/models/meta/types.rs

@@ -1,8 +1,12 @@
 use std::collections::BTreeMap;
 
+use inflector::Inflector;
+use quote::format_ident;
 use xsd_parser_types::misc::Namespace;
 
 use crate::models::{
+    code::IdentPath,
+    data::PathData,
     schema::{xs::FormChoiceType, NamespaceId, SchemaId},
     Name, Naming, TypeIdent,
 };
@@ -156,6 +160,32 @@ impl ModuleMeta {
     pub fn prefix(&self) -> Option<&Name> {
         self.prefix.as_ref().or(self.name.as_ref())
     }
+
+    /// Create a path to the contstant that represents the namespace of this module.
+    #[must_use]
+    pub fn make_ns_const(&self) -> Option<PathData> {
+        self.namespace.as_ref()?;
+        let name = self.name().map_or_else(
+            || format!("UNNAMED_{}", self.namespace_id.0),
+            |name| name.as_str().to_screaming_snake_case(),
+        );
+        let ident = format_ident!("NS_{name}");
+        let path = IdentPath::from_parts([], ident);
+
+        Some(PathData::from_path(path))
+    }
+
+    /// Create a path to the contstant that represents the prefix of this module.
+    #[must_use]
+    pub fn make_prefix_const(&self) -> Option<PathData> {
+        self.namespace.as_ref()?;
+        let name = self.name()?;
+        let name = name.as_str().to_screaming_snake_case();
+        let ident = format_ident!("PREFIX_{name}");
+        let path = IdentPath::from_parts([], ident);
+
+        Some(PathData::from_path(path))
+    }
 }
 
 fn get_resolved_impl<'a>(

xsd-parser/src/pipeline/generator/context.rs

@@ -40,46 +40,25 @@ impl<'a, 'types> Context<'a, 'types> {
         self.namespaces.last()
     }
 
-    pub(super) fn new(
-        meta: &'a MetaData<'types>,
-        ident: &'a TypeIdent,
-        state: &'a mut State<'types>,
-    ) -> Self {
-        let reachable = state.loop_detection.get_reachable(&state.cache, ident);
-
-        Self {
-            meta,
-            ident,
-            state,
-            reachable,
-            namespaces: Vec::new(),
-        }
-    }
-
-    pub(super) fn current_module(&self) -> ModuleIdent {
-        ModuleIdent::new(
-            self.meta.types,
-            self.ident,
-            self.check_generator_flags(GeneratorFlags::USE_NAMESPACE_MODULES),
-            self.check_generator_flags(GeneratorFlags::USE_SCHEMA_MODULES),
-        )
-    }
-
-    pub(super) fn current_type_ref(&self) -> &TypeRef {
-        self.state.cache.get(self.ident).unwrap()
-    }
-
-    pub(super) fn get_trait_infos(&mut self) -> &TraitInfos {
-        &self.state.trait_infos
-    }
-
-    pub(super) fn get_or_create_type_ref(&mut self, ident: &TypeIdent) -> Result<&TypeRef, Error> {
+    /// Get the [`TypeRef`] for the passed `ident`, creating it (and scheduling
+    /// the type for generation) if it does not exist yet.
+    ///
+    /// # Errors
+    ///
+    /// Forwards the errors raised while creating the type reference.
+    pub fn get_or_create_type_ref(&mut self, ident: &TypeIdent) -> Result<&TypeRef, Error> {
         let type_ref = self.state.get_or_create_type_ref_mut(self.meta, ident)?;
 
         Ok(type_ref)
     }
 
-    pub(super) fn get_or_create_type_ref_for_value(
+    /// Like [`get_or_create_type_ref`](Self::get_or_create_type_ref), but also
+    /// marks the type as reachable by value if `by_value` is set.
+    ///
+    /// # Errors
+    ///
+    /// Forwards the errors raised while creating the type reference.
+    pub fn get_or_create_type_ref_for_value(
         &mut self,
         ident: &TypeIdent,
         by_value: bool,
@@ -93,7 +72,14 @@ impl<'a, 'types> Context<'a, 'types> {
         Ok(type_ref)
     }
 
-    pub(super) fn get_or_create_type_ref_for_element(
+    /// Like [`get_or_create_type_ref`](Self::get_or_create_type_ref), but for an
+    /// element. Returns the [`TypeRef`] together with a flag that indicates if
+    /// the type needs to be boxed.
+    ///
+    /// # Errors
+    ///
+    /// Forwards the errors raised while creating the type reference.
+    pub fn get_or_create_type_ref_for_element(
         &mut self,
         ident: &TypeIdent,
         by_value: bool,
@@ -108,6 +94,38 @@ impl<'a, 'types> Context<'a, 'types> {
         Ok((type_ref, boxed))
     }
 
+    pub(super) fn new(
+        meta: &'a MetaData<'types>,
+        ident: &'a TypeIdent,
+        state: &'a mut State<'types>,
+    ) -> Self {
+        let reachable = state.loop_detection.get_reachable(&state.cache, ident);
+
+        Self {
+            meta,
+            ident,
+            state,
+            reachable,
+            namespaces: Vec::new(),
+        }
+    }
+
+    pub(super) fn current_module(&self) -> ModuleIdent {
+        ModuleIdent::new(
+            self.meta.types,
+            self.ident,
+            self.check_generator_flags(GeneratorFlags::USE_NAMESPACE_MODULES),
+            self.check_generator_flags(GeneratorFlags::USE_SCHEMA_MODULES),
+        )
+    }
+
+    pub(super) fn current_type_ref(&self) -> &TypeRef {
+        self.state.cache.get(self.ident).unwrap()
+    }
+
+    pub(super) fn get_trait_infos(&mut self) -> &TraitInfos {
+        &self.state.trait_infos
+    }
     pub(super) fn make_trait_impls(&mut self) -> Result<Vec<TokenStream>, Error> {
         let ident = self.ident.clone();
         let current_module = self.current_module();

xsd-parser/src/pipeline/generator/custom.rs

@@ -1,9 +1,52 @@
 use std::fmt::{Debug, Formatter, Result as FmtResult};
 
+use crate::models::meta::CustomMeta;
 use crate::pipeline::renderer::ValueRenderer;
 
 use super::{Context, Error};
 
+/// Boxed version of [`CustomGenerator`].
+pub type CustomGeneratorBox = Box<dyn CustomGenerator>;
+
+impl Debug for CustomGeneratorBox {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        f.debug_struct("CustomGeneratorBox").finish()
+    }
+}
+
+/// Implements a custom generator step that is execute if a custom type is
+/// processed by the generator.
+pub trait CustomGenerator: 'static {
+    /// Execute this generator step.
+    fn exec<'types>(
+        &self,
+        ctx: &mut Context<'_, 'types>,
+        meta: &'types CustomMeta,
+    ) -> Result<(), Error>;
+
+    /// Clone this instance and return it as a box.
+    fn clone(&self) -> Box<dyn CustomGenerator>;
+}
+
+impl<X> CustomGenerator for X
+where
+    X: for<'types> Fn(&mut Context<'_, 'types>, &'types CustomMeta) -> Result<(), Error>
+        + Clone
+        + 'static,
+{
+    fn exec<'types>(
+        &self,
+        ctx: &mut Context<'_, 'types>,
+        meta: &'types CustomMeta,
+    ) -> Result<(), Error> {
+        (*self)(ctx, meta)
+    }
+
+    fn clone(&self) -> Box<dyn CustomGenerator> {
+        Box::new(self.clone())
+    }
+}
+
 /// Boxed version of [`ValueGenerator`].
 pub type ValueGeneratorBox = Box<dyn ValueGenerator>;
 

xsd-parser/src/pipeline/generator/data/custom.rs

@@ -0,0 +1,20 @@
+use std::borrow::Cow;
+
+use crate::models::{data::CustomData, meta::CustomMeta};
+
+use super::super::{Context, Error};
+
+impl<'types> CustomData<'types> {
+    pub(super) fn new(
+        meta: &'types CustomMeta,
+        ctx: &mut Context<'_, 'types>,
+    ) -> Result<Self, Error> {
+        if let Some(generator) = &meta.generator {
+            generator.exec(ctx, meta)?;
+        }
+
+        Ok(Self {
+            meta: Cow::Borrowed(meta),
+        })
+    }
+}

xsd-parser/src/pipeline/generator/data/mod.rs

@@ -1,5 +1,6 @@
 mod complex;
 mod constrains;
+mod custom;
 mod dynamic;
 mod enumeration;
 mod reference;
@@ -13,8 +14,8 @@ use std::mem::swap;
 use crate::config::GeneratorFlags;
 use crate::models::{
     code::IdentPath,
-    data::{BuildInData, CustomData, PathData},
-    meta::{BuildInMeta, CustomMeta},
+    data::{BuildInData, PathData},
+    meta::BuildInMeta,
 };
 
 use super::Context;
@@ -27,14 +28,6 @@ impl<'types> BuildInData<'types> {
     }
 }
 
-impl<'types> CustomData<'types> {
-    fn new(meta: &'types CustomMeta) -> Self {
-        Self {
-            meta: Cow::Borrowed(meta),
-        }
-    }
-}
-
 impl Context<'_, '_> {
     fn path_data_nillable(&self, is_mixed: bool, mut path: PathData) -> PathData {
         if !is_mixed {

xsd-parser/src/pipeline/generator/data/type_.rs

@@ -21,7 +21,7 @@ impl<'types> DataType<'types> {
         let derive = ConfigValue::Default;
         let variant = match &meta.variant {
             M::BuildIn(x) => D::BuildIn(BuildInData::new(x)),
-            M::Custom(x) => D::Custom(CustomData::new(x)),
+            M::Custom(x) => D::Custom(CustomData::new(x, ctx)?),
             M::Union(x) => D::Union(UnionData::new(x, ctx)?),
             M::Dynamic(x) => D::Dynamic(DynamicData::new(x, ctx)?),
             M::Reference(x) => D::Reference(ReferenceData::new(x, ctx)?),

xsd-parser/src/pipeline/generator/mod.rs

@@ -44,11 +44,14 @@ use crate::models::{
 use crate::traits::Naming;
 
 pub use self::context::Context;
-pub use self::custom::{ValueGenerator, ValueGeneratorBox, ValueGeneratorMode};
+pub use self::custom::{
+    CustomGenerator, CustomGeneratorBox, ValueGenerator, ValueGeneratorBox, ValueGeneratorMode,
+};
 pub use self::error::Error;
 pub use self::meta::MetaData;
+pub use self::state::TypeRef;
 
-use self::state::{LoopDetection, PendingType, State, TraitInfos, TypeRef};
+use self::state::{LoopDetection, PendingType, State, TraitInfos};
 
 /// Configurable Rust code generator for schema-derived type information.
 ///