git.r.bdr.sh - rbdr/page/blame_incremental - src/file_handler/mod.rs

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::fs::read_to_string;
use std::path::{Path, PathBuf};

pub struct FileHandler {
    pub strategies: Vec<Box<dyn Strategy>>,
    pub layout: Option<String>,
}

impl Default for FileHandler {
    fn default() -> FileHandler {
        FileHandler {
            strategies: vec![
                Box::new(GeminiStrategy {}),
                Box::new(LayoutStrategy {}),
                Box::new(FileStrategy {}),
            ],
            layout: None,
        }
    }
}

impl FileHandler {
    pub fn identify(&self, path: &Path) -> FileType {
        for strategy in &self.strategies {
            if strategy.is(path) {
                return strategy.identify();
            }
        }
        FileType::Unknown
    }

    pub fn get_layout_or_panic(&mut self, files: &[File]) -> Result<(), &str> {
        for file in files {
            if 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: &Path,
        html_destination: &Path,
        gemini_destination: &Path,
        files: &[File],
    ) {
        for file in files {
            self.handle(source, html_destination, gemini_destination, file);
        }
    }

    pub fn handle(
        &self,
        source: &Path,
        html_destination: &Path,
        gemini_destination: &Path,
        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);
        }
    }
}

pub trait Strategy {
    fn is(&self, path: &Path) -> bool;
    fn identify(&self) -> FileType;
    fn can_handle(&self, file_type: &FileType) -> bool;
    fn handle_html(&self, source: &Path, destination: &Path, file: &File, layout: &str);
    fn handle_gemini(&self, source: &Path, destination: &Path, file: &File);
}

#[derive(Debug, Clone, PartialEq)]
pub enum FileType {
    Gemini,
    File,
    Layout,
    Unknown,
}

#[derive(PartialEq, Debug)]
pub struct File {
    pub path: PathBuf,
    pub file_type: FileType,
}

#[cfg(test)]
mod tests {
    use std::fs::create_dir_all;
    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 Strategy for MockStrategy {
        fn is(&self, _path: &Path) -> 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: &Path, _destination: &Path, _file: &File, _layout: &str) {}
        fn handle_gemini(&self, _source: &Path, _destination: &Path, _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: Some("None".to_string()),
        };

