[WIP] Code Generation with Weaver - Example of Code Generation for SemConv Attribute Registry and SemConv Metrics

crates/weaver_forge/src/extensions/code.rs

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//! Set of filters used to facilitate the generation of code.
+
+/// Converts the input string into a comment with a prefix.
+pub fn comment_with_prefix(input: &str, prefix: &str) -> String {
+    let mut comment = String::new();
+    for line in input.lines() {
+        if !comment.is_empty() {
+            comment.push_str("\n");
+        }
+        comment.push_str(&format!("{}{}", prefix, line));
+    }
+    comment
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_comment() {
+        assert_eq!(comment_with_prefix("test", "// "), "// test");
+
+        let brief = r#"These attributes may be used to describe the client in a connection-based network interaction
+where there is one side that initiates the connection (the client is the side that initiates the connection).
+This covers all TCP network interactions since TCP is connection-based and one side initiates the
+connection (an exception is made for peer-to-peer communication over TCP where the "user-facing" surface of the
+protocol / API doesn't expose a clear notion of client and server).
+This also covers UDP network interactions where one side initiates the interaction, e.g. QUIC (HTTP/3) and DNS."#;
+
+      let expected_brief =  r#"/// These attributes may be used to describe the client in a connection-based network interaction
+/// where there is one side that initiates the connection (the client is the side that initiates the connection).
+/// This covers all TCP network interactions since TCP is connection-based and one side initiates the
+/// connection (an exception is made for peer-to-peer communication over TCP where the "user-facing" surface of the
+/// protocol / API doesn't expose a clear notion of client and server).
+/// This also covers UDP network interactions where one side initiates the interaction, e.g. QUIC (HTTP/3) and DNS."#;
+
+       assert_eq!(comment_with_prefix(brief, "/// "), expected_brief);
+    }
+}

crates/weaver_forge/src/extensions/mod.rs

@@ -3,3 +3,5 @@
 //! Custom filters used by the template engine.
 pub mod acronym;
 pub mod case_converter;
+pub mod code;
+pub mod tests;

crates/weaver_forge/src/extensions/tests.rs

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//! Set of tests
+
+use minijinja::Value;
+
+/// Checks if the input value is an object with a field named "stability" that has the value "stable".
+/// Otherwise, it returns false.
+pub fn is_stable(input: Value) -> bool {
+    let result = input.get_attr("stability");
+
+    if let Ok(stability) = result {
+        if let Some(stability) = stability.as_str() {
+            return stability == "stable";
+        }
+    }
+    false
+}
+
+/// Checks if the input value is an object with a field named "stability" that has the value
+/// "experimental". Otherwise, it returns false.
+pub fn is_experimental(input: Value) -> bool {
+    let result = input.get_attr("stability");
+
+    if let Ok(stability) = result {
+        if let Some(stability) = stability.as_str() {
+            return stability == "experimental";
+        }
+    }
+    false
+}
+
+/// Checks if the input value is an object with a field named "stability" that has the value "deprecated".
+/// Otherwise, it returns false.
+pub fn is_deprecated(input: Value) -> bool {
+    let result = input.get_attr("deprecated");
+
+    if let Ok(deprecated) = result {
+        if let Some(deprecated) = deprecated.as_str() {
+            return deprecated.len() > 0;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use minijinja::value::StructObject;
+
+    use super::*;
+
+    struct DynAttr {
+        id: String,
+        r#type: String,
+        stability: String,
+        deprecated: Option<String>,
+    }
+
+    impl StructObject for DynAttr {
+        fn get_field(&self, field: &str) -> Option<Value> {
+            match field {
+                "id" => Some(Value::from(self.id.as_str())),
+                "type" => Some(Value::from(self.r#type.as_str())),
+                "stability" => Some(Value::from(self.stability.as_str())),
+                "deprecated" => self.deprecated.as_ref().map(|s| Value::from(s.as_str())),
+                _ => None,
+            }
+        }
+    }
+
+    struct DynSomethingElse {
+        id: String,
+        r#type: String,
+    }
+
+    impl StructObject for DynSomethingElse {
+        fn get_field(&self, field: &str) -> Option<Value> {
+            match field {
+                "id" => Some(Value::from(self.id.as_str())),
+                "type" => Some(Value::from(self.r#type.as_str())),
+                _ => None,
+            }
+        }
+    }
+
+    #[test]
+    fn test_is_stable() {
+        // An attribute with stability "stable"
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "stable".to_owned(),
+            deprecated: None,
+        });
+        assert!(is_stable(attr));
+
+        // An attribute with stability "deprecated"
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "deprecated".to_owned(),
+            deprecated: None,
+        });
+        assert!(!is_stable(attr));
+
+        // An object without a stability field
+        let object = Value::from_struct_object(DynSomethingElse {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+        });
+        assert!(!is_stable(object));
+    }
+
+    #[test]
+    fn test_is_experimental() {
+        // An attribute with stability "experimental"
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "experimental".to_owned(),
+            deprecated: None,
+        });
+        assert!(is_experimental(attr));
+
+        // An attribute with stability "stable"
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "stable".to_owned(),
+            deprecated: None,
+        });
+        assert!(!is_experimental(attr));
+
+        // An object without a stability field
+        let object = Value::from_struct_object(DynSomethingElse {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+        });
+        assert!(!is_experimental(object));
+    }
+
+    #[test]
+    fn test_is_deprecated() {
+        // An attribute with stability "experimental" and a deprecated field with a value
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "experimental".to_owned(),
+            deprecated: Some("This is deprecated".to_owned()),
+        });
+        assert!(is_deprecated(attr));
+
+        // An attribute with stability "stable" and a deprecated field with a value
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "stable".to_owned(),
+            deprecated: Some("This is deprecated".to_owned()),
+        });
+        assert!(is_deprecated(attr));
+
+        // An object without a deprecated field
+        let object = Value::from_struct_object(DynSomethingElse {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+        });
+        assert!(!is_deprecated(object));
+
+        let attr = Value::from_struct_object(DynAttr {
+            id: "test".to_owned(),
+            r#type: "test".to_owned(),
+            stability: "stable".to_owned(),
+            deprecated: None,
+        });
+        assert!(!is_deprecated(attr));
+    }
+}

crates/weaver_forge/src/lib.rs

@@ -27,6 +27,7 @@ use crate::debug::error_summary;
 use crate::error::Error::InvalidConfigFile;
 use crate::extensions::acronym::acronym;
 use crate::extensions::case_converter::case_converter;
+use crate::extensions::code;
 use crate::registry::{TemplateGroup, TemplateRegistry};
 
 mod config;
@@ -375,6 +376,12 @@ impl TemplateEngine {
 
         env.add_filter("acronym", acronym(self.target_config.acronyms.clone()));
 
+        env.add_filter("comment_with_prefix", code::comment_with_prefix);
+
+        env.add_test("stable", extensions::tests::is_stable);
+        env.add_test("experimental", extensions::tests::is_experimental);
+        env.add_test("deprecated", extensions::tests::is_deprecated);
+
         // env.add_filter("unique_attributes", extensions::unique_attributes);
         // env.add_filter("instrument", extensions::instrument);
         // env.add_filter("required", extensions::required);