feat: content type from spec

Author: apskhem

rust/catalyst-signed-doc-macro/Cargo.toml

@@ -19,4 +19,5 @@ quote = "1.0"
 proc-macro2 = "1.0"
 serde_json = "1.0.142"
 anyhow = "1.0.99"
+Inflector = "0.11.4"
 serde = { version = "1.0.219", features = ["derive"] }

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

@@ -1,17 +1,20 @@
 //! `ContentTypeRule` generation
 
+use std::collections::HashMap;
+
 use proc_macro2::TokenStream;
 use quote::quote;
 
-use crate::signed_doc_spec::{self, IsRequired};
+use crate::signed_doc_spec::{self, ContentTypeSpec, ContentTypeTemplate, IsRequired};
 
 /// Generating `ContentTypeRule` instantiation
 pub(crate) fn into_rule(
-    content_type: &signed_doc_spec::content_type::ContentType
+    content_types: &HashMap<ContentTypeTemplate, ContentTypeSpec>,
+    field: &signed_doc_spec::content_type::ContentType,
 ) -> anyhow::Result<TokenStream> {
-    if matches!(content_type.required, IsRequired::Excluded) {
+    if matches!(field.required, IsRequired::Excluded) {
         anyhow::ensure!(
-            content_type.value.is_empty(),
+            field.value.is_empty(),
             "'value' field must not exist when 'required' is 'excluded'"
         );
 
@@ -20,42 +23,19 @@ pub(crate) fn into_rule(
         });
     }
 
-    if matches!(content_type.required, IsRequired::Yes) {
-        anyhow::ensure!(!content_type.value.is_empty(), "'value' field must exist");
+    if matches!(field.required, IsRequired::Yes) {
+        anyhow::ensure!(!field.value.is_empty(), "'value' field must exist");
     }
 
-    let exp = match content_type.value.as_str() {
-        "application/cbor" => quote! { ContentType::Cbor },
-        "application/cddl" => quote! { ContentType::Cddl },
-        "application/json" => quote! { ContentType::Json },
-        "application/json+schema" => quote! { ContentType::JsonSchema },
-        "text/css; charset=utf-8" => quote! { ContentType::Css },
-        "text/css; charset=utf-8; template=handlebars" => {
-            quote! { ContentType::CssHandlebars }
-        },
-        "text/html; charset=utf-8" => quote! { ContentType::Html },
-        "text/html; charset=utf-8; template=handlebars" => {
-            quote! { ContentType::HtmlHandlebars }
-        },
-        "text/markdown; charset=utf-8" => quote! { ContentType::Markdown },
-        "text/markdown; charset=utf-8; template=handlebars" => {
-            quote! { ContentType::MarkdownHandlebars }
-        },
-        "text/plain; charset=utf-8" => quote! { ContentType::Plain },
-        "text/plain; charset=utf-8; template=handlebars" => {
-            quote! { ContentType::PlainHandlebars }
-        },
-        _ => {
-            return Err(anyhow::anyhow!(
-                "Unsupported Content Type: {}",
-                content_type.value
-            ))
-        },
+    let template = ContentTypeTemplate(field.value.clone());
+    let Some(_) = content_types.get(&template) else {
+        return Err(anyhow::anyhow!("Unsupported Content Type: {}", field.value));
     };
+    let ident = template.ident();
 
     Ok(quote! {
         crate::validator::rules::ContentTypeRule::Specified {
-            exp: #exp,
+            exp: ContentType::#ident,
         }
     })
 }

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

@@ -16,7 +16,8 @@ pub(crate) fn catalyst_signed_documents_rules_impl() -> anyhow::Result<TokenStre
     for (doc_name, doc_spec) in spec.docs {
         let const_type_name_ident = doc_name.ident();
 
-        let content_type_rule = content_type::into_rule(&doc_spec.headers.content_type)?;
+        let content_type_rule =
+            content_type::into_rule(&spec.content_types, &doc_spec.headers.content_type)?;
         let ref_rule = doc_ref::ref_rule(&doc_spec.metadata.doc_ref)?;
         // TODO: implement a proper initialization for all specific validation rules
         let rules = quote! {

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

@@ -5,16 +5,67 @@ pub(crate) mod doc_ref;
 
 use std::{collections::HashMap, ops::Deref};
 
+use inflector::cases::pascalcase::to_pascal_case;
 use proc_macro2::Ident;
 use quote::format_ident;
 
 /// Catalyst Signed Document spec representation struct
 #[derive(serde::Deserialize)]
 pub(crate) struct CatalystSignedDocSpec {
+    /// A collection of document's supported content types
+    #[serde(rename = "contentTypes")]
+    #[allow(dead_code)]
+    pub(crate) content_types: HashMap<ContentTypeTemplate, ContentTypeSpec>,
     /// A collection of document's specs
     pub(crate) docs: HashMap<DocumentName, DocSpec>,
 }
 
+// A thin wrapper over the RFC2046 content type strings.
+#[derive(serde::Deserialize, PartialEq, Eq, Hash)]
+pub(crate) struct ContentTypeTemplate(pub(crate) String);
+
+impl ContentTypeTemplate {
+    /// returns a document name as a `Ident` in the following form
+    ///
+    /// text/css; charset=utf-8; template=handlebars
+    /// => `CssHandlebars`
+    ///
+    /// text/css; charset=utf-8
+    /// => `Css`
+    pub(crate) fn ident(&self) -> Ident {
+        let raw = self.0.as_str();
+
+        // split into parts like "text/css; charset=utf-8; template=handlebars"
+        let mut parts = raw.split(';').map(str::trim);
+
+        // first part is "type/subtype"
+        let first = parts.next().unwrap_or_default(); // e.g. "text/css"
+        let subtype = first.split('/').nth(1).unwrap_or_default(); // "css"
+
+        // look for "template=..."
+        let template = parts
+            .find_map(|p| p.strip_prefix("template="))
+            .map(to_pascal_case);
+
+        // build PascalCase
+        let mut ident = String::new();
+        ident.push_str(&to_pascal_case(subtype));
+        if let Some(t) = template {
+            ident.push_str(&t);
+        }
+
+        format_ident!("{}", ident)
+    }
+}
+
+/// Catalyst Signed Document supported content type declaration struct
+#[derive(serde::Deserialize)]
+pub(crate) struct ContentTypeSpec {
+    /// CoAP Content-Formats
+    #[allow(dead_code)]
+    coap_type: Option<u32>,
+}
+
 // A thin wrapper over the string document name values
 #[derive(serde::Deserialize, PartialEq, Eq, Hash)]
 pub(crate) struct DocumentName(String);

rust/signed_doc/src/metadata/content_type.rs

@@ -16,9 +16,9 @@ pub enum ContentType {
     /// `application/json`
     #[strum(to_string = "application/json")]
     Json,
-    /// `application/json+schema`
-    #[strum(to_string = "application/json+schema")]
-    JsonSchema,
+    /// `application/schema+json`
+    #[strum(to_string = "application/schema+json")]
+    SchemaJson,
     /// `text/css; charset=utf-8`
     #[strum(to_string = "text/css; charset=utf-8")]
     Css,
@@ -53,7 +53,7 @@ impl FromStr for ContentType {
             "application/cbor" => Ok(Self::Cbor),
             "application/cddl" => Ok(Self::Cddl),
             "application/json" => Ok(Self::Json),
-            "application/json+schema" => Ok(Self::JsonSchema),
+            "application/schema+json" => Ok(Self::SchemaJson),
             "text/css; charset=utf-8" => Ok(Self::Css),
             "text/css; charset=utf-8; template=handlebars" => Ok(Self::CssHandlebars),
             "text/html; charset=utf-8" => Ok(Self::Html),
@@ -162,8 +162,8 @@ mod tests {
         "application/json"
     )]
     #[test_case(
-        ("application/json+schema", ContentType::JsonSchema);
-        "application/json+schema"
+        ("application/schema+json", ContentType::SchemaJson);
+        "application/schema+json"
     )]
     #[test_case(
         ("text/css; charset=utf-8", ContentType::Css);

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

@@ -73,7 +73,7 @@ impl ContentRule {
                     ContentType::Json => templated_json_schema_check(doc, template_doc),
                     ContentType::Cddl
                     | ContentType::Cbor
-                    | ContentType::JsonSchema
+                    | ContentType::SchemaJson
                     | ContentType::Css
                     | ContentType::CssHandlebars
                     | ContentType::Html

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

@@ -11,6 +11,7 @@ pub(crate) enum ContentTypeRule {
         exp: ContentType,
     },
     /// Content Type field must not be present in the document.
+    #[allow(dead_code)]
     NotSpecified,
 }
 
@@ -92,7 +93,7 @@ impl ContentTypeRule {
                     }
                 },
                 ContentType::Cddl
-                | ContentType::JsonSchema
+                | ContentType::SchemaJson
                 | ContentType::Css
                 | ContentType::CssHandlebars
                 | ContentType::Html