wip

Author: Mr-Leshiy

rust/catalyst-signed-doc-macro/src/rules/doc_ref.rs

@@ -7,35 +7,32 @@ use crate::signed_doc_spec::{self, IsRequired};
 
 /// Generating `RefRule` instantiation
 pub(crate) fn ref_rule(ref_spec: &signed_doc_spec::doc_ref::Ref) -> anyhow::Result<TokenStream> {
-    match ref_spec.required {
-        IsRequired::Yes => {
-            let doc_name = ref_spec.doc_type.as_ref().ok_or(anyhow::anyhow!(
-                "'type' field should exists for the required 'ref' metadata definition"
-            ))?;
-            let const_type_name_ident = doc_name.ident();
-            Ok(quote! {
-                crate::validator::rules::RefRule::Specified {
-                    exp_ref_types: vec![ #const_type_name_ident ]
-                    optional: false,
-                }
-            })
-        },
-        IsRequired::Optional => {
-            let doc_name = ref_spec.doc_type.as_ref().ok_or(anyhow::anyhow!(
-                "'type' field should exists for the required 'ref' metadata definition"
-            ))?;
-            let const_type_name_ident = doc_name.ident();
-            Ok(quote! {
-                crate::validator::rules::RefRule::Specified {
-                    exp_ref_types: vec![ #const_type_name_ident ]
-                    optional: true,
-                }
-            })
-        },
+    let optional = match ref_spec.required {
+        IsRequired::Yes => true,
+        IsRequired::Optional => false,
         IsRequired::Excluded => {
-            Ok(quote! {
+            return Ok(quote! {
                 crate::validator::rules::RefRule::NotSpecified
-            })
+            });
         },
-    }
+    };
+
+    anyhow::ensure!(!ref_spec.doc_type.is_empty(), "'type' field should exists and has at least one entry for the required 'ref' metadata definition");
+
+    let const_type_name_idents = ref_spec.doc_type.iter().map(|doc_name| {
+        let const_type_name_ident = doc_name.ident();
+        quote! {
+            crate::doc_types::#const_type_name_ident
+        }
+    });
+    let multiple = ref_spec.multiple.ok_or(anyhow::anyhow!(
+        "'multiple' field should exists for the required 'ref' metadata definition"
+    ))?;
+    Ok(quote! {
+        crate::validator::rules::RefRule::Specified {
+            exp_ref_types: vec![ #(#const_type_name_idents,)* ],
+            multiple: #multiple,
+            optional: #optional,
+        }
+    })
 }

rust/catalyst-signed-doc-macro/src/signed_doc_spec/doc_ref.rs

@@ -1,12 +1,12 @@
 //! `signed_doc.json` "ref" field JSON defintion
 
-use crate::signed_doc_spec::{DocumentName, IsRequired};
+use crate::signed_doc_spec::{DocTypes, IsRequired};
 
 /// `signed_doc.json` "ref" field JSON object
 #[derive(serde::Deserialize)]
 pub(crate) struct Ref {
     pub(crate) required: IsRequired,
     #[serde(rename = "type")]
-    pub(crate) doc_type: Option<DocumentName>,
-    // pub(crate) multiple: Option<bool>,
+    pub(crate) doc_type: DocTypes,
+    pub(crate) multiple: Option<bool>,
 }

rust/catalyst-signed-doc-macro/src/signed_doc_spec/mod.rs

@@ -2,7 +2,7 @@
 
 pub(crate) mod doc_ref;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, ops::Deref};
 
 use proc_macro2::Ident;
 use quote::format_ident;
@@ -65,6 +65,35 @@ pub(crate) enum IsRequired {
     Optional,
 }
 
+pub(crate) struct DocTypes(Vec<DocumentName>);
+
+impl Deref for DocTypes {
+    type Target = Vec<DocumentName>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for DocTypes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: serde::Deserializer<'de> {
+        #[derive(serde::Deserialize)]
+        #[serde(untagged)]
+        enum SingleOrVec {
+            Single(DocumentName),
+            Multiple(Vec<DocumentName>),
+        }
+        let value = Option::<SingleOrVec>::deserialize(deserializer)?;
+        let result = match value {
+            Some(SingleOrVec::Single(item)) => vec![item],
+            Some(SingleOrVec::Multiple(items)) => items,
+            None => vec![],
+        };
+        Ok(Self(result))
+    }
+}
+
 impl CatalystSignedDocSpec {
     /// Loading a Catalyst Signed Documents spec from the `signed_doc.json`
     // #[allow(dependency_on_unit_never_type_fallback)]