♻️ Make FileProcessor::process handle all visit types

core/src/filesystem/media/builder.rs

@@ -4,7 +4,7 @@
 
 use crate::{
 	config::StumpConfig,
-	db::entity::{LibraryConfig, Media, MediaMetadata, Series},
+	db::entity::{LibraryConfig, Media, Series},
 	filesystem::{
 		process,
 		scanner::{CustomVisit, CustomVisitResult},
@@ -13,7 +13,7 @@
 	CoreError, CoreResult,
 };
 
-use super::{generate_hashes, process_metadata, ProcessedFileHashes};
+use super::{FileProcessorOptions, ProcessedFileHashes};
 
 pub struct MediaBuilder {
 	path: PathBuf,
@@ -101,24 +101,26 @@
 		})
 	}
 
-	pub fn regen_hashes(&self) -> CoreResult<ProcessedFileHashes> {
-		Ok(generate_hashes(
-			self.path.clone(),
-			self.library_config.clone().into(),
-		)?)
-	}
-
-	pub fn regen_meta(&self) -> CoreResult<Option<MediaMetadata>> {
-		Ok(process_metadata(self.path.clone())?)
-	}
-
 	pub fn custom_visit(self, config: CustomVisit) -> CoreResult<CustomVisitResult> {
 		let mut result = CustomVisitResult::default();
+		let processor_options = FileProcessorOptions {
+			convert_rar_to_zip: false,
+			delete_conversion_source: false,
+			generate_file_hashes: config.regen_hashes,
+			generate_koreader_hashes: config.regen_hashes,
+			process_metadata: config.regen_meta,
+			process_pages: config.regen_meta,
+		};
+		let processed_file =
+			process(self.path.as_path(), processor_options, &self.config)?;
 		if config.regen_hashes {
-			result.hashes = Some(self.regen_hashes()?);
+			result.hashes = Some(ProcessedFileHashes {
+				hash: processed_file.hash,
+				koreader_hash: processed_file.koreader_hash,
+			});
 		}
 		if config.regen_meta {
-			result.meta = self.regen_meta()?.map(Box::new);
+			result.meta = processed_file.metadata.map(Box::new);
 		}
 		Ok(result)
 	}
@@ -239,8 +241,12 @@
 
 		let builder =
 			MediaBuilder::new(path, series_id, library_config, &StumpConfig::debug());
-		let hashes = builder.regen_hashes();
-		assert!(hashes.is_ok());
+		let custom_visit = CustomVisit {
+			regen_hashes: true,
+			regen_meta: false,
+		};
+		let hashes = builder.custom_visit(custom_visit).unwrap().hashes;
+		assert!(hashes.is_some());
 		assert!(hashes.unwrap().hash.is_some());
 	}
 }

core/src/filesystem/media/format/epub.rs

@@ -89,102 +89,44 @@
 		})
 	}
 
