feat: add support for raw reading of variables

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/cuddle-clusters/src/catalog/cluster_vars.rs

@@ -1,7 +1,24 @@
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
+
+use serde_yaml::Value;
 
 use crate::Component;
 
+use super::cuddle_vars::CuddleVariables;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum RawClusterVariable {
+    Map(RawClusterVariables),
+    List(RawClusterVariableList),
+    String(String),
+    Bool(bool),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Default)]
+pub struct RawClusterVariables(BTreeMap<String, RawClusterVariable>);
+#[derive(Clone, PartialEq, Eq, Debug, Default)]
+pub struct RawClusterVariableList(Vec<RawClusterVariable>);
+
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub enum ClusterVariable {
     String(String),
@@ -18,6 +35,9 @@ pub struct ClusterVariables {
     name: String,
     namespace: String,
     replicas: u64,
+
+    raw: RawClusterVariables,
+    // raw: CuddleVariables,
 }
 
 #[derive(Default)]
@@ -42,8 +62,6 @@ impl Component for ClusterVars {
             ..Default::default()
         };
 
-        // TODO: actually extract values
-
         if let Some(mapping) = value.as_mapping() {
             if let Some(env) = mapping.get("env") {
                 if let Some(env_entries) = env.as_mapping() {
@@ -63,6 +81,11 @@ impl Component for ClusterVars {
                 }
             }
         }
+        // vars.raw = match value.clone().try_into() {
+        //     Ok(o) => o,
+        //     Err(e) => panic!("{}", e),
+        // };
+        vars.raw = value.into();
 
         vars.name = environment.into();
         vars.namespace = environment.into();
@@ -78,6 +101,10 @@ impl minijinja::value::Object for ClusterVariables {
             "name" => minijinja::Value::from_safe_string(self.name.clone()),
             "namespace" => minijinja::Value::from_safe_string(self.namespace.clone()),
             "replicas" => minijinja::Value::from_safe_string(self.replicas.to_string()),
+            "raw" => {
+                tracing::info!("returning raw: {:?}", self.raw);
+                minijinja::Value::from_object(self.raw.clone())
+            }
             _ => return None,
         };
 
@@ -103,3 +130,95 @@ impl minijinja::value::Object for ClusterEnv {
         )
     }
 }
+
+impl From<&Value> for RawClusterVariables {
+    fn from(value: &Value) -> Self {
+        match value {
+            Value::Mapping(mapping) => RawClusterVariables(
+                mapping
+                    .into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k.as_str()
+                                .expect("keys to always be valid strings")
+                                .to_string(),
+                            v.into(),
+                        )
+                    })
+                    .collect(),
+            ),
+            Value::Null => RawClusterVariables::default(),
+            _ => todo!(),
+        }
+    }
+}
+
+impl From<&Value> for RawClusterVariable {
+    fn from(value: &Value) -> Self {
+        match value {
+            Value::Null => Self::Map(RawClusterVariables::default()),
+            Value::Bool(b) => Self::Bool(*b),
+            Value::Number(number) => Self::String(number.to_string()),
+            Value::String(s) => Self::String(s.into()),
+            Value::Sequence(vec) => Self::List(RawClusterVariableList(
+                vec.iter().map(|i| i.into()).collect(),
+            )),
+            Value::Mapping(mapping) => Self::Map(RawClusterVariables(
+                mapping
+                    .into_iter()
+                    .map(|(k, v)| {
+                        (
+                            k.as_str()
+                                .expect("keys to always be valid strings")
+                                .to_string(),
+                            v.into(),
+                        )
+                    })
+                    .collect(),
+            )),
+            Value::Tagged(_tagged_value) => todo!(),
+        }
+    }
+}
+
+impl minijinja::value::Object for RawClusterVariables {
+    fn get_value(self: &std::sync::Arc<Self>, key: &minijinja::Value) -> Option<minijinja::Value> {
+        self.0.get(key.as_str()?).map(|o| match o {
+            RawClusterVariable::Map(raw_cluster_variables) => {
+                minijinja::Value::from_object(raw_cluster_variables.clone())
+            }
+            RawClusterVariable::List(list) => minijinja::Value::from_object(list.clone()),
+            RawClusterVariable::String(s) => minijinja::Value::from_safe_string(s.clone()),
+            RawClusterVariable::Bool(b) => minijinja::Value::from_safe_string(b.to_string()),
+        })
+    }
+
+    fn enumerate(self: &std::sync::Arc<Self>) -> minijinja::value::Enumerator {
+        minijinja::value::Enumerator::Values(
+            self.0
+                .keys()
+                .map(|key| minijinja::Value::from_safe_string(key.clone()))
+                .collect::<Vec<_>>(),
+        )
+    }
+}
+
+impl minijinja::value::Object for RawClusterVariableList {
+    fn enumerate(self: &std::sync::Arc<Self>) -> minijinja::value::Enumerator {
+        minijinja::value::Enumerator::Values(
+            self.0
+                .iter()
+                .map(|i| match i {
+                    RawClusterVariable::Map(raw_cluster_variables) => {
+                        minijinja::Value::from_object(raw_cluster_variables.clone())
+                    }
+                    RawClusterVariable::List(list) => minijinja::Value::from_object(list.clone()),
+                    RawClusterVariable::String(s) => minijinja::Value::from_safe_string(s.clone()),
+                    RawClusterVariable::Bool(b) => {
+                        minijinja::Value::from_safe_string(b.to_string())
+                    }
+                })
+                .collect(),
+        )
+    }
+}