refactor: improve code formatting and readability in SQL and function calls

src/modes/common.rs

@@ -1,28 +1,28 @@
-use humansize::{BINARY, FormatSizeOptions};
-use clap::Command;
-use log::debug;
-use prettytable::format::TableFormat;
-use clap::error::ErrorKind;
-use regex::Regex;
-use std::collections::HashMap;
-use std::env;
-use rusqlite::Connection;
-use std::str::FromStr;
+use crate::Args;
+use crate::compression_engine::CompressionType;
 use crate::db::Item;
 use crate::db::Meta;
 use crate::db::store_meta;
-use crate::compression_engine::CompressionType;
 use crate::digest_engine::DigestType;
-use crate::Args;
+use clap::Command;
+use clap::error::ErrorKind;
+use humansize::{BINARY, FormatSizeOptions};
+use log::debug;
+use prettytable::format::TableFormat;
+use regex::Regex;
+use rusqlite::Connection;
+use std::collections::HashMap;
+use std::env;
+use std::str::FromStr;
 
 pub fn get_meta_from_env() -> HashMap<String, String> {
-    debug!("MAIN: Getting meta from KEEP_META_*");
+    debug!("COMMON: Getting meta from KEEP_META_*");
     let re = Regex::new(r"^KEEP_META_(.+)$").unwrap();
     let mut meta_env: HashMap<String, String> = HashMap::new();
     for (key, value) in env::vars() {
         if let Some(meta_name_caps) = re.captures(key.as_str()) {
             let name = String::from(meta_name_caps.get(1).unwrap().as_str());
-            debug!("MAIN: Found meta: {}={}", name.clone(), value.clone());
+            debug!("COMMON: Found meta: {}={}", name.clone(), value.clone());
             meta_env.insert(name, value.clone());
         }
     }
@@ -101,7 +101,6 @@ pub fn get_format_box_chars_no_border_line_separator() -> TableFormat {
         .build()
 }
 
-
 pub fn get_digest_type_meta(digest_type: DigestType) -> String {
     format!("digest_{}", digest_type.to_string().to_lowercase())
 }
@@ -136,7 +135,7 @@ pub fn cmd_args_digest_type(cmd: &mut Command, args: &Args) -> DigestType {
             ErrorKind::InvalidValue,
             format!("Unknown digest type: {}", digest_name),
         )
-            .exit();
+        .exit();
     }
 
     digest_type_opt.unwrap()
@@ -155,7 +154,7 @@ pub fn cmd_args_compression_type(cmd: &mut Command, args: &Args) -> CompressionT
             ErrorKind::InvalidValue,
             format!("Unknown compression type: {}", compression_name),
         )
-            .exit();
+        .exit();
     }
 
     compression_type_opt.unwrap()

src/modes/save.rs

@@ -1,5 +1,5 @@
+use anyhow::{Context, Result, anyhow};
 use gethostname::gethostname;
-use anyhow::{anyhow, Context, Result};
 use is_terminal::IsTerminal;
 use std::collections::HashMap;
 use std::io::{self, Read, Write};
@@ -13,7 +13,9 @@ use std::path::PathBuf;
 use crate::compression_engine::get_compression_engine;
 use crate::db::{self};
 use crate::digest_engine::get_digest_engine;
-use crate::modes::common::{get_meta_from_env, store_item_digest_value, cmd_args_compression_type, cmd_args_digest_type};
+use crate::modes::common::{
+    cmd_args_compression_type, cmd_args_digest_type, get_meta_from_env, store_item_digest_value,
+};
 use chrono::Utc;
 
 pub fn mode_save(
@@ -143,15 +145,11 @@ pub fn mode_save(
     stdout.flush()?;
     item_out.flush()?;
 
-    // Finalize the digest and log the result
     let digest = digest_engine.finalize()?;
     debug!("DIGEST: {}", digest);
-    item.digest_value = Some(digest.clone());
 
-    db::update_item(conn, item.clone())?;
-
-    // Save digest to meta using the common function
     store_item_digest_value(conn, item.clone(), digest_type, digest)?;
+    db::update_item(conn, item.clone())?;
 
     Ok(())
 }

src/modes/update.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use crate::compression_engine::{CompressionType, get_compression_engine};
 use crate::db;
 use crate::digest_engine;
-use crate::modes::common::store_item_digest_value;
+use crate::modes::common::{cmd_args_digest_type, get_digest_type_meta, store_item_digest_value};
 use clap::Command;
 use clap::error::ErrorKind;
 use log::{debug, info};
@@ -67,13 +67,11 @@ pub fn mode_update(
         }
     }
 
-    if item.digest_value.is_none() {
-        let digest_type = digest_engine::DigestType::from_str(&item.digest_type.clone())?;
-
-        if digest_type != digest_engine::DigestType::None {
-            info!("Updating unknown digest value");
-        }
+    let digest_type = cmd_args_digest_type(cmd, args);
+    let digest_meta = get_digest_type_meta(digest_type.clone());
+    let digest_value = db::get_item_meta_value(&conn, &item, digest_meta)?;
 
+    if digest_value.is_none() || digest_value.unwrap().is_empty() {
         let item_file_metadata = item_path.metadata();
 
         if item_file_metadata.is_ok() {
@@ -97,10 +95,6 @@ pub fn mode_update(
             let digest_value = digest_engine.finalize()?;
             debug!("DIGEST: {}", digest_value);
 
-            // Update item with new digest value
-            item.digest_value = Some(digest_value.clone());
-            db::update_item(conn, item.clone())?;
-
             // Save digest to meta using the common function
             store_item_digest_value(conn, item.clone(), digest_type, digest_value)?;
         } else {