Refactor markdown generation using a method object

2 files changed, 61 insertions, 21 deletions

diff --git a/src/generator/generation.rs b/src/generator/generation.rs
new file mode 100644
index 0000000..4235cd2
--- /dev/null
+++ b/src/generator/generation.rs
@@ -0,0 +1,55 @@
+use std::{collections::HashSet, io::Write, path::Path};
+
+use crate::{
+    logger::Logger,
+    normalizer::{NormalizeError, NormalizedPath, Normalizer},
+    renderer::Renderer,
+    util::path_display::display_path,
+};
+
+use super::MarkdownGenerator;
+
+pub(super) struct MarkdownGeneration<'a, W: Write> {
+    logger: Logger,
+    normalizer: Normalizer,
+    paths: &'a [&'a Path],
+    project_title: String,
+    renderer: Renderer<W>,
+    seen_paths: HashSet<NormalizedPath>,
+}
+
+impl<'a, W: Write> MarkdownGeneration<'a, W> {
+    pub fn new(generator: MarkdownGenerator<'a>, output: W) -> Result<Self, NormalizeError> {
+        let renderer =
+            Renderer::new(output, generator.render_options).with_logger(generator.logger);
+        Ok(Self {
+            logger: generator.logger,
+            normalizer: Normalizer::new(generator.root, generator.origin_base)?,
+            paths: generator.paths,
+            project_title: generator.get_or_derive_project_title().to_string(),
+            renderer,
+            seen_paths: HashSet::new(),
+        })
+    }
+
+    pub fn run(mut self) -> Result<(), Box<dyn std::error::Error>> {
+        self.renderer.render_header(&self.project_title)?;
+        for path in self.paths {
+            self.render_path(path)?;
+        }
+        Ok(())
+    }
+
+    fn render_path(&mut self, path: &Path) -> Result<(), Box<dyn std::error::Error>> {
+        let normalized_path = self.normalizer.normalize(path)?;
+        if self.seen_paths.insert(normalized_path.clone()) {
+            self.renderer.render_path(&normalized_path)?;
+        } else {
+            self.logger.warn(format!(
+                "skipping duplicate file: {}",
+                display_path(&normalized_path.root_relative)
+            ));
+        }
+        Ok(())
+    }
+}
diff --git a/src/generator/mod.rs b/src/generator/mod.rs
index 5c0b84a..07bdf1f 100644
--- a/src/generator/mod.rs
+++ b/src/generator/mod.rs
@@ -1,10 +1,10 @@
-use std::{collections::HashSet, io::Write, path::Path};
+mod generation;
+
+use std::{io::Write, path::Path};
 
 use crate::{
-    logger::Logger,
-    normalizer::Normalizer,
-    renderer::{RenderOptions, Renderer},
-    util::{fence::generate_outer_backticks, path_display::display_path},
+    generator::generation::MarkdownGeneration, logger::Logger, renderer::RenderOptions,
+    util::fence::generate_outer_backticks,
 };
 
 const DEFAULT_PROJECT_NAME: &str = "Project Outline";
@@ -68,22 +68,7 @@ impl<'a> MarkdownGenerator<'a> {
     }
 
     pub fn generate<W: Write>(self, output: W) -> Result<(), Box<dyn std::error::Error>> {
-        let normalizer = Normalizer::new(self.root, self.origin_base)?;
-        let mut renderer = Renderer::new(output, self.render_options).with_logger(self.logger);
-        renderer.render_header(self.get_or_derive_project_title())?;
-        let mut seen_paths = HashSet::new();
-        for path in self.paths {
-            let normalized_path = normalizer.normalize(path)?;
-            if !seen_paths.insert(normalized_path.clone()) {
-                self.logger.warn(format!(
-                    "skipping duplicate file: {}",
-                    display_path(&normalized_path.root_relative)
-                ));
-                continue;
-            }
-            renderer.render_path(&normalized_path)?;
-        }
-        Ok(())
+        MarkdownGeneration::new(self, output)?.run()
     }
 
     pub fn generate_fenced<W: Write>(