        let path = PathBuf::from("test.whatever");
        let file = File{
            path: path.clone(),
            file_type: FileType::Gemini
        };
        assert!(matches!(handler.identify(&path), FileType::Gemini));
        handler.handle(&path, &path, &path, &file);
    }

    #[test]
    fn test_handle_all_empty_files() {
        let handler = FileHandler::default();
        let files: Vec<File> = vec![];

        // Should not panic with empty vector
        handler.handle_all(
            &PathBuf::from("source"),
            &PathBuf::from("output_html"),
            &PathBuf::from("output_gemini"),
            &files,
        );
    }

    #[test]
    fn test_handle_with_layout() {
        let handler = FileHandler {
            layout: Some("test layout".to_string()),
            ..Default::default()
        };

        let test_dir = setup_test_dir();
        create_dir_all(test_dir.join("output_html"))
            .expect("Could not create output html test directory");
        create_dir_all(test_dir.join("output_gemini"))
            .expect("Could not create output gemini test directory");
        let test_path = test_dir.join("test.gmi");
        create_test_file(&test_path, "");
        let file = create_test_internal_file(
            test_path
                .to_str()
                .expect("Could not encode gemini test file"),
            FileType::Gemini,
        );

        // Should not panic with valid layout
        handler.handle(
            &test_dir,
            &test_dir.join("output_html"),
            &test_dir.join("output_gemini"),
            &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("output_html"),
            &PathBuf::from("output_gemini"),
            &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, "");
        create_test_file(&test_dir.join("test1.gmi"), "");
        create_test_file(&test_dir.join("test2.gmi"), "");
        create_test_file(&test_dir.join("test3.gmi"), "");
        create_dir_all(test_dir.join("output_html"))
            .expect("Could not create output html test directory");
        create_dir_all(test_dir.join("output_gemini"))
            .expect("Could not create output gemini test directory");

        let mut handler = FileHandler::default();
        let files = [
            create_test_internal_file(
                test_dir
                    .join("test1.gmi")
                    .to_str()
                    .expect("Could not encode test1"),
                FileType::Gemini,
            ),
            create_test_internal_file(
                layout_path.to_str().expect("Could not encode layout"),
                FileType::Layout,
            ),
            create_test_internal_file(
                test_dir
                    .join("test2.gmi")
                    .to_str()
                    .expect("Could not encode test2"),
                FileType::Gemini,
            ),
            create_test_internal_file(
                test_dir
                    .join("test3.gmi")
                    .to_str()
                    .expect("Could not encode test3"),
                FileType::Gemini,
            ),
        ];

        let _ = handler.get_layout_or_panic(&files[1..]);

        // Test with slice
        handler.handle_all(
            &test_dir,
            &test_dir.join("output_html"),
            &test_dir.join("output_gemini"),
            &files[1..], // Test with slice of last three elements
        );
    }
}
Commit	Line	Data
	1	mod file_strategies;
	2
	3	use file_strategies::file::Strategy as FileStrategy;
	4	use file_strategies::gemini::Strategy as GeminiStrategy;
	5	use file_strategies::layout::Strategy as LayoutStrategy;
	6
	7	use std::fs::read_to_string;
	8	use std::path::{Path, PathBuf};
	9
	10	pub struct FileHandler {
	11	pub strategies: Vec<Box<dyn Strategy>>,
	12	pub layout: Option<String>,
	13	}
	14
	15	impl Default for FileHandler {
	16	fn default() -> FileHandler {
	17	FileHandler {
	18	strategies: vec![
	19	Box::new(GeminiStrategy {}),
	20	Box::new(LayoutStrategy {}),
	21	Box::new(FileStrategy {}),
	22	],
	23	layout: None,
	24	}
	25	}
	26	}
	27
	28	impl FileHandler {
	29	pub fn identify(&self, path: &Path) -> FileType {
	30	for strategy in &self.strategies {
	31	if strategy.is(path) {
	32	return strategy.identify();
	33	}
	34	}
	35	FileType::Unknown
	36	}
	37
	38	pub fn get_layout_or_panic(&mut self, files: &[File]) -> Result<(), &str> {
	39	for file in files {
	40	if file.file_type == FileType::Layout {
	41	let layout_text = read_to_string(&file.path).unwrap();
	42	self.layout = Some(layout_text);
	43	return Ok(());
	44	}
	45	}
	46	Err("No layout found. Please ensure there's a _layout.html file at the root")
	47	}
	48
	49	pub fn handle_all(
	50	&self,
	51	source: &Path,
	52	html_destination: &Path,
	53	gemini_destination: &Path,
	54	files: &[File],
	55	) {
	56	for file in files {
	57	self.handle(source, html_destination, gemini_destination, file);
	58	}
	59	}
	60
	61	pub fn handle(
	62	&self,
	63	source: &Path,
	64	html_destination: &Path,
	65	gemini_destination: &Path,
	66	file: &File,
	67	) {
	68	if let Some(strategy) = self
	69	.strategies
	70	.iter()
	71	.find(\|s\| s.can_handle(&file.file_type))
	72	{
	73	let layout = self
	74	.layout
	75	.as_ref()
	76	.expect("Layout should be initialized before handling files");
	77	strategy.handle_html(source, html_destination, file, layout);
	78	strategy.handle_gemini(source, gemini_destination, file);
	79	}
	80	}
	81	}
	82
	83	pub trait Strategy {
	84	fn is(&self, path: &Path) -> bool;
	85	fn identify(&self) -> FileType;
	86	fn can_handle(&self, file_type: &FileType) -> bool;
	87	fn handle_html(&self, source: &Path, destination: &Path, file: &File, layout: &str);
	88	fn handle_gemini(&self, source: &Path, destination: &Path, file: &File);
	89	}
	90
	91	#[derive(Debug, Clone, PartialEq)]
	92	pub enum FileType {
	93	Gemini,
	94	File,
	95	Layout,
	96	Unknown,
	97	}
	98
	99	#[derive(PartialEq, Debug)]
	100	pub struct File {
	101	pub path: PathBuf,
	102	pub file_type: FileType,
	103	}
	104
	105	#[cfg(test)]
	106	mod tests {
	107	use std::fs::create_dir_all;
	108	use std::path::PathBuf;
	109
	110	use super::*;
	111
	112	use test_utilities::*;
	113
	114	fn create_test_internal_file(path: &str, file_type: FileType) -> File {
	115	File {
	116	path: PathBuf::from(path),
	117	file_type,
	118	}
	119	}
	120
	121	#[test]
	122	fn test_identify_gemini_file() {
	123	let handler = FileHandler::default();
	124	let path = PathBuf::from("test.gmi");
	125	assert!(matches!(handler.identify(&path), FileType::Gemini));
	126	}
	127
	128	#[test]
	129	fn test_identify_layout_file() {
	130	let handler = FileHandler::default();
	131	let path = PathBuf::from("_layout.html");
	132	assert!(matches!(handler.identify(&path), FileType::Layout));
	133	}
	134
	135	#[test]
	136	fn test_identify_regular_file() {
	137	let handler = FileHandler::default();
	138	let path = PathBuf::from("regular.html");
	139	assert!(matches!(handler.identify(&path), FileType::File));
	140	}
	141
	142	#[test]
	143	fn test_identify_unknown_file() {
	144	let handler = FileHandler::default();
	145	let path = PathBuf::from("tests");
	146	assert!(matches!(handler.identify(&path), FileType::Unknown));
	147	}
	148
	149	#[test]
	150	fn test_get_layout_success() {
	151	let test_dir = setup_test_dir();
	152	let layout_path = test_dir.join("_layout.html");
	153	create_test_file(&layout_path, "");
	154
	155	let mut handler = FileHandler::default();
	156	let files = vec![
	157	create_test_internal_file("test.gmi", FileType::Gemini),
	158	create_test_internal_file(
	159	layout_path.to_str().expect("Could not encode layout"),
	160	FileType::Layout,
	161	),
	162	create_test_internal_file("regular.html", FileType::File),
	163	];
	164
	165	assert!(handler.get_layout_or_panic(&files).is_ok());
	166	}
	167
	168	#[test]
	169	fn test_get_layout_failure() {
	170	let mut handler = FileHandler::default();
	171	let files = vec![
	172	create_test_internal_file("test.gmi", FileType::Gemini),
	173	create_test_internal_file("regular.html", FileType::File),
	174	];
	175
	176	assert!(handler.get_layout_or_panic(&files).is_err());
	177	}
	178
	179	// Mock strategy for testing
	180	struct MockStrategy {
	181	is_match: bool,
	182	file_type: FileType,
	183	}
	184
	185	impl Strategy for MockStrategy {
	186	fn is(&self, _path: &Path) -> bool {
	187	self.is_match
	188	}
	189
	190	fn identify(&self) -> FileType {
	191	self.file_type.clone()
	192	}
	193
	194	fn can_handle(&self, file_type: &FileType) -> bool {
	195	&self.file_type == file_type
	196	}
	197
	198	fn handle_html(&self, _source: &Path, _destination: &Path, _file: &File, _layout: &str) {}
	199	fn handle_gemini(&self, _source: &Path, _destination: &Path, _file: &File) {}
	200	}
	201
	202	#[test]
	203	fn test_custom_strategy() {
	204	let mock_strategy = MockStrategy {
	205	is_match: true,
	206	file_type: FileType::Gemini,
	207	};
	208
	209	let handler = FileHandler {
	210	strategies: vec![Box::new(mock_strategy)],
	211	layout: Some("None".to_string()),
	212	};
	213
	214	let path = PathBuf::from("test.whatever");
	215	let file = File{
	216	path: path.clone(),
	217	file_type: FileType::Gemini
	218	};
	219	assert!(matches!(handler.identify(&path), FileType::Gemini));
	220	handler.handle(&path, &path, &path, &file);
	221	}
	222
	223	#[test]
	224	fn test_handle_all_empty_files() {
	225	let handler = FileHandler::default();
	226	let files: Vec<File> = vec![];
	227
	228	// Should not panic with empty vector
	229	handler.handle_all(
	230	&PathBuf::from("source"),
	231	&PathBuf::from("output_html"),
	232	&PathBuf::from("output_gemini"),
	233	&files,
	234	);
	235	}
	236
	237	#[test]
	238	fn test_handle_with_layout() {
	239	let handler = FileHandler {
	240	layout: Some("test layout".to_string()),
	241	..Default::default()
	242	};
	243
	244	let test_dir = setup_test_dir();
	245	create_dir_all(test_dir.join("output_html"))
	246	.expect("Could not create output html test directory");
	247	create_dir_all(test_dir.join("output_gemini"))
	248	.expect("Could not create output gemini test directory");
	249	let test_path = test_dir.join("test.gmi");
	250	create_test_file(&test_path, "");
	251	let file = create_test_internal_file(
	252	test_path
	253	.to_str()
	254	.expect("Could not encode gemini test file"),
	255	FileType::Gemini,
	256	);
	257
	258	// Should not panic with valid layout
	259	handler.handle(
	260	&test_dir,
	261	&test_dir.join("output_html"),
	262	&test_dir.join("output_gemini"),
	263	&file,
	264	);
	265	}
	266
	267	#[test]
	268	#[should_panic(expected = "Layout should be initialized before handling files")]
	269	fn test_handle_without_layout() {
	270	let handler = FileHandler::default();
	271	let file = create_test_internal_file("test.gmi", FileType::Gemini);
	272
	273	handler.handle(
	274	&PathBuf::from("source"),
	275	&PathBuf::from("output_html"),
	276	&PathBuf::from("output_gemini"),
	277	&file,
	278	);
	279	}
	280
	281	#[test]
	282	fn test_slice_handling() {
	283	let test_dir = setup_test_dir();
	284	let layout_path = test_dir.join("_layout.html");
	285	create_test_file(&layout_path, "");
	286	create_test_file(&test_dir.join("test1.gmi"), "");
	287	create_test_file(&test_dir.join("test2.gmi"), "");
	288	create_test_file(&test_dir.join("test3.gmi"), "");
	289	create_dir_all(test_dir.join("output_html"))
	290	.expect("Could not create output html test directory");
	291	create_dir_all(test_dir.join("output_gemini"))
	292	.expect("Could not create output gemini test directory");
	293
	294	let mut handler = FileHandler::default();
	295	let files = [
	296	create_test_internal_file(
	297	test_dir
	298	.join("test1.gmi")
	299	.to_str()
	300	.expect("Could not encode test1"),
	301	FileType::Gemini,
	302	),
	303	create_test_internal_file(
	304	layout_path.to_str().expect("Could not encode layout"),
	305	FileType::Layout,
	306	),
	307	create_test_internal_file(
	308	test_dir
	309	.join("test2.gmi")
	310	.to_str()
	311	.expect("Could not encode test2"),
	312	FileType::Gemini,
	313	),
	314	create_test_internal_file(
	315	test_dir
	316	.join("test3.gmi")
	317	.to_str()
	318	.expect("Could not encode test3"),
	319	FileType::Gemini,
	320	),
	321	];
	322
	323	let _ = handler.get_layout_or_panic(&files[1..]);
	324
	325	// Test with slice
	326	handler.handle_all(
	327	&test_dir,
	328	&test_dir.join("output_html"),
	329	&test_dir.join("output_gemini"),
	330	&files[1..], // Test with slice of last three elements
	331	);
	332	}
	333	}