refactor: move compression engine init and reorganize digest recalculation logic

src/modes/update.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::Result;
 use std::path::PathBuf;
 use std::str::FromStr;
 
@@ -7,7 +7,7 @@ use crate::db;
 use clap::error::ErrorKind;
 use clap::Command;
 use log::{debug, info};
-use crate::digest_engine::{DigestType, get_digest_engine};
+use crate::digest_engine;
 use rusqlite::Connection;
 
 pub fn mode_update(
@@ -45,15 +45,16 @@ pub fn mode_update(
         path
     };
 
+    let compression_type = CompressionType::from_str(&item.compression)?;
+    let compression_engine = get_compression_engine(compression_type)
+        .expect("Unable to get compression engine");
+    
     if item.size.is_none() {
         info!("Updating unknown stream size");
         let item_file_metadata = item_path.metadata();
 
         if item_file_metadata.is_ok() {
             debug!("MAIN: Updating stream size of {:?}", item_path);
-            let compression_type = CompressionType::from_str(&item.compression)?;
-            let compression_engine = get_compression_engine(compression_type)
-                .expect("Unable to get compression engine");
             let size = compression_engine.size(item_path.clone())?;
             item.size = Some(size as i64);
             db::update_item(conn, item.clone())?;
@@ -65,37 +66,28 @@ pub fn mode_update(
         }
     }
 
-    // If digest is defined and not None, but digest_value is missing, recalculate it
-    match &item.digest_type {
-        Some(digest_type_str) if digest_type_str != "None" && item.digest_value.is_none() => {
-            debug!("MAIN: Recalculating digest for item {:?}", item.id);
 
-            // Get the digest type
-            let digest_type = DigestType::from_str(digest_type_str)?;
-            let mut digest_engine = get_digest_engine(digest_type);
+    if item.digest_value.is_none() {
+        let digest_type = digest_engine::DigestType::from_str(&item.digest_type)?;
 
-            // Read the file using the compression engine
-            let compression_type = CompressionType::from_str(&item.compression)?;
-            let compression_engine = get_compression_engine(compression_type)
-                .expect("Unable to get compression engine");
-            
-            let mut reader = compression_engine.open(item_path.clone())?;
-            let mut buffer = [0; 4096];
-            
-            loop {
-                let n = reader.read(&mut buffer)?;
-                if n == 0 {
-                    break;
-                }
-                digest_engine.update(&buffer[..n]);
+        if digest_type != digest_engine::DigestType::None {
+            info!("Updating unknown digest value");
         }
 
-            // Finalize the digest and update the item
-            let digest_value = digest_engine.finalize()?;
-            item.digest_value = Some(digest_value);
+        let item_file_metadata = item_path.metadata();
+
+        if item_file_metadata.is_ok() {
+            debug!("MAIN: Updating stream size of {:?}", item_path);
+
+            // TODO: Add loop here to calculate new digest and put in item.
+            
             db::update_item(conn, item.clone())?;
-        },
-        _ => {}
+        } else {
+            debug!(
+                "MAIN: Unable to update digest of item due to missing file {:?}",
+                item_path
+            );
+        }
     }
 
     if !args.item.meta.is_empty() {