Work in progress

rudder-lang/src/technique.rs

@@ -11,15 +11,70 @@ use crate::{
 use colored::Colorize;
 use lazy_static::lazy_static;
 use regex::{Captures, Regex};
-use serde::{Deserialize, Serialize};
-use std::str;
+use serde::{
+    de::{self, Deserializer},
+    Deserialize, Serialize, Serializer,
+};
+use std::{
+    fmt,
+    str::{self, FromStr},
+};
 
 // Techniques are limited subsets of CFEngine in JSON representation
 // that only carry method calls and Rudder metadata
 
 // might change later
 pub type TechniqueFmt = String;
 
+// required Version type de/serializer
+fn version_into_string<S>(v: &Version, s: S) -> std::result::Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    s.serialize_str(&v.to_string())
+}
+fn string_into_version<'de, D>(deserializer: D) -> std::result::Result<Version, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let str_version = String::deserialize(deserializer)?;
+    Version::from_str(&str_version).map_err(|e| de::Error::custom(e))
+}
+
+#[derive(Serialize, Deserialize, Copy, Clone)]
+#[cfg_attr(test, derive(PartialEq, Debug))]
+struct Version(u8, u8);
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}.{}", self.0, self.1)
+    }
+}
+impl FromStr for Version {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        // expected format is "X.X", X being positive numbers
+        let values = s
+            .split(".")
+            .map(|value| {
+                value.parse::<u8>().map_err(|e| {
+                    Error::new(format!(
+                        "'{}' is not a valid version (composed of two positive integers): {}",
+                        s, e
+                    ))
+                })
+            })
+            .collect::<Result<Vec<u8>>>()?;
+        if values.len() != 2 {
+            return Err(Error::new(format!(
+                "version ('{}') is not composed of 2 integers",
+                s
+            )));
+        }
+        Ok(Version(values[0], values[1]))
+    }
+}
+
 /// Every Technique substructure has only 1 purpose: represent a Technique as json or rudderlang string
 #[derive(Serialize, Deserialize)]
 pub struct Technique {
@@ -71,7 +126,11 @@ pub struct TechniqueData {
     bundle_name: String,
     description: String,
     name: String,
-    version: String,
+    #[serde(
+        serialize_with = "version_into_string",
+        deserialize_with = "string_into_version"
+    )] // >=6.1
+    version: Version,
     #[serde(rename = "parameter")]
     interpolated_parameters: Vec<InterpolatedParameter>,
     #[serde(default = "default_category")] // >=6.2
@@ -112,7 +171,8 @@ impl TechniqueData {
 @format = 0
 @name = "{name}"
 @description = "{description}"
-@version = {version}
+@version = "{version}"
+@category = "{category}"
 @parameters = [{parameters_meta}]
 
 resource {bundle_name}({parameter_list})
@@ -122,6 +182,7 @@ resource {bundle_name}({parameter_list})
             name = self.name,
             description = self.description,
             version = self.version,
+            category = self.category,
             parameters_meta = parameters_meta_fmt,
             bundle_name = self.bundle_name,
             parameter_list = parameter_list.join(", "),

rudder-lang/src/technique/from_ir.rs

@@ -75,7 +75,7 @@ impl<'src> From<&IR2<'src>> for Technique {
                 bundle_name: extract_meta_string(meta, "name"),
                 description: extract_meta_string(meta, "description"),
                 name: extract_meta_string(meta, "name"),
-                version: extract_meta_string(meta, "version"),
+                version: Version::from_str(&extract_meta_string(meta, "version")).unwrap(),
                 category: extract_meta_string(meta, "category"),
                 interpolated_parameters,
                 method_calls,

rudder-lang/tests/techniques/simplest/technique.rl

@@ -2,7 +2,8 @@
 @format = 0
 @name = "simplest"
 @description = "rudderlang simplest for a complete loop"
-@version = 1.0
+@version = "1.0"
+@category = "ncf_techniques"
 @parameters = []
 
 resource simplest()