fix: clippy errors with new config (#4428)

* refactor: improve code quality with clippy fixes and standardized logging

- Replace dangerous unwrap()/expect() calls with proper error handling
- Standardize logging from log:: to logging\! macro with Type:: classifications
- Fix app handle panics with graceful fallback patterns
- Improve error resilience across 35+ modules without breaking functionality
- Reduce clippy warnings from 300+ to 0 in main library code

* chore: update Cargo.toml configuration

* refactor: resolve all clippy warnings
- Fix Arc clone warnings using explicit Arc::clone syntax across 9 files
- Add #[allow(clippy::expect_used)] to test functions for appropriate expect usage
- Remove no-effect statements from debug code cleanup
- Apply clippy auto-fixes for dbg\! macro removals and path statements
- Achieve zero clippy warnings on all targets with -D warnings flag

* chore: update Cargo.toml clippy configuration

* refactor: simplify macOS job configuration and improve caching

* refactor: remove unnecessary async/await from service and proxy functions

* refactor: streamline pnpm installation in CI configuration

* refactor: simplify error handling and remove unnecessary else statements

* refactor: replace async/await with synchronous locks for core management

* refactor: add workflow_dispatch trigger to clippy job

* refactor: convert async functions to synchronous for service management

* refactor: convert async functions to synchronous for UWP tool invocation

* fix: change wrong logging

* refactor: convert proxy restoration functions to async

* Revert "refactor: convert proxy restoration functions to async"

This reverts commit b82f5d250b.

* refactor: update proxy restoration functions to return Result types

* fix: handle errors during proxy restoration and update async function signatures

* fix: handle errors during proxy restoration and update async function signatures

* refactor: update restore_pac_proxy and restore_sys_proxy functions to async

* fix: convert restore_pac_proxy and restore_sys_proxy functions to async

* fix: await restore_sys_proxy calls in proxy restoration logic

* fix: suppress clippy warnings for unused async functions in proxy restoration

* fix: suppress clippy warnings for unused async functions in proxy restoration

src-tauri/src/config/clash.rs

@@ -19,7 +19,9 @@ impl IClashTemp {
             Ok(mut map) => {
                 template.0.keys().for_each(|key| {
                     if !map.contains_key(key) {
-                        map.insert(key.clone(), template.0.get(key).unwrap().clone());
+                        if let Some(value) = template.0.get(key) {
+                            map.insert(key.clone(), value.clone());
+                        }
                     }
                 });
                 // 确保 secret 字段存在且不为空
@@ -307,7 +309,13 @@ impl IClashTemp {
 
     pub fn guard_external_controller_ipc() -> String {
         // 总是使用当前的 IPC 路径，确保配置文件与运行时路径一致
-        path_to_str(&ipc_path().unwrap()).unwrap().to_string()
+        ipc_path()
+            .ok()
+            .and_then(|path| path_to_str(&path).ok().map(|s| s.to_string()))
+            .unwrap_or_else(|| {
+                log::error!(target: "app", "Failed to get IPC path, using default");
+                "127.0.0.1:9090".to_string()
+            })
     }
 }
 

src-tauri/src/config/config.rs

@@ -72,7 +72,7 @@ impl Config {
                 .append_item(script_item.clone())?;
         }
         // 生成运行时配置
-        if let Err(err) = Self::generate().await {
+        if let Err(err) = Self::generate() {
             logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
         } else {
             logging!(info, Type::Config, true, "生成运行时配置成功");
@@ -96,8 +96,7 @@ impl Config {
                             error_msg
                         );
                         CoreManager::global()
-                            .use_default_config("config_validate::boot_error", &error_msg)
-                            .await?;
+                            .use_default_config("config_validate::boot_error", &error_msg)?;
                         Some(("config_validate::boot_error", error_msg))
                     } else {
                         logging!(info, Type::Config, true, "配置验证成功");
@@ -107,16 +106,13 @@ impl Config {
                 Err(err) => {
                     logging!(warn, Type::Config, true, "验证进程执行失败: {}", err);
                     CoreManager::global()
-                        .use_default_config("config_validate::process_terminated", "")
-                        .await?;
+                        .use_default_config("config_validate::process_terminated", "")?;
                     Some(("config_validate::process_terminated", String::new()))
                 }
             }
         } else {
             logging!(warn, Type::Config, true, "生成配置文件失败，使用默认配置");
-            CoreManager::global()
-                .use_default_config("config_validate::error", "")
-                .await?;
+            CoreManager::global().use_default_config("config_validate::error", "")?;
             Some(("config_validate::error", String::new()))
         };
 
@@ -150,8 +146,8 @@ impl Config {
     }
 
     /// 生成订阅存好
-    pub async fn generate() -> Result<()> {
-        let (config, exists_keys, logs) = enhance::enhance().await;
+    pub fn generate() -> Result<()> {
+        let (config, exists_keys, logs) = enhance::enhance();
 
         *Config::runtime().draft_mut() = Box::new(IRuntime {
             config: Some(config),
@@ -174,33 +170,33 @@ mod tests {
     use std::mem;
 
     #[test]
+    #[allow(unused_variables)]
+    #[allow(clippy::expect_used)]
     fn test_prfitem_from_merge_size() {
-        let merge_item = PrfItem::from_merge(Some("Merge".to_string())).unwrap();
-        dbg!(&merge_item);
+        let merge_item = PrfItem::from_merge(Some("Merge".to_string()))
+            .expect("Failed to create merge item in test");
         let prfitem_size = mem::size_of_val(&merge_item);
-        dbg!(prfitem_size);
         // Boxed version
         let boxed_merge_item = Box::new(merge_item);
         let box_prfitem_size = mem::size_of_val(&boxed_merge_item);
-        dbg!(box_prfitem_size);
         // The size of Box<T> is always pointer-sized (usually 8 bytes on 64-bit)
         // assert_eq!(box_prfitem_size, mem::size_of::<Box<PrfItem>>());
         assert!(box_prfitem_size < prfitem_size);
     }
 
     #[test]
+    #[allow(unused_variables)]
     fn test_draft_size_non_boxed() {
         let draft = Draft::from(IRuntime::new());
         let iruntime_size = std::mem::size_of_val(&draft);
-        dbg!(iruntime_size);
         assert_eq!(iruntime_size, std::mem::size_of::<Draft<IRuntime>>());
     }
 
     #[test]
+    #[allow(unused_variables)]
     fn test_draft_size_boxed() {
         let draft = Draft::from(Box::new(IRuntime::new()));
         let box_iruntime_size = std::mem::size_of_val(&draft);
-        dbg!(box_iruntime_size);
         assert_eq!(
             box_iruntime_size,
             std::mem::size_of::<Draft<Box<IRuntime>>>()

src-tauri/src/config/draft.rs

@@ -46,11 +46,18 @@ impl<T: Clone + ToOwned> Draft<Box<T>> {
         if guard.1.is_none() {
             let mut guard = RwLockUpgradableReadGuard::upgrade(guard);
             guard.1 = Some(guard.0.clone());
-            return RwLockWriteGuard::map(guard, |inner| inner.1.as_mut().unwrap());
+            return RwLockWriteGuard::map(guard, |inner| {
+                inner.1.as_mut().unwrap_or_else(|| {
+                    unreachable!("Draft was just created above, this should never fail")
+                })
+            });
         }
         // 已存在草稿，升级为写锁映射
         RwLockWriteGuard::map(RwLockUpgradableReadGuard::upgrade(guard), |inner| {
-            inner.1.as_mut().unwrap()
+            inner
+                .1
+                .as_mut()
+                .unwrap_or_else(|| unreachable!("Draft should exist when guard.1.is_some()"))
         })
     }
 

src-tauri/src/config/prfitem.rs

@@ -147,12 +147,15 @@ impl PrfItem {
             bail!("type should not be null");
         }
 
-        match item.itype.unwrap().as_str() {
+        let itype = item
+            .itype
+            .ok_or_else(|| anyhow::anyhow!("type should not be null"))?;
+        match itype.as_str() {
             "remote" => {
-                if item.url.is_none() {
-                    bail!("url should not be null");
-                }
-                let url = item.url.as_ref().unwrap().as_str();
+                let url = item
+                    .url
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!("url should not be null"))?;
                 let name = item.name;
                 let desc = item.desc;
                 PrfItem::from_url(url, name, desc, item.option).await
@@ -549,22 +552,20 @@ impl PrfItem {
 
     /// get the file data
     pub fn read_file(&self) -> Result<String> {
-        if self.file.is_none() {
-            bail!("could not find the file");
-        }
-
-        let file = self.file.clone().unwrap();
+        let file = self
+            .file
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
         let path = dirs::app_profiles_dir()?.join(file);
         fs::read_to_string(path).context("failed to read the file")
     }
 
     /// save the file data
     pub fn save_file(&self, data: String) -> Result<()> {
-        if self.file.is_none() {
-            bail!("could not find the file");
-        }
-
-        let file = self.file.clone().unwrap();
+        let file = self
+            .file
+            .clone()
+            .ok_or_else(|| anyhow::anyhow!("could not find the file"))?;
         let path = dirs::app_profiles_dir()?.join(file);
         fs::write(path, data.as_bytes()).context("failed to save the file")
     }

src-tauri/src/config/profiles.rs

@@ -77,10 +77,11 @@ impl IProfiles {
         }
 
         if let Some(current) = patch.current {
-            let items = self.items.as_ref().unwrap();
-            let some_uid = Some(current);
-            if items.iter().any(|e| e.uid == some_uid) {
-                self.current = some_uid;
+            if let Some(items) = self.items.as_ref() {
+                let some_uid = Some(current);
+                if items.iter().any(|e| e.uid == some_uid) {
+                    self.current = some_uid;
+                }
             }
         }
 
@@ -127,7 +128,9 @@ impl IProfiles {
                 bail!("the file should not be null");
             }
 
-            let file = item.file.clone().unwrap();
+            let file = item.file.clone().ok_or_else(|| {
+                anyhow::anyhow!("file field is required when file_data is provided")
+            })?;
             let path = dirs::app_profiles_dir()?.join(&file);
 
             fs::File::create(path)
@@ -168,11 +171,12 @@ impl IProfiles {
             }
         }
 
-        if old_index.is_none() || new_index.is_none() {
-            return Ok(());
-        }
-        let item = items.remove(old_index.unwrap());
-        items.insert(new_index.unwrap(), item);
+        let (old_idx, new_idx) = match (old_index, new_index) {
+            (Some(old), Some(new)) => (old, new),
+            _ => return Ok(()),
+        };
+        let item = items.remove(old_idx);
+        items.insert(new_idx, item);
         self.items = Some(items);
         self.save_file()
     }