Merge pull request #3111 from itowlson/templates-partials

Support Liquid partials in templates

Author: itowlson

crates/templates/src/manager.rs

@@ -1196,6 +1196,32 @@ mod tests {
         assert!(!http_empty.supports_variant(&add_component));
     }
 
+    #[tokio::test]
+    async fn can_render_partials() {
+        let manager = TempManager::new();
+        manager.install_test_data_templates().await;
+
+        let partials_template = manager.get("partials").unwrap().unwrap();
+
+        let dest_temp_dir = tempdir().unwrap();
+        let output_dir = dest_temp_dir.path().join("myproj");
+        let options = run_options("my project", &output_dir, |opts| {
+            opts.values = [("example-value".to_owned(), "myvalue".to_owned())]
+                .into_iter()
+                .collect();
+        });
+
+        partials_template.run(options).silent().await.unwrap();
+
+        let generated_file = output_dir.join("test.txt");
+        let generated_text = std::fs::read_to_string(&generated_file).unwrap();
+        let generated_lines = generated_text.lines().collect::<Vec<_>>();
+
+        assert_eq!("Value: myvalue", generated_lines[0]);
+        assert_eq!("Partial 1: Hello from P1", generated_lines[1]);
+        assert_eq!("Partial 2: Value is myvalue", generated_lines[2]);
+    }
+
     #[tokio::test]
     async fn fails_on_unknown_filter() {
         let manager = TempManager::new();

crates/templates/src/run.rs

@@ -19,6 +19,9 @@ use crate::{
     template::Template,
 };
 
+/// A set of partials to be included in a Liquid template.
+type PartialsBuilder = liquid::partials::EagerCompiler<liquid::partials::InMemorySource>;
+
 /// Executes a template to the point where it is ready to generate
 /// artefacts.
 pub struct Run {
@@ -104,6 +107,9 @@ impl Run {
             };
         }
 
+        let partials = self.partials()?;
+        let parser = Self::template_parser(partials)?;
+
         self.validate_provided_values()?;
 
         let files = match self.template.content_dir() {
@@ -112,15 +118,15 @@ impl Run {
                 let from = path
                     .absolutize()
                     .context("Failed to get absolute path of template directory")?;
-                self.included_files(&from, &to)?
+                self.included_files(&from, &to, &parser)?
             }
         };
 
         let snippets = self
             .template
             .snippets(&self.options.variant)
             .iter()
-            .map(|(id, path)| self.snippet_operation(id, path))
+            .map(|(id, path)| self.snippet_operation(id, path, &parser))
             .collect::<anyhow::Result<Vec<_>>>()?;
 
         let extras = self
@@ -151,7 +157,12 @@ impl Run {
         }
     }
 
