X-Git-Url: https://git.r.bdr.sh/rbdr/page/blobdiff_plain/1e2d00b62ecce95f71d4bfd60a043c8e86631eee..ad021007efdaced54b6351b4220d77fa8188309e:/src/file_handler/mod.rs diff --git a/src/file_handler/mod.rs b/src/file_handler/mod.rs index 8038b3c..cefe6a2 100644 --- a/src/file_handler/mod.rs +++ b/src/file_handler/mod.rs @@ -1,16 +1,26 @@ mod file_strategies; use file_strategies::file::Strategy as FileStrategy; +use file_strategies::gemini::Strategy as GeminiStrategy; +use file_strategies::layout::Strategy as LayoutStrategy; + use std::path::PathBuf; +use std::fs::read_to_string; pub struct FileHandler { - pub strategies: Vec> + pub strategies: Vec>, + pub layout: Option } impl Default for FileHandler { fn default() -> FileHandler { FileHandler { - strategies: vec![Box::new(FileStrategy{})] + strategies: vec![ + Box::new(GeminiStrategy{}), + Box::new(LayoutStrategy{}), + Box::new(FileStrategy{}), + ], + layout: None } } } @@ -25,22 +35,49 @@ impl FileHandler { FileType::Unknown } - pub fn handle(&self, path: &PathBuf) { - for strategy in self.strategies.iter() { - if strategy.can_handle(path) { - return strategy.handle(path); + pub fn get_layout_or_panic(&mut self, files: &[File]) -> Result<(), &str> { + for file in files { + match file.file_type { + FileType::Layout => { + let layout_text = read_to_string(&file.path).unwrap(); + self.layout = Some(layout_text); + return Ok(()); + }, + _ => {} } } + Err("No layout found. Please ensure there's a _layout.html file at the root") + } + + pub fn handle_all(&self, source: &PathBuf, html_destination: &PathBuf, gemini_destination: &PathBuf, files: &[File]) { + files.iter().for_each(|file| { + self.handle(source, html_destination, gemini_destination, file); + }); + } + + pub fn handle(&self, source: &PathBuf, html_destination: &PathBuf, gemini_destination: &PathBuf, file: &File) { + if let Some(strategy) = self.strategies + .iter() + .find(|s| s.can_handle(&file.file_type)) + { + let layout = self.layout.as_ref() + .expect("Layout should be initialized before handling files"); + strategy.handle_html(source, html_destination, file, layout); + strategy.handle_gemini(source, gemini_destination, file); + return; + } } } pub trait FileHandlerStrategy { fn is(&self, path: &PathBuf) -> bool; fn identify(&self) -> FileType; - fn can_handle(&self, path: &PathBuf) -> bool; - fn handle(&self, path: &PathBuf); + fn can_handle(&self, file_type: &FileType) -> bool; + fn handle_html(&self, source: &PathBuf, destination: &PathBuf, file: &File, layout: &str); + fn handle_gemini(&self, source: &PathBuf, destination: &PathBuf, file: &File); } +#[derive(Debug, Clone, PartialEq)] pub enum FileType { Gemini, File, @@ -48,7 +85,188 @@ pub enum FileType { Unknown, } +#[derive(PartialEq, Debug)] pub struct File { pub path: PathBuf, pub file_type: FileType, } + + +#[cfg(test)] +mod tests { + use std::path::PathBuf; + + use super::*; + + use test_utilities::*; + + fn create_test_internal_file(path: &str, file_type: FileType) -> File { + File { + path: PathBuf::from(path), + file_type, + } + } + + #[test] + fn test_identify_gemini_file() { + let handler = FileHandler::default(); + let path = PathBuf::from("test.gmi"); + assert!(matches!(handler.identify(&path), FileType::Gemini)); + } + + #[test] + fn test_identify_layout_file() { + let handler = FileHandler::default(); + let path = PathBuf::from("_layout.html"); + assert!(matches!(handler.identify(&path), FileType::Layout)); + } + + #[test] + fn test_identify_regular_file() { + let handler = FileHandler::default(); + let path = PathBuf::from("regular.html"); + assert!(matches!(handler.identify(&path), FileType::File)); + } + + #[test] + fn test_identify_unknown_file() { + let handler = FileHandler::default(); + let path = PathBuf::from("tests"); + assert!(matches!(handler.identify(&path), FileType::Unknown)); + } + + #[test] + fn test_get_layout_success() { + let test_dir = setup_test_dir(); + let layout_path = test_dir.join("_layout.html"); + create_test_file(&layout_path, ""); + + let mut handler = FileHandler::default(); + let files = vec![ + create_test_internal_file("test.gmi", FileType::Gemini), + create_test_internal_file(&layout_path.to_str().expect("Could not encode layout"), FileType::Layout), + create_test_internal_file("regular.html", FileType::File), + ]; + + assert!(handler.get_layout_or_panic(&files).is_ok()); + } + + #[test] + fn test_get_layout_failure() { + let mut handler = FileHandler::default(); + let files = vec![ + create_test_internal_file("test.gmi", FileType::Gemini), + create_test_internal_file("regular.html", FileType::File), + ]; + + assert!(handler.get_layout_or_panic(&files).is_err()); + } + + // Mock strategy for testing + struct MockStrategy { + is_match: bool, + file_type: FileType, + } + + impl FileHandlerStrategy for MockStrategy { + fn is(&self, _path: &PathBuf) -> bool { + self.is_match + } + + fn identify(&self) -> FileType { + self.file_type.clone() + } + + fn can_handle(&self, file_type: &FileType) -> bool { + &self.file_type == file_type + } + + fn handle_html(&self, _source: &PathBuf, _destination: &PathBuf, _file: &File, _layout: &str) {} + fn handle_gemini(&self, _source: &PathBuf, _destination: &PathBuf, _file: &File) {} + } + + #[test] + fn test_custom_strategy() { + let mock_strategy = MockStrategy { + is_match: true, + file_type: FileType::Gemini, + }; + + let handler = FileHandler { + strategies: vec![Box::new(mock_strategy)], + layout: None, + }; + + let path = PathBuf::from("test.whatever"); + assert!(matches!(handler.identify(&path), FileType::Gemini)); + } + + #[test] + fn test_handle_all_empty_files() { + let handler = FileHandler::default(); + let files: Vec = vec![]; + + // Should not panic with empty vector + handler.handle_all( + &PathBuf::from("source"), + &PathBuf::from("tests/fixtures/output"), + &PathBuf::from("tests/fixtures/output"), + &files + ); + } + + #[test] + fn test_handle_with_layout() { + let mut handler = FileHandler::default(); + handler.layout = Some("test layout".to_string()); + + let file = create_test_internal_file("tests/fixtures/test1.gmi", FileType::Gemini); + + // Should not panic with valid layout + handler.handle( + &PathBuf::from(""), + &PathBuf::from("tests/fixtures/output"), + &PathBuf::from("tests/fixtures/output"), + &file + ); + } + + #[test] + #[should_panic(expected = "Layout should be initialized before handling files")] + fn test_handle_without_layout() { + let handler = FileHandler::default(); + let file = create_test_internal_file("test.gmi", FileType::Gemini); + + handler.handle( + &PathBuf::from("source"), + &PathBuf::from("tests/fixtures/output"), + &PathBuf::from("tests/fixtures/output"), + &file + ); + } + + #[test] + fn test_slice_handling() { + let test_dir = setup_test_dir(); + let layout_path = test_dir.join("_layout.html"); + create_test_file(&layout_path, ""); + + let mut handler = FileHandler::default(); + let files = vec![ + create_test_internal_file("tests/fixtures/test1.gmi", FileType::Gemini), + create_test_internal_file(&layout_path.to_str().expect("Could not encode layout"), FileType::Layout), + create_test_internal_file("tests/fixtures/test2.gmi", FileType::Gemini), + create_test_internal_file("tests/fixtures/test3.gmi", FileType::Gemini), + ]; + + let _ = handler.get_layout_or_panic(&files[1..]); + + // Test with slice + handler.handle_all( + &PathBuf::from(""), + &PathBuf::from("tests/fixtures/output"), + &PathBuf::from("tests/fixtures/output"), + &files[1..] // Test with slice of last three elements + ); + } +}