1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
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(())
}
}
|
