wip

Author: Mr-Leshiy

rust/catalyst-signed-doc-spec/src/is_required.rs

@@ -1,7 +1,7 @@
 //! 'required' field allowed values definition
 
 /// "required" field definition
-#[derive(serde::Deserialize)]
+#[derive(serde::Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 #[allow(clippy::missing_docs_in_private_items)]
 pub enum IsRequired {

rust/catalyst-signed-doc-spec/src/lib.rs

@@ -8,7 +8,7 @@ pub mod headers;
 pub mod is_required;
 pub mod metadata;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt::Display};
 
 use build_info as build_info_lib;
 
@@ -27,6 +27,15 @@ pub struct CatalystSignedDocSpec {
 #[derive(serde::Deserialize, PartialEq, Eq, Hash)]
 pub struct DocumentName(String);
 
+impl Display for DocumentName {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
 impl DocumentName {
     /// returns document name
     #[must_use]

rust/signed_doc/Cargo.toml

@@ -15,6 +15,7 @@ catalyst-types = { version = "0.0.6", git = "https://github.com/input-output-hk/
 cbork-utils = { version = "0.0.2", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cbork-utils-v0.0.2" }
 
 catalyst-signed-doc-macro = { version = "0.0.1", path = "../catalyst-signed-doc-macro" }
+catalyst-signed-doc-spec = { version = "0.1.3", path = "../catalyst-signed-doc-spec" }
 
 anyhow = "1.0.95"
 serde = { version = "1.0.217", features = ["derive"] }

rust/signed_doc/src/validator/mod.rs

@@ -5,7 +5,6 @@ pub(crate) mod rules;
 
 use std::{collections::HashMap, sync::LazyLock};
 
-use catalyst_signed_doc_macro;
 use catalyst_types::catalyst_id::role_index::RoleId;
 use rules::{
     ContentEncodingRule, ContentRule, ContentSchema, ContentTypeRule, IdRule, OriginalAuthorRule,
@@ -23,8 +22,6 @@ use crate::{
     CatalystSignedDocument, ContentEncoding, ContentType,
 };
 
-catalyst_signed_doc_macro::catalyst_signed_documents_rules!();
-
 /// A table representing a full set or validation rules per document id.
 static DOCUMENT_RULES: LazyLock<HashMap<DocType, Rules>> = LazyLock::new(document_rules_init);
 
@@ -166,8 +163,11 @@ fn proposal_submission_action_rule() -> Rules {
 }
 
 /// `DOCUMENT_RULES` initialization function
+#[allow(clippy::expect_used)]
 fn document_rules_init() -> HashMap<DocType, Rules> {
-    let mut document_rules_map: HashMap<DocType, Rules> = documents_rules().collect();
+    let mut document_rules_map: HashMap<DocType, Rules> = Rules::documents_rules()
+        .expect("cannot fail to initialize validation rules")
+        .collect();
 
     // TODO: remove this redefinitions of the validation rules after
     // `catalyst_signed_documents_rules!` macro would be fully finished

rust/signed_doc/src/validator/rules/content_type.rs

@@ -16,6 +16,33 @@ pub(crate) enum ContentTypeRule {
 }
 
 impl ContentTypeRule {
+    /// Generating `ContentTypeRule` from specs
+    pub(crate) fn new(
+        spec: &catalyst_signed_doc_spec::headers::content_type::ContentType
+    ) -> anyhow::Result<Self> {
+        if let catalyst_signed_doc_spec::is_required::IsRequired::Excluded = spec.required {
+            anyhow::ensure!(
+                spec.value.is_none(),
+                "'value' field must not exist when 'required' is 'excluded'"
+            );
+            return Ok(Self::NotSpecified);
+        }
+
+        anyhow::ensure!(
+            catalyst_signed_doc_spec::is_required::IsRequired::Optional == spec.required,
+            "'content type' field cannot been optional"
+        );
+
+        let value = spec
+            .value
+            .as_ref()
+            .ok_or(anyhow::anyhow!("'content type' 'value' field must exist"))?;
+
+        Ok(Self::Specified {
+            exp: value.parse()?,
+        })
+    }
+
     /// Field validation rule
     #[allow(clippy::unused_async)]
     pub(crate) async fn check(

rust/signed_doc/src/validator/rules/doc_ref.rs

@@ -1,5 +1,7 @@
 //! `ref` rule type impl.
 
+use std::collections::HashMap;
+
 use catalyst_types::problem_report::ProblemReport;
 
 use crate::{
@@ -69,6 +71,43 @@ impl RefRule {
 
         Ok(true)
     }
+
+    /// Generating `RefRule` from specs
+    pub(crate) fn new(
+        docs: &HashMap<catalyst_signed_doc_spec::DocumentName, catalyst_signed_doc_spec::DocSpec>,
+        ref_spec: &catalyst_signed_doc_spec::metadata::doc_ref::Ref,
+    ) -> anyhow::Result<Self> {
+        let optional = match ref_spec.required {
+            catalyst_signed_doc_spec::is_required::IsRequired::Yes => false,
+            catalyst_signed_doc_spec::is_required::IsRequired::Optional => true,
+            catalyst_signed_doc_spec::is_required::IsRequired::Excluded => {
+                return Ok(Self::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 exp_ref_types = ref_spec.doc_type.iter().try_fold(
+            Vec::new(),
+            |mut res, doc_name| -> anyhow::Result<_> {
+                let docs_spec = docs.get(doc_name).ok_or(anyhow::anyhow!(
+                    "cannot find a document definition {doc_name}"
+                ))?;
+                res.push(docs_spec.doc_type.as_str().parse()?);
+                Ok(res)
+            },
+        )?;
+
+        let multiple = ref_spec.multiple.ok_or(anyhow::anyhow!(
+            "'multiple' field should exists for the required 'ref' metadata definition"
+        ))?;
+
+        Ok(Self::Specified {
+            exp_ref_types,
+            multiple,
+            optional,
+        })
+    }
 }
 
 /// Validate all the document references by the defined validation rules,

rust/signed_doc/src/validator/rules/mod.rs

@@ -103,4 +103,51 @@ impl Rules {
 
         Ok(res)
     }
+
+    /// Returns an iterator with all defined Catalyst Signed Documents validation rules
+    /// per corresponding document type based on the `signed_doc.json` file
+    ///
+    /// # Errors:
+    ///  - `signed_doc.json` filed loading and JSON parsing errors.
+    ///  - `catalyst-signed-doc-spec` crate version doesn't  align with the latest version
+    ///    of the `signed_doc.json`.
+    pub(crate) fn documents_rules(
+    ) -> anyhow::Result<impl Iterator<Item = (crate::DocType, crate::validator::rules::Rules)>>
+    {
+        let spec = catalyst_signed_doc_spec::CatalystSignedDocSpec::load_signed_doc_spec()?;
+
+        let mut doc_rules = Vec::new();
+        for (_, doc_spec) in &spec.docs {
+            let rules = Self {
+                id: IdRule,
+                ver: VerRule,
+                content_type: ContentTypeRule::new(&doc_spec.headers.content_type)?,
+                content_encoding: ContentEncodingRule::NotSpecified,
+                template: TemplateRule::NotSpecified,
+                parameters: ParametersRule::NotSpecified,
+                doc_ref: RefRule::new(&spec.docs, &doc_spec.metadata.doc_ref)?,
+                reply: ReplyRule::NotSpecified,
+                section: SectionRule::NotSpecified,
+                content: ContentRule::Nil,
+                kid: SignatureKidRule { exp: &[] },
+                signature: SignatureRule { mutlisig: false },
+                original_author: OriginalAuthorRule,
+            };
+            let doc_type = doc_spec.doc_type.parse()?;
+
+            doc_rules.push((doc_type, rules));
+        }
+
+        Ok(doc_rules.into_iter())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rules_documents_rules_test() {
+        let _unused = Rules::documents_rules().unwrap();
+    }
 }