-	fn process_metadata(path: &str) -> Result<Option<MediaMetadata>, FileError> {
-		let epub_file = Self::open(path)?;
-		let embedded_metadata = MediaMetadata::from(epub_file.metadata);
-
-		// try get opf file
-		let file_path = std::path::Path::new(path).with_extension("opf");
-		if file_path.exists() {
-			// extract OPF data
-			let opf_string = std::fs::read_to_string(file_path)?;
-			let mut reader = Reader::from_str(opf_string.as_str());
-			reader.config_mut().trim_text(true);
-			let mut current_tag = String::new();
-
-			let mut opf_metadata: HashMap<String, Vec<String>> = HashMap::new();
-
-			while let Ok(event) = reader.read_event() {
-				match event {
-					Event::Start(ref e) | Event::Empty(ref e) => {
-						let tag_name =
-							String::from_utf8_lossy(e.name().as_ref()).to_string();
-
-						// normalize tags
-						current_tag = tag_name
-							.strip_prefix("dc:")
-							.unwrap_or(tag_name.as_str())
-							.to_string();
-
-						if let Some(attr) =
-							e.attributes().filter_map(|a| a.ok()).find(|a| {
-								a.key.as_ref() == b"property" || a.key.as_ref() == b"name"
-							}) {
-							current_tag = format!(
-								"{}: {}",
-								current_tag,
-								String::from_utf8_lossy(&attr.value)
-							);
-						}
-					},
-					Event::Text(e) => {
-						if let Ok(text) = e.unescape() {
-							opf_metadata
-								.entry(current_tag.clone())
-								.or_default()
-								.push(text.to_string());
-						}
-					},
-					Event::Eof => {
-						break;
-					},
-					_ => {},
-				}
-			}
-
-			// merge opf and embedded, prioritizing opf
-			let opf_metadata = MediaMetadata::from(opf_metadata);
-			let mut combined_metadata = opf_metadata.clone();
-
-			combined_metadata.id = opf_metadata.id;
-			combined_metadata.merge(embedded_metadata);
-
-			return Ok(Some(combined_metadata));
-		}
-
-		Ok(Some(embedded_metadata))
-	}
-
 	fn process(
 		path: &str,
 		options: FileProcessorOptions,
 		_: &StumpConfig,
 	) -> Result<ProcessedFile, FileError> {
 		tracing::debug!(?path, "processing epub");
 
-		let metadata = Self::process_metadata(path);
+		let mut processed_file = ProcessedFile {
+			path: PathBuf::from(path),
+			..Default::default()
+		};
 
-		let path_buf = PathBuf::from(path);
-		let epub_file = Self::open(path)?;
+		if options.process_pages || options.process_metadata {
+			let epub_file = Self::open(path)?;
 
-		let pages = epub_file.get_num_pages() as i32;
-		// Get metadata from epub file if process_metadata failed
-		let metadata = match metadata {
-			Ok(Some(m)) => m,
-			_ => MediaMetadata::from(epub_file.metadata),
+			if options.process_pages {
+				processed_file.pages = epub_file.get_num_pages() as i32;
+			}
+			// This still needs to be changed to take epub_file
+			if options.process_metadata {
+				processed_file.metadata = Self::process_metadata(path, epub_file)?;
+			}
 		};
-		let ProcessedFileHashes {
-			hash,
-			koreader_hash,
-		} = Self::generate_hashes(path, options)?;
 
-		Ok(ProcessedFile {
-			path: path_buf,
-			hash,
-			koreader_hash,
-			metadata: Some(metadata),
-			pages,
-		})
+		if options.generate_file_hashes || options.generate_koreader_hashes {
+			let ProcessedFileHashes {
+				hash,
+				koreader_hash,
+			} = Self::generate_hashes(path, options)?;
+			if options.generate_file_hashes {
+				processed_file.hash = hash;
+			}
+			if options.generate_koreader_hashes {
+				processed_file.koreader_hash = koreader_hash;
+			}
+		};
+
+		Ok(processed_file)
 	}
 
 	fn get_page(
@@ -255,6 +197,74 @@
 		EpubDoc::new(path).map_err(|e| FileError::EpubOpenError(e.to_string()))
 	}
 
+	pub fn process_metadata(
+		path: &str,
+		epub_file: EpubDoc<BufReader<File>>,
+	) -> Result<Option<MediaMetadata>, FileError> {
+		let embedded_metadata = MediaMetadata::from(epub_file.metadata);
+
+		// try get opf file
+		let file_path = std::path::Path::new(path).with_extension("opf");
+		if file_path.exists() {
+			// extract OPF data
+			let opf_string = std::fs::read_to_string(file_path)?;
+			let mut reader = Reader::from_str(opf_string.as_str());
+			reader.config_mut().trim_text(true);
+			let mut current_tag = String::new();
+
+			let mut opf_metadata: HashMap<String, Vec<String>> = HashMap::new();
+
+			while let Ok(event) = reader.read_event() {
+				match event {
+					Event::Start(ref e) | Event::Empty(ref e) => {
+						let tag_name =
+							String::from_utf8_lossy(e.name().as_ref()).to_string();
+
+						// normalize tags
+						current_tag = tag_name
+							.strip_prefix("dc:")
+							.unwrap_or(tag_name.as_str())
+							.to_string();
+
+						if let Some(attr) =
+							e.attributes().filter_map(|a| a.ok()).find(|a| {
+								a.key.as_ref() == b"property" || a.key.as_ref() == b"name"
+							}) {
+							current_tag = format!(
+								"{}: {}",
+								current_tag,
+								String::from_utf8_lossy(&attr.value)
+							);
+						}
+					},
+					Event::Text(e) => {
+						if let Ok(text) = e.unescape() {
+							opf_metadata
+								.entry(current_tag.clone())
+								.or_default()
+								.push(text.to_string());
+						}
+					},
+					Event::Eof => {
+						break;
+					},
+					_ => {},
+				}
+			}
+
+			// merge opf and embedded, prioritizing opf
+			let opf_metadata = MediaMetadata::from(opf_metadata);
+			let mut combined_metadata = opf_metadata.clone();
+
+			combined_metadata.id = opf_metadata.id;
+			combined_metadata.merge(embedded_metadata);
+
+			return Ok(Some(combined_metadata));
+		}
+
+		Ok(Some(embedded_metadata))
+	}
+
 	fn get_cover_path(resources: &HashMap<String, (PathBuf, String)>) -> Option<String> {
 		let search_result = resources
 			.iter()
@@ -692,20 +702,70 @@
 		let processed_file = EpubProcessor::process(
 			&path,
 			FileProcessorOptions {
-				convert_rar_to_zip: false,
-				delete_conversion_source: false,
 				..Default::default()
 			},
 			&config,
 		);
 		assert!(processed_file.is_ok());
+		let processed_file = processed_file.unwrap();
+		assert!(processed_file.hash.is_none());
+		assert!(processed_file.koreader_hash.is_none());
+		assert!(processed_file.metadata.is_none());
+		assert_eq!(processed_file.pages, 0);
+
+		let processed_file = EpubProcessor::process(
+			&path,
+			FileProcessorOptions {
+				generate_file_hashes: true,
+				generate_koreader_hashes: true,
+				..Default::default()
+			},
+			&config,
+		);
+		assert!(processed_file.is_ok());
+		let processed_file = processed_file.unwrap();
+		assert!(processed_file.hash.is_some());
+		assert!(processed_file.koreader_hash.is_some());
+		assert!(processed_file.metadata.is_none());
+		assert_eq!(processed_file.pages, 0);
+
+		let processed_file = EpubProcessor::process(
+			&path,
+			FileProcessorOptions {
+				process_metadata: true,
+				..Default::default()
+			},
+			&config,
+		);
+		assert!(processed_file.is_ok());
+		let processed_file = processed_file.unwrap();
+		assert!(processed_file.hash.is_none());
+		assert!(processed_file.koreader_hash.is_none());
+		assert!(processed_file.metadata.is_some());
+		assert_eq!(processed_file.pages, 0);
+
+		let processed_file = EpubProcessor::process(
+			&path,
+			FileProcessorOptions {
+				process_pages: true,
+				..Default::default()
+			},
+			&config,
+		);
+		assert!(processed_file.is_ok());
+		let processed_file = processed_file.unwrap();
+		assert!(processed_file.hash.is_none());
+		assert!(processed_file.koreader_hash.is_none());
+		assert!(processed_file.metadata.is_none());
+		assert_ne!(processed_file.pages, 0);
 	}
 
 	#[test]
 	fn test_process_metadata() {
 		let path = get_test_epub_path();
+		let epub_file = EpubProcessor::open(&path).unwrap();
 
-		let processed_metadata = EpubProcessor::process_metadata(&path);
+		let processed_metadata = EpubProcessor::process_metadata(&path, epub_file);
 		match processed_metadata {
 			Ok(Some(metadata)) => {
 				assert_eq!(