feat: extract digest and compression type handling into common command functions

src/modes/common.rs

@@ -1,15 +1,19 @@
 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::db::Item;
 use crate::db::Meta;
 use crate::db::store_meta;
+use crate::compression_engine::CompressionType;
 use crate::digest_engine::DigestType;
-use crate::digest_engine::get_digest_type_meta;
+use crate::Args;
 
 pub fn get_meta_from_env() -> HashMap<String, String> {
     debug!("MAIN: Getting meta from KEEP_META_*");
@@ -97,6 +101,11 @@ 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())
+}
+
 pub fn store_item_digest_value(
     conn: &mut Connection,
     item: Item,
@@ -113,3 +122,41 @@ pub fn store_item_digest_value(
     store_meta(conn, digest_meta)?;
     Ok(())
 }
+
+pub fn cmd_args_digest_type(cmd: &mut Command, args: Args) -> DigestType {
+    let digest_name = args
+        .item
+        .digest
+        .clone()
+        .unwrap_or(DigestType::Sha256.to_string());
+
+    let digest_type_opt = DigestType::from_str(&digest_name);
+    if digest_type_opt.is_err() {
+        cmd.error(
+            ErrorKind::InvalidValue,
+            format!("Unknown digest type: {}", digest_name),
+        )
+            .exit();
+    }
+
+    digest_type_opt.unwrap()
+}
+
+pub fn cmd_args_compression_type(cmd: &mut Command, args: Args) -> CompressionType {
+    let compression_name = args
+        .item
+        .compression
+        .clone()
+        .unwrap_or(CompressionType::LZ4.to_string());
+
+    let compression_type_opt = CompressionType::from_str(&compression_name);
+    if compression_type_opt.is_err() {
+        cmd.error(
+            ErrorKind::InvalidValue,
+            format!("Unknown compression type: {}", compression_name),
+        )
+            .exit();
+    }
+
+    compression_type_opt.unwrap()
+}

src/modes/save.rs

@@ -1,8 +1,8 @@
-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};
+use std::io::{self, Read, Write};
-use std::str::FromStr;
 
 use clap::Command;
 use clap::error::ErrorKind;
@@ -10,10 +10,10 @@ use log::debug;
 use rusqlite::Connection;
 use std::path::PathBuf;
 
-use crate::compression_engine::{CompressionType, get_compression_engine};
+use crate::compression_engine::get_compression_engine;
 use crate::db::{self};
-use crate::digest_engine::{DigestType, get_digest_engine};
+use crate::digest_engine::get_digest_engine;
-use crate::modes::common::{get_meta_from_env, store_item_digest_value};
+use crate::modes::common::{get_meta_from_env, store_item_digest_value, cmd_args_compression_type, cmd_args_digest_type};
 use chrono::Utc;
 
 pub fn mode_save(
@@ -36,35 +36,14 @@ pub fn mode_save(
         tags.push("none".to_string());
     }
 
-    // Get the digest type to use
+    let digest_type = cmd_args_digest_type(cmd, args);
-    let digest_name = args
+    let compression_type = cmd_args_compression_type(cmd, args);
-        .item
-        .digest
-        .clone()
-        .unwrap_or(DigestType::Sha256.to_string());
-
-    let compression_name = args
-        .item
-        .compression
-        .unwrap_or(crate::compression_engine::default_compression_type().to_string());
-
-    use gethostname::gethostname;
-    use std::io::Write;
-    let compression_type_opt = CompressionType::from_str(&compression_name);
-    if compression_type_opt.is_err() {
-        cmd.error(
-            ErrorKind::InvalidValue,
-            format!("Unknown compression type: {}", compression_name),
-        )
-        .exit();
-    }
-
-    let compression_type = compression_type_opt.unwrap();
     debug!("MAIN: Compression type: {}", compression_type);
+    debug!("MAIN: Digest type: {}", digest_type);
 
-    // Create a new digest engine
-    let digest_type = DigestType::from_str(&digest_name).unwrap_or(DigestType::Sha256);
     let mut digest_engine = get_digest_engine(digest_type.clone());
+    let compression_engine =
+        get_compression_engine(compression_type.clone()).expect("Unable to get compression engine");
 
     let mut item = db::Item {
         id: None,
@@ -133,8 +112,6 @@ pub fn mode_save(
     let mut stdout = io::stdout().lock();
     let mut buffer = [0; libc::BUFSIZ as usize];
 
-    let compression_engine =
-        get_compression_engine(compression_type.clone()).expect("Unable to get compression engine");
     let mut item_out: Box<dyn Write> =
         compression_engine
             .create(item_path.clone())