-    fn included_files(&self, from: &Path, to: &Path) -> anyhow::Result<Vec<RenderOperation>> {
+    fn included_files(
+        &self,
+        from: &Path,
+        to: &Path,
+        parser: &liquid::Parser,
+    ) -> anyhow::Result<Vec<RenderOperation>> {
         let gitignore = ".gitignore";
         let mut all_content_files = Self::list_content_files(from)?;
         // If user asked for no_vcs
@@ -164,7 +175,7 @@ impl Run {
         let included_files =
             self.template
                 .included_files(from, all_content_files, &self.options.variant);
-        let template_contents = self.read_all(included_files)?;
+        let template_contents = self.read_all(included_files, parser)?;
         let outputs = Self::to_output_paths(from, to, template_contents);
         let file_ops = outputs
             .into_iter()
@@ -262,7 +273,12 @@ impl Run {
         }
     }
 
-    fn snippet_operation(&self, id: &str, snippet_file: &str) -> anyhow::Result<RenderOperation> {
+    fn snippet_operation(
+        &self,
+        id: &str,
+        snippet_file: &str,
+        parser: &liquid::Parser,
+    ) -> anyhow::Result<RenderOperation> {
         let snippets_dir = self
             .template
             .snippets_dir()
@@ -271,7 +287,7 @@ impl Run {
         let abs_snippet_file = snippets_dir.join(snippet_file);
         let file_content = std::fs::read(abs_snippet_file)
             .with_context(|| format!("Error reading snippet file {}", snippet_file))?;
-        let content = TemplateContent::infer_from_bytes(file_content, &Self::template_parser())
+        let content = TemplateContent::infer_from_bytes(file_content, parser)
             .with_context(|| format!("Error parsing snippet file {}", snippet_file))?;
 
         match id {
@@ -356,11 +372,14 @@ impl Run {
     }
 
     // TODO: async when we know where things sit
-    fn read_all(&self, paths: Vec<PathBuf>) -> anyhow::Result<Vec<(PathBuf, TemplateContent)>> {
-        let template_parser = Self::template_parser();
+    fn read_all(
+        &self,
+        paths: Vec<PathBuf>,
+        template_parser: &liquid::Parser,
+    ) -> anyhow::Result<Vec<(PathBuf, TemplateContent)>> {
         let contents = paths
             .iter()
-            .map(|path| TemplateContent::infer_from_bytes(std::fs::read(path)?, &template_parser))
+            .map(|path| TemplateContent::infer_from_bytes(std::fs::read(path)?, template_parser))
             .collect::<Result<Vec<_>, _>>()?;
         // Strip optional .tmpl extension
         // Templates can use this if they don't want to store files with their final extensions
@@ -394,16 +413,45 @@ impl Run {
         pathdiff::diff_paths(source, src_dir).map(|rel| (dest_dir.join(rel), cont))
     }
 
-    fn template_parser() -> liquid::Parser {
+    fn template_parser(
+        partials: impl liquid::partials::PartialCompiler,
+    ) -> anyhow::Result<liquid::Parser> {
         let builder = liquid::ParserBuilder::with_stdlib()
+            .partials(partials)
             .filter(crate::filters::KebabCaseFilterParser)
             .filter(crate::filters::PascalCaseFilterParser)
             .filter(crate::filters::DottedPascalCaseFilterParser)
             .filter(crate::filters::SnakeCaseFilterParser)
             .filter(crate::filters::HttpWildcardFilterParser);
         builder
             .build()
-            .expect("can't fail due to no partials support")
+            .context("Template error: unable to build parser")
+    }
+
+    fn partials(&self) -> anyhow::Result<impl liquid::partials::PartialCompiler> {
+        let mut partials = PartialsBuilder::empty();
+
+        if let Some(partials_dir) = self.template.partials_dir() {
+            let partials_dir = std::fs::read_dir(partials_dir)
+                .context("Error opening template partials directory")?;
+            for partial_file in partials_dir {
+                let partial_file =
+                    partial_file.context("Error scanning template partials directory")?;
+                if !partial_file.file_type().is_ok_and(|t| t.is_file()) {
+                    anyhow::bail!("Non-file in partials directory: {partial_file:?}");
+                }
+                let partial_name = partial_file
+                    .file_name()
+                    .into_string()
+                    .map_err(|f| anyhow!("Unusable partial name {f:?}"))?;
+                let partial_file = partial_file.path();
+                let content = std::fs::read_to_string(&partial_file)
+                    .with_context(|| format!("Invalid partial template {partial_file:?}"))?;
+                partials.add(partial_name, content);
+            }
+        }
+
+        Ok(partials)
     }
 }
 
@@ -418,7 +466,8 @@ mod test {
             "kebabby": "originally-kebabby",
             "dotted": "originally.semi-dotted"
         });
-        let parser = Run::template_parser();
+        let no_partials = super::PartialsBuilder::empty();
+        let parser = Run::template_parser(no_partials).unwrap();
 
         let eval = |s: &str| parser.parse(s).unwrap().render(&data).unwrap();
 

crates/templates/src/store.rs

@@ -68,6 +68,7 @@ pub(crate) struct TemplateLayout {
 const METADATA_DIR_NAME: &str = "metadata";
 const CONTENT_DIR_NAME: &str = "content";
 const SNIPPETS_DIR_NAME: &str = "snippets";
+const PARTIALS_DIR_NAME: &str = "partials";
 
 const MANIFEST_FILE_NAME: &str = "spin-template.toml";
 
@@ -96,6 +97,10 @@ impl TemplateLayout {
         self.metadata_dir().join(SNIPPETS_DIR_NAME)
     }
 
+    pub fn partials_dir(&self) -> PathBuf {
+        self.metadata_dir().join(PARTIALS_DIR_NAME)
+    }
+
     pub fn installation_record_file(&self) -> PathBuf {
         self.template_dir.join(INSTALLATION_RECORD_FILE_NAME)
     }

crates/templates/src/template.rs

@@ -30,6 +30,7 @@ pub struct Template {
     parameters: Vec<TemplateParameter>,
     extra_outputs: Vec<ExtraOutputAction>,
     snippets_dir: Option<PathBuf>,
+    partials_dir: Option<PathBuf>,
     content_dir: Option<PathBuf>, // TODO: maybe always need a spin.toml file in there?
 }
 
@@ -184,6 +185,12 @@ impl Template {
             None
         };
 
+        let partials_dir = if layout.partials_dir().exists() {
+            Some(layout.partials_dir())
+        } else {
+            None
+        };
+
         let installed_from = read_install_record(layout);
 
         let template = match raw {
@@ -197,6 +204,7 @@ impl Template {
                 parameters: Self::parse_parameters(&raw.parameters)?,
                 extra_outputs: Self::parse_extra_outputs(&raw.outputs)?,
                 snippets_dir,
+                partials_dir,
                 content_dir,
             },
         };
@@ -294,6 +302,10 @@ impl Template {
         &self.snippets_dir
     }
 
+    pub(crate) fn partials_dir(&self) -> &Option<PathBuf> {
+        &self.partials_dir
+    }
+
     /// Checks if the template supports the specified variant mode.
     pub fn supports_variant(&self, variant: &TemplateVariantInfo) -> bool {
         self.variants.contains_key(&variant.kind())
@@ -753,6 +765,7 @@ mod test {
             parameters: vec![],
             extra_outputs: vec![],
             snippets_dir: None,
+            partials_dir: None,
             content_dir: None,
         };
 

crates/templates/tests/templates/partials/content/test.txt

@@ -0,0 +1,3 @@
+Value: {{ example-value }}
+Partial 1: {% render 'p1' %}
+Partial 2: {% render 'p2', value: example-value %}

crates/templates/tests/templates/partials/metadata/partials/p1.liquid

@@ -0,0 +1 @@
+Hello from P1

crates/templates/tests/templates/partials/metadata/partials/p2.liquid

@@ -0,0 +1 @@
+Value is {{ value }}

crates/templates/tests/templates/partials/metadata/spin-template.toml

@@ -0,0 +1,7 @@
+manifest_version = "1"
+id = "partials"
+description = "Tests Liquid partials"
+trigger_type = "http"
+
+[parameters]
+example-value = { type = "string", prompt = "Example value" }