Merge pull request #2446 from itowlson/templates-redis-allow-add

Add Redis components to existing app

Author: itowlson

crates/templates/src/lib.rs

@@ -17,6 +17,7 @@ mod run;
 mod source;
 mod store;
 mod template;
+mod toml;
 mod writer;
 
 pub use manager::*;

crates/templates/src/reader.rs

@@ -33,6 +33,48 @@ pub(crate) struct RawTemplateVariant {
     pub skip_files: Option<Vec<String>>,
     pub skip_parameters: Option<Vec<String>>,
     pub snippets: Option<HashMap<String, String>>,
+    pub conditions: Option<HashMap<String, RawConditional>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
+pub(crate) struct RawConditional {
+    pub condition: RawCondition,
+    pub skip_files: Option<Vec<String>>,
+    pub skip_parameters: Option<Vec<String>>,
+    pub skip_snippets: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(
+    deny_unknown_fields,
+    rename_all = "snake_case",
+    try_from = "toml::Value"
+)]
+pub(crate) enum RawCondition {
+    ManifestEntryExists(String),
+}
+
+impl TryFrom<toml::Value> for RawCondition {
+    type Error = anyhow::Error;
+
+    fn try_from(value: toml::Value) -> Result<Self, Self::Error> {
+        let Some(table) = value.as_table() else {
+            anyhow::bail!("Invalid condition: should be a single-entry table");
+        };
+        if table.keys().len() != 1 {
+            anyhow::bail!("Invalid condition: should be a single-entry table");
+        }
+        let Some(value) = table.get("manifest_entry_exists") else {
+            anyhow::bail!("Invalid condition: unknown condition type");
+        };
+        let Some(path) = value.as_str() else {
+            anyhow::bail!(
+                "Invalid condition: 'manifest_entry_exists' should be a dotted-path string"
+            );
+        };
+        Ok(Self::ManifestEntryExists(path.to_owned()))
+    }
 }
 
 #[derive(Debug, Deserialize)]

crates/templates/src/run.rs

@@ -281,6 +281,17 @@ impl Run {
                         Err(anyhow::anyhow!("Spin doesn't know what to do with a 'component' snippet outside an 'add component' operation")),
                 }
             },
