Merge pull request #284 from egohygiene/copilot/implement-file-based-caching

Extend cache hashing to cover config file and template file contents

Author: szmyty

src/cache.rs

@@ -38,16 +38,26 @@ impl OutputCache {
 /// * transformed document content (post-transform pipeline)
 /// * output type string (e.g. `"html"`, `"pdf"`, `"docx"`)
 /// * optional template name (empty string when absent)
+/// * optional template file content (empty string when absent or unreadable)
 ///
 /// A change to any of these fields produces a different hash, causing a cache
-/// miss and triggering a fresh pandoc run.
-pub fn compute_output_hash(transformed_content: &str, output_type: &str, template: Option<&str>) -> String {
+/// miss and triggering a fresh pandoc run.  Including the template file content
+/// (not just its name) means that editing a template file invalidates cached
+/// render outputs even when the template path has not changed.
+pub fn compute_output_hash(
+    transformed_content: &str,
+    output_type: &str,
+    template: Option<&str>,
+    template_content: Option<&str>,
+) -> String {
     let mut hasher = Sha256::new();
     hasher.update(transformed_content.as_bytes());
     hasher.update(b"\x00output-type\x00");
     hasher.update(output_type.as_bytes());
     hasher.update(b"\x00template\x00");
     hasher.update(template.unwrap_or("").as_bytes());
+    hasher.update(b"\x00template-content\x00");
+    hasher.update(template_content.unwrap_or("").as_bytes());
     format!("{:x}", hasher.finalize())
 }
 
@@ -116,13 +126,22 @@ impl TransformCache {
 ///
 /// The hash covers:
 /// * normalized input file content
+/// * config file content (raw YAML bytes)
 /// * variables (sorted for determinism, regardless of map insertion order)
 ///
 /// This hash uniquely identifies a combination of inputs so that a cache hit
-/// guarantees the transform pipeline would produce the same output.
-pub fn compute_input_hash(content: &str, variables: &HashMap<String, String>) -> String {
+/// guarantees the transform pipeline would produce the same output.  Including
+/// the raw config file content means that any change to the config (not only
+/// to `variables`) invalidates the transform cache.
+pub fn compute_input_hash(
+    content: &str,
+    config_content: &str,
+    variables: &HashMap<String, String>,
+) -> String {
     let mut hasher = Sha256::new();
     hasher.update(content.as_bytes());
+    hasher.update(b"\x00config\x00");
+    hasher.update(config_content.as_bytes());
 
     // Sort entries so the hash is stable regardless of HashMap iteration order.
     let mut sorted: Vec<(&String, &String)> = variables.iter().collect();
@@ -324,46 +343,60 @@ mod tests {
 
     #[test]
     fn test_same_inputs_produce_same_hash() {
-        let h1 = compute_input_hash("hello world", &vars(&[("key", "val")]));
-        let h2 = compute_input_hash("hello world", &vars(&[("key", "val")]));
+        let h1 = compute_input_hash("hello world", "", &vars(&[("key", "val")]));
+        let h2 = compute_input_hash("hello world", "", &vars(&[("key", "val")]));
         assert_eq!(h1, h2);
     }
 
     #[test]
     fn test_different_content_produces_different_hash() {
-        let h1 = compute_input_hash("content A", &vars(&[]));
-        let h2 = compute_input_hash("content B", &vars(&[]));
+        let h1 = compute_input_hash("content A", "", &vars(&[]));
+        let h2 = compute_input_hash("content B", "", &vars(&[]));
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_different_variables_produce_different_hash() {
-        let h1 = compute_input_hash("same content", &vars(&[("k", "v1")]));
-        let h2 = compute_input_hash("same content", &vars(&[("k", "v2")]));
+        let h1 = compute_input_hash("same content", "", &vars(&[("k", "v1")]));
+        let h2 = compute_input_hash("same content", "", &vars(&[("k", "v2")]));
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_variable_order_does_not_affect_hash() {
-        let h1 = compute_input_hash("content", &vars(&[("a", "1"), ("b", "2")]));
-        let h2 = compute_input_hash("content", &vars(&[("b", "2"), ("a", "1")]));
+        let h1 = compute_input_hash("content", "", &vars(&[("a", "1"), ("b", "2")]));
+        let h2 = compute_input_hash("content", "", &vars(&[("b", "2"), ("a", "1")]));
         assert_eq!(h1, h2);
     }
 
     #[test]
     fn test_empty_variables_produces_stable_hash() {
-        let h1 = compute_input_hash("content", &vars(&[]));
-        let h2 = compute_input_hash("content", &vars(&[]));
+        let h1 = compute_input_hash("content", "", &vars(&[]));
+        let h2 = compute_input_hash("content", "", &vars(&[]));
         assert_eq!(h1, h2);
     }
 
     #[test]
     fn test_hash_is_hex_string() {
-        let h = compute_input_hash("test", &vars(&[]));
+        let h = compute_input_hash("test", "", &vars(&[]));
         assert!(h.chars().all(|c| c.is_ascii_hexdigit()), "hash must be hex: {h}");
         assert_eq!(h.len(), 64, "SHA-256 hex must be 64 chars");
     }
 
+    #[test]
+    fn test_different_config_content_produces_different_hash() {
+        let h1 = compute_input_hash("same content", "config: a", &vars(&[]));
+        let h2 = compute_input_hash("same content", "config: b", &vars(&[]));
+        assert_ne!(h1, h2);
+    }
+
+    #[test]
+    fn test_empty_config_content_differs_from_nonempty() {
+        let h1 = compute_input_hash("content", "", &vars(&[]));
+        let h2 = compute_input_hash("content", "outputs:\n  - type: html\n", &vars(&[]));
+        assert_ne!(h1, h2);
+    }
+
     // ── TransformCache ───────────────────────────────────────────────────────
 
     #[test]
@@ -438,46 +471,60 @@ mod tests {
 
     #[test]
     fn test_output_hash_same_inputs_stable() {
-        let h1 = compute_output_hash("content", "html", None);
-        let h2 = compute_output_hash("content", "html", None);
+        let h1 = compute_output_hash("content", "html", None, None);
+        let h2 = compute_output_hash("content", "html", None, None);
         assert_eq!(h1, h2);
     }
 
     #[test]
     fn test_output_hash_different_output_type_differs() {
-        let h1 = compute_output_hash("content", "html", None);
-        let h2 = compute_output_hash("content", "pdf", None);
+        let h1 = compute_output_hash("content", "html", None, None);
+        let h2 = compute_output_hash("content", "pdf", None, None);
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_output_hash_different_template_differs() {
-        let h1 = compute_output_hash("content", "html", Some("a.html"));
-        let h2 = compute_output_hash("content", "html", Some("b.html"));
+        let h1 = compute_output_hash("content", "html", Some("a.html"), None);
+        let h2 = compute_output_hash("content", "html", Some("b.html"), None);
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_output_hash_no_template_differs_from_with_template() {
-        let h1 = compute_output_hash("content", "html", None);
-        let h2 = compute_output_hash("content", "html", Some("tmpl.html"));
+        let h1 = compute_output_hash("content", "html", None, None);
+        let h2 = compute_output_hash("content", "html", Some("tmpl.html"), None);
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_output_hash_different_content_differs() {
-        let h1 = compute_output_hash("content A", "html", None);
-        let h2 = compute_output_hash("content B", "html", None);
+        let h1 = compute_output_hash("content A", "html", None, None);
+        let h2 = compute_output_hash("content B", "html", None, None);
         assert_ne!(h1, h2);
     }
 
     #[test]
     fn test_output_hash_is_hex_string() {
-        let h = compute_output_hash("content", "html", None);
+        let h = compute_output_hash("content", "html", None, None);
         assert!(h.chars().all(|c| c.is_ascii_hexdigit()), "hash must be hex: {h}");
         assert_eq!(h.len(), 64, "SHA-256 hex must be 64 chars");
     }
 
+    #[test]
+    fn test_output_hash_different_template_content_differs() {
+        let h1 = compute_output_hash("content", "html", Some("t.html"), Some("<html>v1</html>"));
+        let h2 = compute_output_hash("content", "html", Some("t.html"), Some("<html>v2</html>"));
+        assert_ne!(h1, h2);
+    }
+
+    #[test]
+    fn test_output_hash_no_template_content_differs_from_some() {
+        let h1 = compute_output_hash("content", "html", Some("t.html"), None);
+        let h2 = compute_output_hash("content", "html", Some("t.html"), Some("<html></html>"));
+        assert_ne!(h1, h2);
+    }
+
     // ── OutputCache ──────────────────────────────────────────────────────────
 
     #[test]

src/commands/build.rs

@@ -45,6 +45,12 @@ fn run_impl(config_path: &str, dry_run: bool, resilient: bool, optimization: Opt
     let config = load_config(config_path)?;
     info!("Loaded config successfully");
 
+    // Read the raw config file content so it can be included in the transform
+    // cache hash.  Any change to the config file (not only to `variables`) will
+    // then invalidate the cached transform results and force a fresh pipeline run.
+    let config_content = fs::read_to_string(config_path)
+        .with_context(|| format!("Failed to re-read config file for hashing: {}", config_path))?;
+
     // CLI flag takes precedence over config file; fall back to config value.
     let opt_mode = optimization.unwrap_or(config.optimization);
     info!(optimization = %opt_mode, "Using optimization mode");
@@ -115,7 +121,7 @@ fn run_impl(config_path: &str, dry_run: bool, resilient: bool, optimization: Opt
     // because some transforms are format-specific.  In particular, EmojiTransform skips
     // replacement for HTML (which renders emoji natively) but applies it for PDF, DOCX,
     // and other formats.  A format-keyed cache avoids redundant work across builds.
-    let base_input_hash = compute_input_hash(&normalized_content, &config.variables);
+    let base_input_hash = compute_input_hash(&normalized_content, &config_content, &config.variables);
     let cache_path = output_dir.join(".renderflow-cache.json");
     // Always attempt to read the cache; load_cache handles missing/corrupt files
     // gracefully.  Only write back to disk in non-dry-run mode.
@@ -217,8 +223,30 @@ fn run_impl(config_path: &str, dry_run: bool, resilient: bool, optimization: Opt
         } else {
             // Compute a hash of all inputs that determine this output's content.
             // If the stored hash matches and the output file already exists, pandoc
-            // can be skipped entirely.
-            let output_hash = compute_output_hash(&transformed, &format_str, output.template.as_deref());
+            // can be skipped entirely.  The template file content (not just its
+            // name) is included so that edits to a template file invalidate the
+            // output cache even when the template path is unchanged.
+            let template_content = output.template.as_deref().and_then(|name| {
+                let path = Path::new("templates").join(name);
+                match fs::read_to_string(&path) {
+                    Ok(content) => Some(content),
+                    Err(e) => {
+                        warn!(
+                            template = %name,
+                            path = %path.display(),
+                            error = %e,
+                            "Failed to read template file for cache hash; template changes may not invalidate cache"
+                        );
+                        None
+                    }
+                }
+            });
+            let output_hash = compute_output_hash(
+                &transformed,
+                &format_str,
+                output.template.as_deref(),
+                template_content.as_deref(),
+            );
 
             if Path::new(&output_path).exists()
                 && output_cache.get(&output_path) == Some(output_hash.as_str())
@@ -503,26 +531,29 @@ mod tests {
     #[test]
     fn test_cache_hit_uses_pre_populated_cache() {
         // Pre-populate the cache with the exact hash that the build would
-        // compute for the input file + format, then run a dry-run.  The build
-        // should detect the cache hit and skip the transform phase for that format.
+        // compute for the input file + config + format, then run a dry-run.
+        // The build should detect the cache hit and skip the transform phase
+        // for that format.
         let dir = tempfile::tempdir().expect("failed to create temp dir");
         let input_content = "# Test\n";
         let input_path = dir.path().join("input.md");
         fs::write(&input_path, input_content).expect("failed to write input file");
         let output_dir = dir.path().join("dist");
 
+        let config_content = format!(
+            "outputs:\n  - type: html\ninput: \"{}\"\noutput_dir: \"{}\"\n",
+            input_path.display(),
+            output_dir.display()
+        );
+
         // Compute the hash the same way the build command will: base hash + "-html".
+        // The hash now also incorporates the config file content.
         let variables = std::collections::HashMap::new();
-        let base_hash = crate::cache::compute_input_hash(input_content, &variables);
+        let base_hash = crate::cache::compute_input_hash(input_content, &config_content, &variables);
         let hash_key = format!("{base_hash}-html");
         let cached_transform = "# Test (from cache)\n";
         write_cache_file(&output_dir, &hash_key, cached_transform);
 
-        let config_content = format!(
-            "outputs:\n  - type: html\ninput: \"{}\"\noutput_dir: \"{}\"\n",
-            input_path.display(),
-            output_dir.display()
-        );
         let mut f = NamedTempFile::new().expect("failed to create temp file");
         f.write_all(config_content.as_bytes()).expect("failed to write config");
 
@@ -541,27 +572,63 @@ mod tests {
         fs::write(&input_path, original_content).expect("failed to write input file");
         let output_dir = dir.path().join("dist");
 
-        // Cache is keyed on the *original* content + format.
+        let config_content = format!(
+            "outputs:\n  - type: html\ninput: \"{}\"\noutput_dir: \"{}\"\n",
+            input_path.display(),
+            output_dir.display()
+        );
+
+        // Cache is keyed on the *original* content + config + format.
         let variables = std::collections::HashMap::new();
-        let old_base_hash = crate::cache::compute_input_hash(original_content, &variables);
+        let old_base_hash = crate::cache::compute_input_hash(original_content, &config_content, &variables);
         let old_hash_key = format!("{old_base_hash}-html");
         write_cache_file(&output_dir, &old_hash_key, "cached result");
 
         // Now change the input file — the hash will be different.
         let new_content = "# Changed\n";
         fs::write(&input_path, new_content).expect("failed to write updated input");
 
-        let config_content = format!(
+        let mut f = NamedTempFile::new().expect("failed to create temp file");
+        f.write_all(config_content.as_bytes()).expect("failed to write config");
+
+        // Dry-run still succeeds; it runs transforms because the hash misses.
+        let result = run(f.path().to_str().unwrap(), true, None);
+        assert!(result.is_ok(), "dry-run with cache miss should still succeed: {:?}", result);
+    }
+
+    #[test]
+    fn test_cache_miss_when_config_changed() {
+        // After changing the config content the hash changes, so the previously
+        // cached entry should not match and transforms must run again.
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        let input_content = "# Hello\n";
+        let input_path = dir.path().join("input.md");
+        fs::write(&input_path, input_content).expect("failed to write input file");
+        let output_dir = dir.path().join("dist");
+
+        // Original config — used to seed the cache.
+        let original_config = format!(
             "outputs:\n  - type: html\ninput: \"{}\"\noutput_dir: \"{}\"\n",
             input_path.display(),
             output_dir.display()
         );
+        let variables = std::collections::HashMap::new();
+        let old_base_hash = crate::cache::compute_input_hash(input_content, &original_config, &variables);
+        let old_hash_key = format!("{old_base_hash}-html");
+        write_cache_file(&output_dir, &old_hash_key, "cached result");
+
+        // Updated config (adds a variable) — the hash must differ from the original.
+        let updated_config = format!(
+            "outputs:\n  - type: html\ninput: \"{}\"\noutput_dir: \"{}\"\nvariables:\n  title: changed\n",
+            input_path.display(),
+            output_dir.display()
+        );
         let mut f = NamedTempFile::new().expect("failed to create temp file");
-        f.write_all(config_content.as_bytes()).expect("failed to write config");
+        f.write_all(updated_config.as_bytes()).expect("failed to write config");
 
-        // Dry-run still succeeds; it runs transforms because the hash misses.
+        // Dry-run succeeds; transforms run because the config hash misses.
         let result = run(f.path().to_str().unwrap(), true, None);
-        assert!(result.is_ok(), "dry-run with cache miss should still succeed: {:?}", result);
+        assert!(result.is_ok(), "dry-run with changed config should succeed: {:?}", result);
     }
 
     #[test]