Deduplicate try_to_compress/decompress funcs

crates/kfuz2_cli/src/lib.rs

@@ -2,7 +2,8 @@
 // Home Repo    : https://github.com/InsultingPros/KFRedirectTool
 // License      : https://www.gnu.org/licenses/gpl-3.0.en.html
 
-pub mod helper;
+use kfuz2_lib::types::{InputArguments, LogLevel};
+use std::{path::PathBuf, process::ExitCode};
 
 // Reference: https://docs.rs/gumdrop/latest/gumdrop/
 /// `kfuz2_cli` supported arguments. For online help check: <https://github.com/InsultingPros/KFRedirectTool>
@@ -79,3 +80,47 @@ pub mod exit_codes {
     pub const ERROR_CANNOT_MAKE: u8 = 1;
     pub const ERROR_BAD_ARGUMENTS: u8 = 128;
 }
+
+/// Compose arguments for internal use
+/// # Errors
+///
+/// Will return `Err` if input is none.
+pub fn compose_input_arguments(env_arguments: &Options) -> Result<InputArguments, ExitCode> {
+    // 1. vanilla file check
+    let mut result: InputArguments = InputArguments {
+        ignore_kf_files: !env_arguments.nocheck,
+        ..Default::default()
+    };
+    // 2. input path
+    // decompression
+    if let Some(decompress_argument) = &env_arguments.decompress {
+        result.input_path = PathBuf::from(decompress_argument);
+    }
+    // compression
+    else {
+        if env_arguments.input_file.is_empty() {
+            return Err(ExitCode::from(exit_codes::ERROR_BAD_ARGUMENTS));
+        }
+        result.input_path = PathBuf::from(&env_arguments.input_file[0]);
+    }
+    // 3. output path
+    if let Some(extracted_output) = &env_arguments.output {
+        result.output_path = PathBuf::from(extracted_output);
+    } else {
+        // if none, assign same path as input. Will use this in further checks
+        result.output_path.clone_from(&result.input_path);
+    }
+
+    // silent has higher priority
+    if env_arguments.quiet {
+        result.log_level = LogLevel::Minimal;
+        return Ok(result);
+    }
+
+    if env_arguments.verbose {
+        result.log_level = LogLevel::Verbose;
+        return Ok(result);
+    }
+
+    Ok(result)
+}

crates/kfuz2_cli/src/main.rs

@@ -2,12 +2,11 @@
 // Home Repo    : https://github.com/InsultingPros/KFRedirectTool
 // License      : https://www.gnu.org/licenses/gpl-3.0.en.html
 
-use kfuz2_cli::{
-    exit_codes,
-    helper::{compose_input_arguments, try_to_compress, try_to_decompress},
-    Options,
+use kfuz2_cli::{compose_input_arguments, exit_codes, Options};
+use kfuz2_lib::{
+    helper::{try_to_compress, try_to_decompress},
+    types::{InputArguments, LogLevel::Minimal},
 };
-use kfuz2_lib::types::{InputArguments, LogLevel::Minimal};
 use std::process::ExitCode;
 
 fn main() -> ExitCode {

crates/kfuz2_egui/src/logic.rs

@@ -5,14 +5,9 @@
 #![allow(clippy::cast_possible_truncation)]
 use crate::ui;
 use kfuz2_lib::{
-    compressor::compress,
-    decompressor::decompress,
     errors::{CompressStreamError, DecompressStreamError},
-    helper::{
-        additional_processing_information, validate_compressible_path,
-        validate_decompressible_path, PathChecks,
-    },
-    types::{InputArguments, LogLevel},
+    helper::{try_to_compress, try_to_decompress},
+    types::InputArguments,
 };
 use std::{path::PathBuf, sync::atomic::Ordering, time::Instant};
 use walkdir::WalkDir;
@@ -118,7 +113,7 @@ fn parse_decompression_result(
     gui_app: &ui::app::Kfuz2Egui,
     start: Instant,
 ) {
-    match try_to_decompress(
+    match try_to_decompress_c(
         &mut InputArguments {
             input_path: file_list_path.into(),
             output_path: gui_app.output_dir.clone().unwrap(),
@@ -155,7 +150,7 @@ fn parse_compression_result(
     gui_app: &ui::app::Kfuz2Egui,
     start: Instant,
 ) {
-    match try_to_compress(
+    match try_to_compress_c(
         &mut InputArguments {
             input_path: file_list_path.into(),
             output_path: gui_app.output_dir.clone().unwrap(),
@@ -202,85 +197,29 @@ fn parse_compression_result(
 /// # Errors
 ///
 /// Will return `Err` if fail to create input-output streams, correctly compress the data or remove file on failure.
-pub fn try_to_compress(
+pub fn try_to_compress_c(
     input_arguments: &mut InputArguments,
     cancel: bool,
 ) -> Result<(), CompressStreamError> {
     if cancel {
         return Err(CompressStreamError::Canceled);
     }
-
-    validate_compressible_path(input_arguments)?;
-
-    // create streams
-    let mut output_stream = input_arguments.output_path.open_output_ue_stream()?;
-    let mut input_stream = input_arguments.input_path.open_input_ue_stream()?;
-
-    match compress(&mut input_stream, &mut output_stream, input_arguments) {
-        Ok(result) => {
-            if input_arguments.log_level != LogLevel::Minimal {
-                println!(
-                    "{} compressed in {:?}",
-                    input_arguments.input_path.get_file_name().unwrap_or("404"),
-                    result.time
-                );
-                if input_arguments.log_level == LogLevel::Verbose {
-                    additional_processing_information(&result);
-                }
-            }
-            Ok(())
-        }
-        Err(e) => {
-            // print!("{}", e);
-            std::fs::remove_file(&input_arguments.output_path)?;
-            Err(e)
-            // Err(CompressStreamError::FailedToCompress(
-            //     input_arguments.input_path.to_owned(),
-            // ))
-        }
-    }
+    try_to_compress(input_arguments)
 }
 
 /// Try to decompress given file.
 /// # Errors
 ///
 /// Will return `Err` if fail to create input-output streams, correctly decompress the data or remove file on failure.
-pub fn try_to_decompress(
+pub fn try_to_decompress_c(
     input_arguments: &mut InputArguments,
     cancel: bool,
 ) -> Result<(), DecompressStreamError> {
     if cancel {
         return Err(DecompressStreamError::Canceled);
     }
 
-    validate_decompressible_path(input_arguments)?;
-
-    let mut input_stream = input_arguments.input_path.open_input_ue_stream()?;
-    let mut output_stream = input_arguments.output_path.open_output_ue_stream()?;
-
-    match decompress(&mut input_stream, &mut output_stream, input_arguments) {
-        Ok(result) => {
-            if input_arguments.log_level != LogLevel::Minimal {
-                println!(
-                    "{} decompressed in {:?}",
-                    input_arguments.input_path.get_file_name().unwrap_or("404"),
-                    result.time
-                );
-                if input_arguments.log_level == LogLevel::Verbose {
-                    additional_processing_information(&result);
-                }
-            }
-            Ok(())
-        }
-        Err(e) => {
-            // print!("{}", e);
-            std::fs::remove_file(&input_arguments.output_path)?;
-            Err(e)
-            // Err(DecompressStreamError::FailedToCompress(
-            //     input_arguments.input_path.to_owned(),
-            // ))
-        }
-    }
+    try_to_decompress(input_arguments)
 }
 
 /// Reset progress bar atomics