asp/keep
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: extract magic type processing into helper function

Browse Source 
Co-authored-by: aider (openai/andrew/openrouter/deepseek/deepseek-chat-v3.1) <aider@aider.chat>
This commit is contained in:
Andrew Phillips
2025-08-26 17:30:38 -03:00
parent f44866a2cc
commit c6544ab034
1 changed files with 61 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
src/meta_plugin/magic.rs
View File

@@ -90,90 +90,79 @@ impl MagicFileMetaPlugin {
}
}
fn save_all_magic_metadata(&mut self, conn: &Connection) -> Result<()> {
if let Some(item_id) = self.item_id {
// Save all three magic outputs: mime_type, mime_encoding, and file_type
if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
if !mime_type.is_empty() {
let _ = self.save_meta(conn, item_id, "mime_type", mime_type);
/// Helper function to process all magic types and collect metadata
fn process_magic_types(&self, item_id: i64) -> Vec<crate::meta_plugin::MetaData> {
let mut metadata = Vec::new();
// Define the types to process with their corresponding flags
let types_to_process = [
("mime_type", CookieFlags::MIME_TYPE),
("mime_encoding", CookieFlags::MIME_ENCODING),
("file_type", CookieFlags::default()),
];
for (name, flags) in types_to_process {
if let Ok(result) = self.get_magic_result(flags) {
if !result.is_empty() {
// Use process_metadata_outputs to handle output mapping
if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
name,
result,
&self.outputs
) {
metadata.push(meta_data);
}
}
}
if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
if !mime_encoding.is_empty() {
let _ = self.save_meta(conn, item_id, "mime_encoding", mime_encoding);
}
}
if let Ok(file_type) = self.get_magic_result(CookieFlags::default()) {
if !file_type.is_empty() {
let _ = self.save_meta(conn, item_id, "file_type", file_type);
}
}
self.is_saved = true;
}
Ok(())
metadata
}
}
impl MetaPlugin for MagicFileMetaPlugin {
fn initialize(&mut self, item_id: i64) -> Result<MetaPluginResponse> {
fn initialize(&mut self, item_id: i64) -> crate::meta_plugin::MetaPluginResponse {
self.item_id = Some(item_id);
// Initialize the magic cookie once
let cookie = Cookie::open(Default::default())
.map_err(|e| anyhow::anyhow!("Failed to open magic cookie: {}", e))?;
cookie.load(&[] as &[&str])
.map_err(|e| anyhow::anyhow!("Failed to load magic database: {}", e))?;
let cookie = match Cookie::open(Default::default()) {
Ok(cookie) => cookie,
Err(e) => {
return crate::meta_plugin::MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
};
if let Err(e) = cookie.load(&[] as &[&str]) {
return crate::meta_plugin::MetaPluginResponse {
metadata: Vec::new(),
is_finalized: true,
};
}
self.cookie = Some(cookie);
Ok(MetaPluginResponse::default())
}
fn finalize(&mut self) -> Result<MetaPluginResponse> {
let mut metadata = Vec::new();
// Save all magic metadata if not already saved
if let Some(item_id) = self.item_id {
if let Some(cookie) = &self.cookie {
// Get mime type
if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
if !mime_type.is_empty() {
if let Some(meta) = self.create_meta(item_id, "mime_type", mime_type) {
metadata.push(meta);
}
}
}
// Get mime encoding
if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
if !mime_encoding.is_empty() {
if let Some(meta) = self.create_meta(item_id, "mime_encoding", mime_encoding) {
metadata.push(meta);
}
}
}
// Get file type
if let Ok(file_type) = self.get_magic_result(CookieFlags::default()) {
if !file_type.is_empty() {
if let Some(meta) = self.create_meta(item_id, "file_type", file_type) {
metadata.push(meta);
}
}
}
}
crate::meta_plugin::MetaPluginResponse {
metadata: Vec::new(),
is_finalized: false,
}
Ok(MetaPluginResponse {
metadata: if metadata.is_empty() { None } else { Some(metadata) },
is_finalized: true,
})
}
fn update(&mut self, data: &[u8]) -> Result<MetaPluginResponse> {
fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
let metadata = if let Some(item_id) = self.item_id {
self.process_magic_types(item_id)
} else {
Vec::new()
};
crate::meta_plugin::MetaPluginResponse {
metadata,
is_finalized: true,
}
}
fn update(&mut self, data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
let mut metadata = Vec::new();
// Only collect up to max_buffer_size
@@ -185,42 +174,15 @@ impl MetaPlugin for MagicFileMetaPlugin {
// Check if we've reached our buffer limit and return metadata
if self.buffer.len() >= self.max_buffer_size {
if let Some(item_id) = self.item_id {
if let Some(cookie) = &self.cookie {
// Get mime type
if let Ok(mime_type) = self.get_magic_result(CookieFlags::MIME_TYPE) {
if !mime_type.is_empty() {
if let Some(meta) = self.create_meta(item_id, "mime_type", mime_type) {
metadata.push(meta);
}
}
}
// Get mime encoding
if let Ok(mime_encoding) = self.get_magic_result(CookieFlags::MIME_ENCODING) {
if !mime_encoding.is_empty() {
if let Some(meta) = self.create_meta(item_id, "mime_encoding", mime_encoding) {
metadata.push(meta);
}
}
}
// Get file type
if let Ok(file_type) = self.get_magic_result(CookieFlags::default()) {
if !file_type.is_empty() {
if let Some(meta) = self.create_meta(item_id, "file_type", file_type) {
metadata.push(meta);
}
}
}
}
metadata = self.process_magic_types(item_id);
}
}
}
Ok(MetaPluginResponse {
metadata: if metadata.is_empty() { None } else { Some(metadata) },
crate::meta_plugin::MetaPluginResponse {
metadata,
is_finalized: !metadata.is_empty(),
})
}
}
fn meta_name(&self) -> String {