Change where minification happens

* `write_content` isn't smart enough to do what we need.
* this is a cleaner architecture.
* Now pages with txt templates are not minified.
* Add test for text template whitespace preservation with minification
  * Test verifies that non-HTML templates (e.g., .txt) preserve whitespace
  * Created text_content.txt template with multiple spaces, tabs, and newlines
  * Created test page using the text template
  * Test passes with the minification fix (ed36c1e6) and fails without it
  * Updated page count assertions due to new test page

Author: EvanCarroll

.gitattributes

@@ -0,0 +1,2 @@
+# Preserve exact line endings in test templates (no normalization)
+test_site/templates/*.txt -text

components/site/src/lib.rs

@@ -653,6 +653,11 @@ impl Site {
         clean_site_output_folder(&self.output_path, self.config.preserve_dotfiles_in_output)
     }
 
+    /// Minify HTML content if minification is enabled.
+    fn maybe_minify(&self, content: String) -> Result<String> {
+        if self.config.minify_html { minify::html(content) } else { Ok(content) }
+    }
+
     /// Handles whether to write to disk or to memory
     pub fn write_content(
         &self,
@@ -668,19 +673,11 @@ impl Site {
             site_path.push(component);
         }
 
-        let final_content = if !filename.ends_with("html") || !self.config.minify_html {
-            content
-        } else {
-            match minify::html(content) {
-                Ok(minified_content) => minified_content,
-                Err(error) => bail!(error),
-            }
-        };
-
+        // Content is assumed to already be finalized (minified if needed)
         match self.build_mode {
             BuildMode::Disk | BuildMode::Both => {
                 let end_path = current_path.join(filename);
-                create_file(&end_path, &final_content)?;
+                create_file(&end_path, &content)?;
             }
             _ => (),
         }
@@ -689,7 +686,7 @@ impl Site {
                 let site_path =
                     if filename != "index.html" { site_path.join(filename) } else { site_path };
 
-                SITE_CONTENT.write().unwrap().insert(site_path, final_content);
+                SITE_CONTENT.write().unwrap().insert(site_path, content);
             }
             _ => (),
         }
@@ -720,8 +717,19 @@ impl Site {
 
         let output = page.render_html(&self.tera, &self.config, &self.library.read().unwrap())?;
         let content = self.inject_livereload(output);
+
+        // Determine if we should minify based on template extension
+        let template = page.meta.template.as_deref().unwrap_or("page.html");
+        let final_content = if template.to_lowercase().ends_with(".html")
+            || template.to_lowercase().ends_with(".htm")
+        {
+            self.maybe_minify(content)?
+        } else {
+            content
+        };
+
         let components: Vec<&str> = page.path.split('/').collect();
-        let current_path = self.write_content(&components, "index.html", content)?;
+        let current_path = self.write_content(&components, "index.html", final_content)?;
 
         // Copy any asset we found previously into the same directory as the index.html
         self.copy_assets(page.file.path.parent().unwrap(), &page.assets, &current_path)?;
@@ -889,7 +897,11 @@ impl Site {
             None => "index.html",
         };
         let content = render_redirect_template(permalink, &self.tera)?;
-        self.write_content(&split, page_name, content)?;
+
+        // Aliases are always HTML redirects - minify if enabled
+        let final_content = self.maybe_minify(content)?;
+
+        self.write_content(&split, page_name, final_content)?;
         Ok(())
     }
 
@@ -917,7 +929,11 @@ impl Site {
         context.insert("lang", &self.config.default_language);
         let output = render_template("404.html", &self.tera, context, &self.config.theme)?;
         let content = self.inject_livereload(output);
-        self.write_content(&[], "404.html", content)?;
+
+        // 404.html is always HTML - minify if enabled
+        let final_content = self.maybe_minify(content)?;
+
+        self.write_content(&[], "404.html", final_content)?;
         Ok(())
     }
 
@@ -926,6 +942,8 @@ impl Site {
         let mut context = Context::new();
         context.insert("config", &self.config.serialize(&self.config.default_language));
         let content = render_template("robots.txt", &self.tera, context, &self.config.theme)?;
+
+        // robots.txt is plain text - never minify
         self.write_content(&[], "robots.txt", content)?;
         Ok(())
     }
@@ -961,7 +979,11 @@ impl Site {
         let list_output =
             taxonomy.render_all_terms(&self.tera, &self.config, &self.library.read().unwrap())?;
         let content = self.inject_livereload(list_output);
-        self.write_content(&components, "index.html", content)?;
+
+        // Taxonomy list pages are always HTML - minify if enabled
+        let final_content = self.maybe_minify(content)?;
+
+        self.write_content(&components, "index.html", final_content)?;
 
         let library = self.library.read().unwrap();
         taxonomy
@@ -986,7 +1008,11 @@ impl Site {
                     let single_output =
                         taxonomy.render_term(item, &self.tera, &self.config, &library)?;
                     let content = self.inject_livereload(single_output);
-                    self.write_content(&comp, "index.html", content)?;
+
+                    // Taxonomy term pages are always HTML - minify if enabled
+                    let final_content = self.maybe_minify(content)?;
+
+                    self.write_content(&comp, "index.html", final_content)?;
                 }
 
                 if taxonomy.kind.feed {
@@ -1044,6 +1070,8 @@ impl Site {
             let mut context = Context::new();
             context.insert("entries", &all_sitemap_entries);
             let sitemap = render_template("sitemap.xml", &self.tera, context, &self.config.theme)?;
+
+            // Sitemaps are XML - never minify
             self.write_content(&[], "sitemap.xml", sitemap)?;
             return Ok(());
         }
@@ -1056,6 +1084,8 @@ impl Site {
             let mut context = Context::new();
             context.insert("entries", &chunk);
             let sitemap = render_template("sitemap.xml", &self.tera, context, &self.config.theme)?;
+
+            // Sitemaps are XML - never minify
             let file_name = format!("sitemap{}.xml", i + 1);
             self.write_content(&[], &file_name, sitemap)?;
             let mut sitemap_url = self.config.make_permalink(&file_name);
@@ -1072,6 +1102,8 @@ impl Site {
             main_context,
             &self.config.theme,
         )?;
+
+        // Sitemap index is XML - never minify
         self.write_content(&[], "sitemap.xml", sitemap)?;
 
         Ok(())
@@ -1096,6 +1128,7 @@ impl Site {
         for (feed, feed_filename) in
             feeds.into_iter().zip(self.config.languages[lang].feed_filenames.iter())
         {
+            // Feeds are XML - never minify
             if let Some(base) = base_path {
                 let mut components = Vec::new();
                 for component in base.components() {
@@ -1164,11 +1197,12 @@ impl Site {
             } else {
                 Cow::Owned(self.config.make_permalink(redirect_to))
             };
-            self.write_content(
-                &components,
-                "index.html",
-                render_redirect_template(&permalink, &self.tera)?,
-            )?;
+            let content = render_redirect_template(&permalink, &self.tera)?;
+
+            // Section redirects are always HTML - minify if enabled
+            let final_content = self.maybe_minify(content)?;
+
+            self.write_content(&components, "index.html", final_content)?;
 
             return Ok(());
         }
@@ -1182,7 +1216,11 @@ impl Site {
             let output =
                 section.render_html(&self.tera, &self.config, &self.library.read().unwrap())?;
             let content = self.inject_livereload(output);
-            self.write_content(&components, "index.html", content)?;
+
+            // Section pages are always HTML - minify if enabled
+            let final_content = self.maybe_minify(content)?;
+
+            self.write_content(&components, "index.html", final_content)?;
         }
 
         Ok(())
@@ -1233,15 +1271,20 @@ impl Site {
                 )?;
                 let content = self.inject_livereload(output);
 
+                // Pagination pages are always HTML - minify if enabled
+                let final_content = self.maybe_minify(content)?;
+
                 if pager.index > 1 {
-                    self.write_content(&pager_components, "index.html", content)?;
+                    self.write_content(&pager_components, "index.html", final_content)?;
                 } else {
-                    self.write_content(&index_components, "index.html", content)?;
-                    self.write_content(
-                        &pager_components,
-                        "index.html",
-                        render_redirect_template(&paginator.permalink, &self.tera)?,
-                    )?;
+                    self.write_content(&index_components, "index.html", final_content)?;
+
+                    // The redirect for page 1 is also HTML
+                    let redirect_content =
+                        render_redirect_template(&paginator.permalink, &self.tera)?;
+                    let final_redirect = self.maybe_minify(redirect_content)?;
+
+                    self.write_content(&pager_components, "index.html", final_redirect)?;
                 }
 
                 Ok(())

components/site/tests/site.rs

@@ -22,7 +22,7 @@ fn can_parse_site() {
     let library = site.library.read().unwrap();
 
     // Correct number of pages (sections do not count as pages, draft are ignored)
-    assert_eq!(library.pages.len(), 36);
+    assert_eq!(library.pages.len(), 37);
     let posts_path = path.join("content").join("posts");
 
     // Make sure the page with a url doesn't have any sections
@@ -45,7 +45,7 @@ fn can_parse_site() {
 
     let posts_section = library.sections.get(&posts_path.join("_index.md")).unwrap();
     assert_eq!(posts_section.subsections.len(), 2);
-    assert_eq!(posts_section.pages.len(), 10); // 11 with 1 draft == 10
+    assert_eq!(posts_section.pages.len(), 11); // 12 with 1 draft == 11
     assert_eq!(posts_section.ancestors, vec![index_section.file.relative.clone()]);
 
     // Make sure we remove all the pwd + content from the sections
@@ -445,7 +445,7 @@ fn can_build_site_with_pagination_for_section() {
         "posts/page/1/index.html",
         "http-equiv=\"refresh\" content=\"0; url=https://replace-this-with-your-url.com/posts/\""
     ));
-    assert!(file_contains!(public, "posts/index.html", "Num pagers: 5"));
+    assert!(file_contains!(public, "posts/index.html", "Num pagers: 6"));
     assert!(file_contains!(public, "posts/index.html", "Page size: 2"));
     assert!(file_contains!(public, "posts/index.html", "Current index: 1"));
     assert!(!file_contains!(public, "posts/index.html", "has_prev"));
@@ -458,12 +458,12 @@ fn can_build_site_with_pagination_for_section() {
     assert!(file_contains!(
         public,
         "posts/index.html",
-        "Last: https://replace-this-with-your-url.com/posts/page/5/"
+        "Last: https://replace-this-with-your-url.com/posts/page/6/"
     ));
     assert!(!file_contains!(public, "posts/index.html", "has_prev"));
 
     assert!(file_exists!(public, "posts/page/2/index.html"));
-    assert!(file_contains!(public, "posts/page/2/index.html", "Num pagers: 5"));
+    assert!(file_contains!(public, "posts/page/2/index.html", "Num pagers: 6"));
     assert!(file_contains!(public, "posts/page/2/index.html", "Page size: 2"));
     assert!(file_contains!(public, "posts/page/2/index.html", "Current index: 2"));
     assert!(file_contains!(public, "posts/page/2/index.html", "has_prev"));
@@ -476,11 +476,11 @@ fn can_build_site_with_pagination_for_section() {
     assert!(file_contains!(
         public,
         "posts/page/2/index.html",
-        "Last: https://replace-this-with-your-url.com/posts/page/5/"
+        "Last: https://replace-this-with-your-url.com/posts/page/6/"
     ));
 
     assert!(file_exists!(public, "posts/page/3/index.html"));
-    assert!(file_contains!(public, "posts/page/3/index.html", "Num pagers: 5"));
+    assert!(file_contains!(public, "posts/page/3/index.html", "Num pagers: 6"));
     assert!(file_contains!(public, "posts/page/3/index.html", "Page size: 2"));
     assert!(file_contains!(public, "posts/page/3/index.html", "Current index: 3"));
     assert!(file_contains!(public, "posts/page/3/index.html", "has_prev"));
@@ -493,11 +493,11 @@ fn can_build_site_with_pagination_for_section() {
     assert!(file_contains!(
         public,
         "posts/page/3/index.html",
-        "Last: https://replace-this-with-your-url.com/posts/page/5/"
+        "Last: https://replace-this-with-your-url.com/posts/page/6/"
     ));
 
     assert!(file_exists!(public, "posts/page/4/index.html"));
-    assert!(file_contains!(public, "posts/page/4/index.html", "Num pagers: 5"));
+    assert!(file_contains!(public, "posts/page/4/index.html", "Num pagers: 6"));
     assert!(file_contains!(public, "posts/page/4/index.html", "Page size: 2"));
     assert!(file_contains!(public, "posts/page/4/index.html", "Current index: 4"));
     assert!(file_contains!(public, "posts/page/4/index.html", "has_prev"));
@@ -510,7 +510,7 @@ fn can_build_site_with_pagination_for_section() {
     assert!(file_contains!(
         public,
         "posts/page/4/index.html",
-        "Last: https://replace-this-with-your-url.com/posts/page/5/"
+        "Last: https://replace-this-with-your-url.com/posts/page/6/"
     ));
 
     // sitemap contains the pager pages
@@ -932,16 +932,44 @@ fn can_find_site_and_page_authors() {
     let posts_path = path.join("content").join("posts");
     let posts_section = library.sections.get(&posts_path.join("_index.md")).unwrap();
 
-    let p1 = &library.pages[&posts_section.pages[0]];
-    let p2 = &library.pages[&posts_section.pages[1]];
+    // Find the page with an author (transparent-page.md)
+    let transparent_page =
+        library.pages.get(&posts_path.join("2018").join("transparent-page.md")).unwrap();
+    assert_eq!(1, transparent_page.meta.authors.len());
+    assert_eq!("[email protected] (Page Author)", transparent_page.meta.authors.first().unwrap());
 
-    // Only the first page has had an author added.
-    assert_eq!(1, p1.meta.authors.len());
-    assert_eq!("[email protected] (Page Author)", p1.meta.authors.first().unwrap());
-    assert_eq!(0, p2.meta.authors.len());
+    // Find a page without an author (simple.md)
+    let simple_page = library.pages.get(&posts_path.join("simple.md")).unwrap();
+    assert_eq!(0, simple_page.meta.authors.len());
 }
 
 // Follows test_site/themes/sample/templates/current_path.html
 fn current_path(path: &str) -> String {
     format!("[current_path]({})", path)
 }
+
+#[test]
+fn can_preserve_whitespace_in_text_templates_with_minification() {
+    let (_, _tmp_dir, public) = build_site_with_setup("test_site", |mut site| {
+        site.config.minify_html = true;
+        (site, true)
+    });
+
+    assert!(&public.exists());
+
+    // The page with text template should exist
+    assert!(file_exists!(public, "posts/text-template-test/index.html"));
+
+    // Verify that multiple spaces are preserved (not collapsed by minification)
+    assert!(file_contains!(public, "posts/text-template-test/index.html", "multiple   spaces"));
+
+    // Verify that tabs are preserved
+    assert!(file_contains!(public, "posts/text-template-test/index.html", "tabs\tbetween"));
+
+    // Verify that multiple newlines are preserved
+    assert!(file_contains!(
+        public,
+        "posts/text-template-test/index.html",
+        "Line 1\nLine 2\nLine 3"
+    ));
+}

test_site/content/posts/text-template-test.md

@@ -0,0 +1,8 @@
++++
+title = "Text Template Test"
+description = "Testing text template with minification"
+date = 2024-01-15
+template = "text_content.txt"
++++
+
+This page uses a text template and should preserve whitespace even when minify_html is enabled.

test_site/templates/text_content.txt

@@ -0,0 +1,12 @@
+Title: {{ page.title }}
+
+Date: {{ page.date }}
+
+Content with   multiple   spaces
+And    tabs	between    words
+
+Line 1
+Line 2
+Line 3
+
+End of text file