Wire Pandoc-native template rendering into output strategies (#82)

Copilot · szmyty · web-flow · commit 30c6abef1a72 · 2026-03-23T23:24:52.000-04:00
* Initial plan * Wire template rendering into output strategies using Pandoc-native approach Co-authored-by: szmyty <14865041+szmyty@users.noreply.github.com> Agent-Logs-Url: https://github.com/egohygiene/renderflow/sessions/9fa2d768-a420-4783-abba-42f9d24533db --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: szmyty <14865041+szmyty@users.noreply.github.com>
diff --git a/src/commands/build.rs b/src/commands/build.rs
@@ -52,7 +52,22 @@ pub fn run(config_path: &str, dry_run: bool) -> Result<()> {
         .unwrap_or("document");
 
     let tera = init_tera("templates")?;
-    info!("Tera template engine initialised with {} template(s)", tera.get_template_names().count());
+    let template_count = tera.get_template_names().count();
+    info!("Tera template engine initialised with {} template(s)", template_count);
+
+    // Warn early if any configured template is not present in the templates directory.
+    for output in &config.outputs {
+        if let Some(ref name) = output.template {
+            if !tera.get_template_names().any(|n| n == name) {
+                warn!(
+                    template = %name,
+                    "Configured template '{}' was not found in the templates directory; \
+                     rendering will fail if this template is required.",
+                    name
+                );
+            }
+        }
+    }
 
     let output_formats: Vec<String> = config.outputs.iter().map(|o| o.output_type.to_string()).collect();
     if output_formats.is_empty() {
@@ -101,7 +116,7 @@ pub fn run(config_path: &str, dry_run: bool) -> Result<()> {
             pb.inc(1);
             pb.println(format!("[dry-run] Would write output to: {}", output_path));
         } else {
-            let strategy = select_strategy(format, output.template.clone())?;
+            let strategy = select_strategy(format, output.template.clone(), "templates".to_string())?;
             pipeline.add_step(Box::new(StrategyStep::new(strategy, &output_path)));
 
             pb.set_message(format!("[{format}] Rendering output"));
diff --git a/src/strategies/html.rs b/src/strategies/html.rs
@@ -1,4 +1,5 @@
 use anyhow::{Context, Result};
+use std::path::Path;
 use tracing::info;
 
 use crate::adapters::command::run_command;
@@ -7,18 +8,41 @@ use crate::strategies::OutputStrategy;
 /// Renders a document to HTML format using pandoc.
 pub struct HtmlStrategy {
     pub template: Option<String>,
+    pub template_dir: String,
 }
 
 impl HtmlStrategy {
-    pub fn new(template: Option<String>) -> Self {
-        Self { template }
+    pub fn new(template: Option<String>, template_dir: String) -> Self {
+        Self { template, template_dir }
     }
 }
 
 impl OutputStrategy for HtmlStrategy {
     fn render(&self, input: &str, output_path: &str) -> Result<()> {
         info!(input = %input, output = %output_path, template = ?self.template, "Rendering HTML via pandoc");
-        run_command("pandoc", &["--from", "markdown", input, "-o", output_path])
+
+        // Resolve the optional template to a file path within the template directory.
+        let template_path = if let Some(ref name) = self.template {
+            let path = Path::new(&self.template_dir).join(name);
+            if !path.exists() {
+                anyhow::bail!(
+                    "Template file not found: '{}'. \
+                     Ensure the template exists in the configured template directory.",
+                    path.display()
+                );
+            }
+            info!("Using template: {}", name);
+            Some(path.to_string_lossy().into_owned())
+        } else {
+            None
+        };
+
+        let mut args = vec!["--from", "markdown", input, "-o", output_path];
+        if let Some(ref path) = template_path {
+            args.extend_from_slice(&["--template", path.as_str()]);
+        }
+
+        run_command("pandoc", &args)
             .with_context(|| format!(
                 "Failed to render HTML output '{}'. \
                  Check that pandoc is installed (`pandoc --version`) and that the input file '{}' is valid Markdown.",
@@ -35,7 +59,7 @@ mod tests {
 
     #[test]
     fn test_html_strategy_errors_on_missing_input() {
-        let strategy = HtmlStrategy::new(None);
+        let strategy = HtmlStrategy::new(None, "templates".to_string());
         let result = strategy.render("/nonexistent/input.md", "/tmp/output.html");
         assert!(result.is_err());
         let msg = format!("{:#}", result.unwrap_err());
@@ -48,8 +72,41 @@ mod tests {
 
     #[test]
     fn test_html_strategy_stores_template() {
-        let strategy = HtmlStrategy::new(Some("default".to_string()));
-        assert_eq!(strategy.template, Some("default".to_string()));
+        let strategy = HtmlStrategy::new(Some("default.html".to_string()), "templates".to_string());
+        assert_eq!(strategy.template, Some("default.html".to_string()));
+    }
+
+    #[test]
+    fn test_html_strategy_missing_template_returns_clear_error() {
+        use std::io::Write;
+        use tempfile::NamedTempFile;
+
+        let mut input = NamedTempFile::new().unwrap();
+        writeln!(input, "# Hello\n\nThis is a test.").unwrap();
+
+        let strategy = HtmlStrategy::new(
+            Some("nonexistent.html".to_string()),
+            "/nonexistent/template/dir".to_string(),
+        );
+        let result = strategy.render(
+            input.path().to_str().unwrap(),
+            "/tmp/output.html",
+        );
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(
+            msg.contains("Template file not found"),
+            "error should mention missing template, got: {}",
+            msg
+        );
+    }
+
+    #[test]
+    fn test_html_strategy_no_template_does_not_check_template_dir() {
+        // When no template is configured the template_dir is never accessed,
+        // so a non-existent directory must not cause an error at construction time.
+        let strategy = HtmlStrategy::new(None, "/nonexistent/dir".to_string());
+        assert!(strategy.template.is_none());
     }
 
     #[test]
@@ -64,12 +121,42 @@ mod tests {
         let output = NamedTempFile::new().unwrap();
         let output_path = output.path().with_extension("html");
 
-        let strategy = HtmlStrategy::new(None);
+        let strategy = HtmlStrategy::new(None, "templates".to_string());
         let result = strategy.render(
             input.path().to_str().unwrap(),
             output_path.to_str().unwrap(),
         );
         assert!(result.is_ok());
         assert!(output_path.exists());
     }
+
+    #[test]
+    #[ignore = "requires pandoc to be installed"]
+    fn test_html_strategy_with_template_produces_output() {
+        use std::fs;
+        use std::io::Write;
+        use tempfile::{NamedTempFile, TempDir};
+
+        let template_dir = TempDir::new().unwrap();
+        let template_path = template_dir.path().join("custom.html");
+        // Use pandoc template syntax ($body$) rather than Tera syntax.
+        fs::write(&template_path, "$body$").unwrap();
+
+        let mut input = NamedTempFile::new().unwrap();
+        writeln!(input, "# Hello\n\nThis is a test.").unwrap();
+
+        let output = NamedTempFile::new().unwrap();
+        let output_path = output.path().with_extension("html");
+
+        let strategy = HtmlStrategy::new(
+            Some("custom.html".to_string()),
+            template_dir.path().to_str().unwrap().to_string(),
+        );
+        let result = strategy.render(
+            input.path().to_str().unwrap(),
+            output_path.to_str().unwrap(),
+        );
+        assert!(result.is_ok(), "expected render to succeed with a valid template: {:?}", result);
+        assert!(output_path.exists());
+    }
 }
diff --git a/src/strategies/pdf.rs b/src/strategies/pdf.rs
@@ -1,5 +1,6 @@
 use anyhow::{Context, Result};
 use std::io::ErrorKind;
+use std::path::Path;
 use tracing::info;
 
 use crate::adapters::command::run_command;
@@ -8,11 +9,12 @@ use crate::strategies::OutputStrategy;
 /// Renders a document to PDF format using pandoc with the tectonic PDF engine.
 pub struct PdfStrategy {
     pub template: Option<String>,
+    pub template_dir: String,
 }
 
 impl PdfStrategy {
-    pub fn new(template: Option<String>) -> Self {
-        Self { template }
+    pub fn new(template: Option<String>, template_dir: String) -> Self {
+        Self { template, template_dir }
     }
 
     /// Returns an error if the tectonic PDF engine is not installed.
@@ -40,17 +42,35 @@ impl OutputStrategy for PdfStrategy {
 
         Self::check_tectonic()?;
 
-        run_command(
-            "pandoc",
-            &[
-                "--from",
-                "markdown",
-                input,
-                "-o",
-                output_path,
-                "--pdf-engine=tectonic",
-            ],
-        )
+        // Resolve the optional template to a file path within the template directory.
+        let template_path = if let Some(ref name) = self.template {
+            let path = Path::new(&self.template_dir).join(name);
+            if !path.exists() {
+                anyhow::bail!(
+                    "Template file not found: '{}'. \
+                     Ensure the template exists in the configured template directory.",
+                    path.display()
+                );
+            }
+            info!("Using template: {}", name);
+            Some(path.to_string_lossy().into_owned())
+        } else {
+            None
+        };
+
+        let mut args = vec![
+            "--from",
+            "markdown",
+            input,
+            "-o",
+            output_path,
+            "--pdf-engine=tectonic",
+        ];
+        if let Some(ref path) = template_path {
+            args.extend_from_slice(&["--template", path.as_str()]);
+        }
+
+        run_command("pandoc", &args)
         .with_context(|| format!(
             "Failed to render PDF output '{}'. \
              Check that pandoc and tectonic are installed (`pandoc --version`, `tectonic --version`) \
@@ -77,7 +97,7 @@ mod tests {
 
     #[test]
     fn test_pdf_strategy_errors_on_missing_input() {
-        let strategy = PdfStrategy::new(None);
+        let strategy = PdfStrategy::new(None, "templates".to_string());
         let result = strategy.render("/nonexistent/input.md", "/tmp/output.pdf");
         assert!(result.is_err());
         let msg = format!("{:#}", result.unwrap_err());
@@ -107,8 +127,16 @@ mod tests {
 
     #[test]
     fn test_pdf_strategy_stores_template() {
-        let strategy = PdfStrategy::new(Some("default".to_string()));
-        assert_eq!(strategy.template, Some("default".to_string()));
+        let strategy = PdfStrategy::new(Some("default.html".to_string()), "templates".to_string());
+        assert_eq!(strategy.template, Some("default.html".to_string()));
+    }
+
+    #[test]
+    fn test_pdf_strategy_no_template_does_not_check_template_dir() {
+        // When no template is configured the template_dir is never accessed,
+        // so a non-existent directory must not cause an error at construction time.
+        let strategy = PdfStrategy::new(None, "/nonexistent/dir".to_string());
+        assert!(strategy.template.is_none());
     }
 
     #[test]
@@ -123,7 +151,7 @@ mod tests {
         let output = NamedTempFile::new().unwrap();
         let output_path = output.path().with_extension("pdf");
 
-        let strategy = PdfStrategy::new(None);
+        let strategy = PdfStrategy::new(None, "templates".to_string());
         let result = strategy.render(
             input.path().to_str().unwrap(),
             output_path.to_str().unwrap(),
diff --git a/src/strategies/selector.rs b/src/strategies/selector.rs
@@ -5,12 +5,17 @@ use crate::strategies::{HtmlStrategy, OutputStrategy, PdfStrategy};
 
 /// Select an output strategy based on the given output type.
 ///
-/// The optional `template` name is forwarded to the chosen strategy so that it
-/// can reference the correct Tera template when rendering.
-pub fn select_strategy(output_type: OutputType, template: Option<String>) -> Result<Box<dyn OutputStrategy>> {
+/// The optional `template` name and `template_dir` are forwarded to the chosen
+/// strategy so that it can locate the correct template file when rendering.
+/// When `template` is `None` the strategy falls back to default pandoc behaviour.
+pub fn select_strategy(
+    output_type: OutputType,
+    template: Option<String>,
+    template_dir: String,
+) -> Result<Box<dyn OutputStrategy>> {
     match output_type {
-        OutputType::Html => Ok(Box::new(HtmlStrategy::new(template))),
-        OutputType::Pdf => Ok(Box::new(PdfStrategy::new(template))),
+        OutputType::Html => Ok(Box::new(HtmlStrategy::new(template, template_dir))),
+        OutputType::Pdf => Ok(Box::new(PdfStrategy::new(template, template_dir))),
     }
 }
 
@@ -20,26 +25,30 @@ mod tests {
 
     #[test]
     fn test_select_strategy_html() {
-        let result = select_strategy(OutputType::Html, None);
+        let result = select_strategy(OutputType::Html, None, "templates".to_string());
         assert!(result.is_ok(), "expected html strategy to be selected");
     }
 
     #[test]
     fn test_select_strategy_pdf() {
-        let result = select_strategy(OutputType::Pdf, None);
+        let result = select_strategy(OutputType::Pdf, None, "templates".to_string());
         assert!(result.is_ok(), "expected pdf strategy to be selected");
     }
 
     #[test]
     fn test_select_strategy_html_renders_error_on_missing_input() {
-        let strategy = select_strategy(OutputType::Html, None).unwrap();
+        let strategy = select_strategy(OutputType::Html, None, "templates".to_string()).unwrap();
         let result = strategy.render("/nonexistent/input.md", "/tmp/output.html");
         assert!(result.is_err());
     }
 
     #[test]
     fn test_select_strategy_passes_template_to_strategy() {
-        let strategy = select_strategy(OutputType::Html, Some("default".to_string()));
+        let strategy = select_strategy(
+            OutputType::Html,
+            Some("default.html".to_string()),
+            "templates".to_string(),
+        );
         assert!(strategy.is_ok());
     }
 }
