feat(rust/signed-doc): generate content encoding rules from macro

Author: saibatizoku

rust/catalyst-signed-doc-spec/src/headers/content_encoding.rs

@@ -0,0 +1,10 @@
+//! `signed_doc.json` headers content encoding field JSON definition
+//! Content Encoding
+
+use crate::is_required::IsRequired;
+
+#[derive(serde::Deserialize)]
+pub struct ContentEncoding {
+    pub required: IsRequired,
+    pub value: Option<Vec<String>>,
+}

rust/catalyst-signed-doc-spec/src/headers/mod.rs

@@ -1,5 +1,6 @@
 //! 'headers' field definition
 
+pub mod content_encoding;
 pub mod content_type;
 
 /// Document's metadata fields definition
@@ -8,4 +9,6 @@ pub mod content_type;
 pub struct Headers {
     #[serde(rename = "content type")]
     pub content_type: content_type::ContentType,
+    #[serde(rename = "content-encoding")]
+    pub content_encoding: content_encoding::ContentEncoding,
 }

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

@@ -1,5 +1,7 @@
 //! `content-encoding` rule type impl.
 
+use catalyst_signed_doc_spec::is_required::IsRequired;
+
 use crate::{metadata::ContentEncoding, CatalystSignedDocument};
 
 /// `content-encoding` field validation rule.
@@ -8,16 +10,49 @@ pub(crate) enum ContentEncodingRule {
     /// Content Encoding field is optionally present in the document.
     Specified {
         /// expected `content-encoding` field.
-        exp: ContentEncoding,
+        exp: Vec<ContentEncoding>,
         /// optional flag for the `content-encoding` field.
         optional: bool,
     },
     /// Content Encoding field must not be present in the document.
-    #[allow(dead_code)]
     NotSpecified,
 }
 
 impl ContentEncodingRule {
+    pub(crate) fn new(
+        spec: &catalyst_signed_doc_spec::headers::content_encoding::ContentEncoding
+    ) -> anyhow::Result<Self> {
+        if let IsRequired::Excluded = spec.required {
+            anyhow::ensure!(
+                spec.value.is_none(),
+                "'content type' field must not exist when 'required' is 'excluded'"
+            );
+            return Ok(Self::NotSpecified);
+        }
+
+        if let IsRequired::Yes = spec.required {
+            anyhow::ensure!(
+                spec.value.is_some(),
+                "'content-encoding' field must have value when 'required' is 'yes'"
+            );
+        }
+
+        let optional = IsRequired::Optional == spec.required;
+
+        let mut exp = Vec::new();
+        for encoding in spec
+            .value
+            .as_ref()
+            .ok_or(anyhow::anyhow!("'content-encoding' field must have value "))?
+            .iter()
+            .cloned()
+        {
+            exp.push(encoding.parse()?);
+        }
+
+        Ok(Self::Specified { exp, optional })
+    }
+
     /// Field validation rule
     #[allow(clippy::unused_async)]
     pub(crate) async fn check(
@@ -40,23 +75,24 @@ impl ContentEncodingRule {
             },
             Self::Specified { exp, optional } => {
                 if let Some(content_encoding) = doc.doc_content_encoding() {
-                    if content_encoding != *exp {
+                    if !exp.contains(&content_encoding) {
                         doc.report().invalid_value(
                             "content-encoding",
                             content_encoding.to_string().as_str(),
-                            exp.to_string().as_str(),
-                            "Invalid Document content-encoding value",
+                            &exp.iter()
+                                .map(|e| e.to_string())
+                                .collect::<Vec<_>>()
+                                .join(", "),
+                            "Invalid document content-encoding value",
                         );
                         return Ok(false);
                     }
                     if content_encoding.decode(doc.encoded_content()).is_err() {
                         doc.report().invalid_value(
                             "payload",
                             &hex::encode(doc.encoded_content()),
-                            &format!(
-                                "Document content (payload) must decodable by the set content encoding type: {content_encoding}"
-                            ),
-                            "Invalid Document content value",
+                            content_encoding.to_string().as_str(),
+                            "Document content is not decodable with the expected content-encoding",
                         );
                         return Ok(false);
                     }
@@ -83,7 +119,7 @@ mod tests {
         let content_encoding = ContentEncoding::Brotli;
 
         let rule = ContentEncodingRule::Specified {
-            exp: content_encoding,
+            exp: vec![content_encoding],
             optional: true,
         };
 
@@ -103,7 +139,7 @@ mod tests {
         assert!(rule.check(&doc).await.unwrap());
 
         let rule = ContentEncodingRule::Specified {
-            exp: content_encoding,
+            exp: vec![content_encoding],
             optional: false,
         };
         assert!(!rule.check(&doc).await.unwrap());

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

@@ -11,7 +11,6 @@ pub(crate) enum ContentTypeRule {
         exp: ContentType,
     },
     /// Content Type field must not be present in the document.
-    #[allow(dead_code)]
     NotSpecified,
 }
 

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

@@ -122,7 +122,7 @@ impl Rules {
                 id: IdRule,
                 ver: VerRule,
                 content_type: ContentTypeRule::new(&doc_spec.headers.content_type)?,
-                content_encoding: ContentEncodingRule::NotSpecified,
+                content_encoding: ContentEncodingRule::new(&doc_spec.headers.content_encoding)?,
                 template: TemplateRule::NotSpecified,
                 parameters: ParametersRule::NotSpecified,
                 doc_ref: RefRule::new(&spec.docs, &doc_spec.metadata.doc_ref)?,