Clean up code

Author: Razshy

package-lock.json

@@ -3,6 +3,7 @@ use std::fs::File;
 use std::io::{Read, Write};
 
 /// Compress data using gzip
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn gzip_compress(data: Vec<u8>) -> Result<Vec<u8>, String> {
     use flate2::write::GzEncoder;
@@ -11,15 +12,16 @@ pub fn gzip_compress(data: Vec<u8>) -> Result<Vec<u8>, String> {
     let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
     encoder
         .write_all(&data)
-        .map_err(|e| format!("Compression error: {}", e))?;
+        .map_err(|e| format!("Compression error: {e}"))?;
     encoder
         .finish()
-        .map_err(|e| format!("Compression finish error: {}", e))
+        .map_err(|e| format!("Compression finish error: {e}"))
 }
 
 const MAX_DECOMPRESSED_SIZE: u64 = 100 * 1024 * 1024; // 100 MB
 
 /// Decompress gzip data
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn gzip_decompress(data: Vec<u8>) -> Result<Vec<u8>, String> {
     use flate2::read::GzDecoder;
@@ -29,14 +31,15 @@ pub fn gzip_decompress(data: Vec<u8>) -> Result<Vec<u8>, String> {
     let mut result = Vec::new();
     limited
         .read_to_end(&mut result)
-        .map_err(|e| format!("Decompression error: {}", e))?;
+        .map_err(|e| format!("Decompression error: {e}"))?;
     if result.len() as u64 > MAX_DECOMPRESSED_SIZE {
         return Err("Decompressed data exceeds 100 MB limit".to_string());
     }
     Ok(result)
 }
 
 /// Compress string to gzip base64
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn gzip_compress_text(text: String) -> Result<String, String> {
     use base64::{engine::general_purpose::STANDARD, Engine as _};
@@ -46,15 +49,16 @@ pub fn gzip_compress_text(text: String) -> Result<String, String> {
 }
 
 /// Decompress gzip base64 to string
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn gzip_decompress_text(text: String) -> Result<String, String> {
     use base64::{engine::general_purpose::STANDARD, Engine as _};
 
     let decoded = STANDARD
         .decode(&text)
-        .map_err(|e| format!("Base64 decode error: {}", e))?;
+        .map_err(|e| format!("Base64 decode error: {e}"))?;
     let decompressed = gzip_decompress(decoded)?;
-    String::from_utf8(decompressed).map_err(|e| format!("UTF-8 decode error: {}", e))
+    String::from_utf8(decompressed).map_err(|e| format!("UTF-8 decode error: {e}"))
 }
 
 #[derive(Debug, Serialize)]
@@ -66,18 +70,18 @@ pub struct ZipEntry {
 }
 
 /// List contents of a zip file
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn zip_list(path: String) -> Result<Vec<ZipEntry>, String> {
-    let file = File::open(&path).map_err(|e| format!("Failed to open zip: {}", e))?;
+    let file = File::open(&path).map_err(|e| format!("Failed to open zip: {e}"))?;
 
-    let mut archive =
-        zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip: {}", e))?;
+    let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip: {e}"))?;
 
     let mut entries = Vec::new();
     for i in 0..archive.len() {
         let file = archive
             .by_index(i)
-            .map_err(|e| format!("Failed to read zip entry: {}", e))?;
+            .map_err(|e| format!("Failed to read zip entry: {e}"))?;
 
         entries.push(ZipEntry {
             name: file.name().to_string(),
@@ -91,42 +95,42 @@ pub fn zip_list(path: String) -> Result<Vec<ZipEntry>, String> {
 }
 
 /// Extract single file from zip
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn zip_extract_file(zip_path: String, entry_name: String) -> Result<Vec<u8>, String> {
     if entry_name.contains("..") || entry_name.starts_with('/') || entry_name.starts_with('\\') {
         return Err("Invalid zip entry name: must not contain '..' or start with '/'".to_string());
     }
 
-    let file = File::open(&zip_path).map_err(|e| format!("Failed to open zip: {}", e))?;
+    let file = File::open(&zip_path).map_err(|e| format!("Failed to open zip: {e}"))?;
 
-    let mut archive =
-        zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip: {}", e))?;
+    let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("Failed to read zip: {e}"))?;
 
     let entry = archive
         .by_name(&entry_name)
-        .map_err(|e| format!("Entry not found: {}", e))?;
+        .map_err(|e| format!("Entry not found: {e}"))?;
 
     let entry_size = entry.size();
     if entry_size > MAX_DECOMPRESSED_SIZE {
         return Err(format!(
-            "Zip entry too large: {} bytes (limit: {} bytes)",
-            entry_size, MAX_DECOMPRESSED_SIZE
+            "Zip entry too large: {entry_size} bytes (limit: {MAX_DECOMPRESSED_SIZE} bytes)"
         ));
     }
 
     let mut limited = entry.take(MAX_DECOMPRESSED_SIZE + 1);
     let mut result = Vec::with_capacity(entry_size.min(MAX_DECOMPRESSED_SIZE) as usize);
     limited
         .read_to_end(&mut result)
-        .map_err(|e| format!("Failed to read entry: {}", e))?;
+        .map_err(|e| format!("Failed to read entry: {e}"))?;
 
     Ok(result)
 }
 
 /// Compress directory to zip
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn zip_create(source_dir: String, zip_path: String) -> Result<(), String> {
-    let file = File::create(&zip_path).map_err(|e| format!("Failed to create zip: {}", e))?;
+    let file = File::create(&zip_path).map_err(|e| format!("Failed to create zip: {e}"))?;
 
     let mut zip = zip::ZipWriter::new(file);
     let options = zip::write::SimpleFileOptions::default()
@@ -135,28 +139,27 @@ pub fn zip_create(source_dir: String, zip_path: String) -> Result<(), String> {
     let walkdir = walkdir::WalkDir::new(&source_dir);
     let source_path = std::path::Path::new(&source_dir);
 
-    for entry in walkdir.into_iter().filter_map(|e| e.ok()) {
+    for entry in walkdir.into_iter().filter_map(std::result::Result::ok) {
         let path = entry.path();
         let name = path
             .strip_prefix(source_path)
-            .map_err(|e| format!("Path error: {}", e))?
+            .map_err(|e| format!("Path error: {e}"))?
             .to_string_lossy();
 
         if path.is_file() {
             zip.start_file(name, options)
-                .map_err(|e| format!("Failed to start file: {}", e))?;
+                .map_err(|e| format!("Failed to start file: {e}"))?;
 
-            let mut f = File::open(path).map_err(|e| format!("Failed to open file: {}", e))?;
-            std::io::copy(&mut f, &mut zip)
-                .map_err(|e| format!("Failed to write to zip: {}", e))?;
+            let mut f = File::open(path).map_err(|e| format!("Failed to open file: {e}"))?;
+            std::io::copy(&mut f, &mut zip).map_err(|e| format!("Failed to write to zip: {e}"))?;
         } else if !name.is_empty() {
             zip.add_directory(name, options)
-                .map_err(|e| format!("Failed to add directory: {}", e))?;
+                .map_err(|e| format!("Failed to add directory: {e}"))?;
         }
     }
 
     zip.finish()
-        .map_err(|e| format!("Failed to finish zip: {}", e))?;
+        .map_err(|e| format!("Failed to finish zip: {e}"))?;
 
     Ok(())
 }

src-tauri/src/commands/compress.rs

@@ -5,24 +5,26 @@ use std::io::Read;
 
 const HASH_BUF_SIZE: usize = 64 * 1024;
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn sha256_hash(data: Vec<u8>) -> String {
     let mut hasher = Sha256::new();
     hasher.update(&data);
     format!("{:x}", hasher.finalize())
 }
 
+#[allow(clippy::needless_pass_by_value, clippy::large_stack_arrays)]
 #[tauri::command]
 pub fn sha256_file(path: String) -> Result<String, String> {
-    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {}", e))?;
+    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {e}"))?;
     let mut reader = std::io::BufReader::with_capacity(HASH_BUF_SIZE, file);
     let mut hasher = Sha256::new();
     let mut buf = [0u8; HASH_BUF_SIZE];
 
     loop {
         let n = reader
             .read(&mut buf)
-            .map_err(|e| format!("Failed to read file: {}", e))?;
+            .map_err(|e| format!("Failed to read file: {e}"))?;
         if n == 0 {
             break;
         }
@@ -32,22 +34,24 @@ pub fn sha256_file(path: String) -> Result<String, String> {
     Ok(format!("{:x}", hasher.finalize()))
 }
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn md5_hash(data: Vec<u8>) -> String {
     format!("{:x}", md5::compute(&data))
 }
 
+#[allow(clippy::needless_pass_by_value, clippy::large_stack_arrays)]
 #[tauri::command]
 pub fn md5_file(path: String) -> Result<String, String> {
-    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {}", e))?;
+    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {e}"))?;
     let mut reader = std::io::BufReader::with_capacity(HASH_BUF_SIZE, file);
     let mut context = md5::Context::new();
     let mut buf = [0u8; HASH_BUF_SIZE];
 
     loop {
         let n = reader
             .read(&mut buf)
-            .map_err(|e| format!("Failed to read file: {}", e))?;
+            .map_err(|e| format!("Failed to read file: {e}"))?;
         if n == 0 {
             break;
         }
@@ -70,32 +74,36 @@ pub fn uuid_v4() -> String {
     uuid::Uuid::new_v4().to_string()
 }
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn base64_encode(data: Vec<u8>) -> String {
     use base64::{engine::general_purpose::STANDARD, Engine as _};
     STANDARD.encode(&data)
 }
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn base64_decode(text: String) -> Result<Vec<u8>, String> {
     use base64::{engine::general_purpose::STANDARD, Engine as _};
     STANDARD
         .decode(&text)
-        .map_err(|e| format!("Base64 decode error: {}", e))
+        .map_err(|e| format!("Base64 decode error: {e}"))
 }
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn base64_encode_urlsafe(data: Vec<u8>) -> String {
     use base64::{engine::general_purpose::URL_SAFE, Engine as _};
     URL_SAFE.encode(&data)
 }
 
+#[allow(clippy::needless_pass_by_value)]
 #[tauri::command]
 pub fn base64_decode_urlsafe(text: String) -> Result<Vec<u8>, String> {
     use base64::{engine::general_purpose::URL_SAFE, Engine as _};
     URL_SAFE
         .decode(&text)
-        .map_err(|e| format!("Base64 decode error: {}", e))
+        .map_err(|e| format!("Base64 decode error: {e}"))
 }
 
 #[derive(Debug, Serialize)]
@@ -106,12 +114,13 @@ pub struct FileHashInfo {
     pub size: u64,
 }
 
+#[allow(clippy::needless_pass_by_value, clippy::large_stack_arrays)]
 #[tauri::command]
 pub fn file_hashes(path: String) -> Result<FileHashInfo, String> {
-    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {}", e))?;
+    let file = std::fs::File::open(&path).map_err(|e| format!("Failed to open file: {e}"))?;
     let file_size = file
         .metadata()
-        .map_err(|e| format!("Failed to get metadata: {}", e))?
+        .map_err(|e| format!("Failed to get metadata: {e}"))?
         .len();
 
     let mut reader = std::io::BufReader::with_capacity(HASH_BUF_SIZE, file);
@@ -122,7 +131,7 @@ pub fn file_hashes(path: String) -> Result<FileHashInfo, String> {
     loop {
         let n = reader
             .read(&mut buf)
-            .map_err(|e| format!("Failed to read file: {}", e))?;
+            .map_err(|e| format!("Failed to read file: {e}"))?;
         if n == 0 {
             break;
         }