+            "application_trigger" => {
+                match &self.options.variant {
+                    TemplateVariantInfo::AddComponent { manifest_path } =>
+                        Ok(RenderOperation::AppendToml(
+                            manifest_path.clone(),
+                            content,
+                        )),
+                    TemplateVariantInfo::NewApplication =>
+                        Err(anyhow::anyhow!("Spin doesn't know what to do with an 'application_trigger' snippet outside an 'add component' operation")),
+                    }
+            },
             "variables" => {
                 match &self.options.variant {
                     TemplateVariantInfo::AddComponent { manifest_path } =>

crates/templates/src/template.rs

@@ -5,13 +5,14 @@ use std::{
 
 use anyhow::{anyhow, Context};
 use indexmap::IndexMap;
+use itertools::Itertools;
 use regex::Regex;
 
 use crate::{
     constraints::StringConstraints,
     reader::{
-        RawExtraOutput, RawParameter, RawTemplateManifest, RawTemplateManifestV1,
-        RawTemplateVariant,
+        RawCondition, RawConditional, RawExtraOutput, RawParameter, RawTemplateManifest,
+        RawTemplateManifestV1, RawTemplateVariant,
     },
     run::{Run, RunOptions},
     store::TemplateLayout,
@@ -46,7 +47,7 @@ enum TemplateVariantKind {
 }
 
 /// The variant mode in which a template should be run.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug)]
 pub enum TemplateVariantInfo {
     /// Create a new application from the template.
     NewApplication,
@@ -96,6 +97,22 @@ pub(crate) struct TemplateVariant {
     skip_files: Vec<String>,
     skip_parameters: Vec<String>,
     snippets: HashMap<String, String>,
+    conditions: Vec<Conditional>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Conditional {
+    condition: Condition,
+    skip_files: Vec<String>,
+    skip_parameters: Vec<String>,
+    skip_snippets: Vec<String>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum Condition {
+    ManifestEntryExists(Vec<String>),
+    #[cfg(test)]
+    Always(bool),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
@@ -241,9 +258,12 @@ impl Template {
         }
     }
 
-    fn variant(&self, variant_info: &TemplateVariantInfo) -> Option<&TemplateVariant> {
+    // TODO: we should resolve this once at the start of Run and then use that forever
+    fn variant(&self, variant_info: &TemplateVariantInfo) -> Option<TemplateVariant> {
         let kind = variant_info.kind();
-        self.variants.get(&kind)
+        self.variants
+            .get(&kind)
+            .map(|vt| vt.resolve_conditions(variant_info))
     }
 
     pub(crate) fn parameters(
@@ -253,7 +273,7 @@ impl Template {
         let variant = self.variant(variant_kind).unwrap(); // TODO: for now
         self.parameters
             .iter()
-            .filter(|p| !variant.skip_parameter(p))
+            .filter(move |p| !variant.skip_parameter(p))
     }
 
     pub(crate) fn parameter(&self, name: impl AsRef<str>) -> Option<&TemplateParameter> {
@@ -277,9 +297,9 @@ impl Template {
         self.variants.contains_key(&variant.kind())
     }
 
-    pub(crate) fn snippets(&self, variant_kind: &TemplateVariantInfo) -> &HashMap<String, String> {
+    pub(crate) fn snippets(&self, variant_kind: &TemplateVariantInfo) -> HashMap<String, String> {
         let variant = self.variant(variant_kind).unwrap(); // TODO: for now
-        &variant.snippets
+        variant.snippets
     }
 
     /// Creates a runner for the template, governed by the given options. Call
@@ -355,6 +375,29 @@ impl Template {
             skip_files: raw.skip_files.unwrap_or_default(),
             skip_parameters: raw.skip_parameters.unwrap_or_default(),
             snippets: raw.snippets.unwrap_or_default(),
+            conditions: raw
+                .conditions
+                .unwrap_or_default()
+                .into_values()
+                .map(Self::parse_conditional)
+                .collect(),
+        }
+    }
+
+    fn parse_conditional(conditional: RawConditional) -> Conditional {
+        Conditional {
+            condition: Self::parse_condition(conditional.condition),
+            skip_files: conditional.skip_files.unwrap_or_default(),
+            skip_parameters: conditional.skip_parameters.unwrap_or_default(),
+            skip_snippets: conditional.skip_snippets.unwrap_or_default(),
+        }
+    }
+
+    fn parse_condition(condition: RawCondition) -> Condition {
+        match condition {
+            RawCondition::ManifestEntryExists(path) => {
+                Condition::ManifestEntryExists(path.split('.').map(|s| s.to_string()).collect_vec())
+            }
         }
     }
 
@@ -528,6 +571,45 @@ impl TemplateVariant {
     pub(crate) fn skip_parameter(&self, parameter: &TemplateParameter) -> bool {
         self.skip_parameters.iter().any(|p| &parameter.id == p)
     }
+
+    fn resolve_conditions(&self, variant_info: &TemplateVariantInfo) -> Self {
+        let mut resolved = self.clone();
+        for condition in &self.conditions {
+            if condition.condition.is_true(variant_info) {
+                resolved
+                    .skip_files
+                    .append(&mut condition.skip_files.clone());
+                resolved
+                    .skip_parameters
+                    .append(&mut condition.skip_parameters.clone());
+                resolved
+                    .snippets
+                    .retain(|id, _| !condition.skip_snippets.contains(id));
+            }
+        }
+        resolved
+    }
+}
+
+impl Condition {
+    fn is_true(&self, variant_info: &TemplateVariantInfo) -> bool {
+        match self {
+            Self::ManifestEntryExists(path) => match variant_info {
+                TemplateVariantInfo::NewApplication => false,
+                TemplateVariantInfo::AddComponent { manifest_path } => {
+                    let Ok(toml_text) = std::fs::read_to_string(manifest_path) else {
+                        return false;
+                    };
+                    let Ok(table) = toml::from_str::<toml::Value>(&toml_text) else {
+                        return false;
+                    };
+                    crate::toml::get_at(table, path).is_some()
+                }
+            },
+            #[cfg(test)]
+            Self::Always(b) => *b,
+        }
+    }
 }
 
 fn parse_string_constraints(raw: &RawParameter) -> anyhow::Result<StringConstraints> {
@@ -559,3 +641,128 @@ fn validate_v1_manifest(raw: &RawTemplateManifestV1) -> anyhow::Result<()> {
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    struct TempFile(tempfile::TempDir, PathBuf);
+
+    impl TempFile {
+        fn path(&self) -> PathBuf {
+            self.1.clone()
+        }
+    }
+
+    fn make_temp_manifest(content: &str) -> TempFile {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let temp_file = temp_dir.path().join("spin.toml");
+        std::fs::write(&temp_file, content).unwrap();
+        TempFile(temp_dir, temp_file)
+    }
+
+    #[test]
+    fn manifest_entry_exists_condition_is_false_for_new_app() {
+        let condition = Template::parse_condition(RawCondition::ManifestEntryExists(
+            "application.trigger.redis".to_owned(),
+        ));
+        assert!(!condition.is_true(&TemplateVariantInfo::NewApplication));
+    }
+
+    #[test]
+    fn manifest_entry_exists_condition_is_false_if_not_present_in_existing_manifest() {
+        let temp_file =
+            make_temp_manifest("name = \"hello\"\n[application.trigger.http]\nbase = \"/\"");
+        let condition = Template::parse_condition(RawCondition::ManifestEntryExists(
+            "application.trigger.redis".to_owned(),
+        ));
+        assert!(!condition.is_true(&TemplateVariantInfo::AddComponent {
+            manifest_path: temp_file.path()
+        }));
+    }
+
+    #[test]
+    fn manifest_entry_exists_condition_is_true_if_present_in_existing_manifest() {
+        let temp_file = make_temp_manifest(
+            "name = \"hello\"\n[application.trigger.redis]\nchannel = \"HELLO\"",
+        );
+        let condition = Template::parse_condition(RawCondition::ManifestEntryExists(
+            "application.trigger.redis".to_owned(),
+        ));
+        assert!(condition.is_true(&TemplateVariantInfo::AddComponent {
+            manifest_path: temp_file.path()
+        }));
+    }
+
+    #[test]
+    fn manifest_entry_exists_condition_is_false_if_path_does_not_exist() {
+        let condition = Template::parse_condition(RawCondition::ManifestEntryExists(
+            "application.trigger.redis".to_owned(),
+        ));
+        assert!(!condition.is_true(&TemplateVariantInfo::AddComponent {
+            manifest_path: PathBuf::from("this/file/does/not.exist")
+        }));
+    }
+
+    #[test]
+    fn selected_variant_respects_target() {
+        let add_component_vt = TemplateVariant {
+            conditions: vec![Conditional {
+                condition: Condition::Always(true),
+                skip_files: vec!["test2".to_owned()],
+                skip_parameters: vec!["p1".to_owned()],
+                skip_snippets: vec!["s1".to_owned()],
+            }],
+            skip_files: vec!["test1".to_owned()],
+            snippets: [
+                ("s1".to_owned(), "s1val".to_owned()),
+                ("s2".to_owned(), "s2val".to_owned()),
+            ]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        };
+        let variants = [
+            (
+                TemplateVariantKind::NewApplication,
+                TemplateVariant::default(),
+            ),
+            (TemplateVariantKind::AddComponent, add_component_vt),
+        ]
+        .into_iter()
+        .collect();
+        let template = Template {
+            id: "test".to_owned(),
+            tags: HashSet::new(),
+            description: None,
+            installed_from: InstalledFrom::Unknown,
+            trigger: TemplateTriggerCompatibility::Any,
+            variants,
+            parameters: vec![],
+            extra_outputs: vec![],
+            snippets_dir: None,
+            content_dir: None,
+        };
+
+        let variant_info = TemplateVariantInfo::NewApplication;
+        let variant = template.variant(&variant_info).unwrap();
+        assert!(variant.skip_files.is_empty());
+        assert!(variant.skip_parameters.is_empty());
+        assert!(variant.snippets.is_empty());
+
+        let add_variant_info = TemplateVariantInfo::AddComponent {
+            manifest_path: PathBuf::from("dummy"),
+        };
+        let add_variant = template.variant(&add_variant_info).unwrap();
+        // the conditional skip_files and skip_parameters are added to the variant's skip lists
+        assert_eq!(2, add_variant.skip_files.len());
+        assert!(add_variant.skip_files.contains(&"test1".to_owned()));
+        assert!(add_variant.skip_files.contains(&"test2".to_owned()));
+        assert_eq!(1, add_variant.skip_parameters.len());
+        assert!(add_variant.skip_parameters.contains(&"p1".to_owned()));
+        // the conditional skip_snippets are *removed from* the variant's snippets list
+        assert_eq!(1, add_variant.snippets.len());
+        assert!(!add_variant.snippets.contains_key("s1"));
+        assert!(add_variant.snippets.contains_key("s2"));
+    }
+}