feat(clippy): cognitive-complexity rule (#5215)

* feat(config): enhance configuration initialization and validation process

* refactor(profile): streamline profile update logic and enhance error handling

* refactor(config): simplify profile item checks and streamline update flag processing

* refactor(disney_plus): add cognitive complexity allowance for check_disney_plus function

* refactor(enhance): restructure configuration and profile item handling for improved clarity and maintainability

* refactor(tray): add cognitive complexity allowance for create_tray_menu function

* refactor(config): add cognitive complexity allowance for patch_config function

* refactor(profiles): simplify item removal logic by introducing take_item_file_by_uid helper function

* refactor(profile): add new validation logic for profile configuration syntax

* refactor(profiles): improve formatting and readability of take_item_file_by_uid function

* refactor(cargo): change cognitive complexity level from warn to deny

* refactor(cargo): ensure cognitive complexity is denied in Cargo.toml

* refactor(i18n): clean up imports and improve code readability
refactor(proxy): simplify system proxy toggle logic
refactor(service): remove unnecessary `as_str()` conversion in error handling
refactor(tray): modularize tray menu creation for better maintainability

* refactor(tray): update menu item text handling to use references for improved performance

src-tauri/src/enhance/mod.rs

@@ -12,11 +12,35 @@ use smartstring::alias::String;
 use std::collections::{HashMap, HashSet};
 
 type ResultLog = Vec<(String, String)>;
+#[derive(Debug)]
+struct ConfigValues {
+    clash_config: Mapping,
+    clash_core: Option<String>,
+    enable_tun: bool,
+    enable_builtin: bool,
+    socks_enabled: bool,
+    http_enabled: bool,
+    enable_dns_settings: bool,
+    #[cfg(not(target_os = "windows"))]
+    redir_enabled: bool,
+    #[cfg(target_os = "linux")]
+    tproxy_enabled: bool,
+}
 
-/// Enhance mode
-/// 返回最终订阅、该订阅包含的键、和script执行的结果
-pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
-    // config.yaml 的订阅
+#[derive(Debug)]
+struct ProfileItems {
+    config: Mapping,
+    merge_item: ChainItem,
+    script_item: ChainItem,
+    rules_item: ChainItem,
+    proxies_item: ChainItem,
+    groups_item: ChainItem,
+    global_merge: ChainItem,
+    global_script: ChainItem,
+    profile_name: String,
+}
+
+async fn get_config_values() -> ConfigValues {
     let clash_config = { Config::clash().await.latest_ref().0.clone() };
 
     let (clash_core, enable_tun, enable_builtin, socks_enabled, http_enabled, enable_dns_settings) = {
@@ -31,12 +55,14 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             verge.enable_dns_settings.unwrap_or(false),
         )
     };
+
     #[cfg(not(target_os = "windows"))]
     let redir_enabled = {
         let verge = Config::verge().await;
         let verge = verge.latest_ref();
         verge.verge_redir_enabled.unwrap_or(false)
     };
+
     #[cfg(target_os = "linux")]
     let tproxy_enabled = {
         let verge = Config::verge().await;
@@ -44,9 +70,189 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         verge.verge_tproxy_enabled.unwrap_or(false)
     };
 
+    ConfigValues {
+        clash_config,
+        clash_core,
+        enable_tun,
+        enable_builtin,
+        socks_enabled,
+        http_enabled,
+        enable_dns_settings,
+        #[cfg(not(target_os = "windows"))]
+        redir_enabled,
+        #[cfg(target_os = "linux")]
+        tproxy_enabled,
+    }
+}
+
+async fn collect_profile_items() -> ProfileItems {
     // 从profiles里拿东西 - 先收集需要的数据，然后释放锁
     let (
-        mut config,
+        current,
+        merge_uid,
+        script_uid,
+        rules_uid,
+        proxies_uid,
+        groups_uid,
+        _current_profile_uid,
+        name,
+    ) = {
+        let current = {
+            let profiles = Config::profiles().await;
+            let profiles_clone = profiles.latest_ref().clone();
+            profiles_clone.current_mapping().await.unwrap_or_default()
+        };
+
+        let profiles = Config::profiles().await;
+        let profiles_ref = profiles.latest_ref();
+
+        let merge_uid = profiles_ref.current_merge().unwrap_or_default();
+        let script_uid = profiles_ref.current_script().unwrap_or_default();
+        let rules_uid = profiles_ref.current_rules().unwrap_or_default();
+        let proxies_uid = profiles_ref.current_proxies().unwrap_or_default();
+        let groups_uid = profiles_ref.current_groups().unwrap_or_default();
+        let current_profile_uid = profiles_ref.get_current().unwrap_or_default();
+
+        let name = profiles_ref
+            .get_item(&current_profile_uid)
+            .ok()
+            .and_then(|item| item.name.clone())
+            .unwrap_or_default();
+
+        (
+            current,
+            merge_uid,
+            script_uid,
+            rules_uid,
+            proxies_uid,
+            groups_uid,
+            current_profile_uid,
+            name,
+        )
+    };
+
+    // 现在获取具体的items，此时profiles锁已经释放
+    let merge_item = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&merge_uid).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "".into(),
+        data: ChainType::Merge(Mapping::new()),
+    });
+
+    let script_item = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&script_uid).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "".into(),
+        data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+    });
+
+    let rules_item = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&rules_uid).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "".into(),
+        data: ChainType::Rules(SeqMap::default()),
+    });
+
+    let proxies_item = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&proxies_uid).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "".into(),
+        data: ChainType::Proxies(SeqMap::default()),
+    });
+
+    let groups_item = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&groups_uid).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "".into(),
+        data: ChainType::Groups(SeqMap::default()),
+    });
+
+    let global_merge = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&"Merge".into()).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "Merge".into(),
+        data: ChainType::Merge(Mapping::new()),
+    });
+
+    let global_script = {
+        let item = {
+            let profiles = Config::profiles().await;
+            let profiles = profiles.latest_ref();
+            profiles.get_item(&"Script".into()).ok().cloned()
+        };
+        if let Some(item) = item {
+            <Option<ChainItem>>::from_async(&item).await
+        } else {
+            None
+        }
+    }
+    .unwrap_or_else(|| ChainItem {
+        uid: "Script".into(),
+        data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
+    });
+
+    ProfileItems {
+        config: current,
         merge_item,
         script_item,
         rules_item,
@@ -54,192 +260,19 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         groups_item,
         global_merge,
         global_script,
-        profile_name,
-    ) = {
-        // 收集所有需要的数据，然后释放profiles锁
-        let (
-            current,
-            merge_uid,
-            script_uid,
-            rules_uid,
-            proxies_uid,
-            groups_uid,
-            _current_profile_uid,
-            name,
-        ) = {
-            // 分离async调用和数据获取，避免借用检查问题
-            let current = {
-                let profiles = Config::profiles().await;
-                let profiles_clone = profiles.latest_ref().clone();
-                profiles_clone.current_mapping().await.unwrap_or_default()
-            };
+        profile_name: name,
+    }
+}
 
-            // 重新获取锁进行其他操作
-            let profiles = Config::profiles().await;
-            let profiles_ref = profiles.latest_ref();
+fn process_global_items(
+    mut config: Mapping,
+    global_merge: ChainItem,
+    global_script: ChainItem,
+    profile_name: String,
+) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+    let mut result_map = HashMap::new();
+    let mut exists_keys = use_keys(&config);
 
-            let merge_uid = profiles_ref.current_merge().unwrap_or_default();
-            let script_uid = profiles_ref.current_script().unwrap_or_default();
-            let rules_uid = profiles_ref.current_rules().unwrap_or_default();
-            let proxies_uid = profiles_ref.current_proxies().unwrap_or_default();
-            let groups_uid = profiles_ref.current_groups().unwrap_or_default();
-            let current_profile_uid = profiles_ref.get_current().unwrap_or_default();
-
-            let name = profiles_ref
-                .get_item(&current_profile_uid)
-                .ok()
-                .and_then(|item| item.name.clone())
-                .unwrap_or_default();
-
-            (
-                current,
-                merge_uid,
-                script_uid,
-                rules_uid,
-                proxies_uid,
-                groups_uid,
-                current_profile_uid,
-                name,
-            )
-        };
-
-        // 现在获取具体的items，此时profiles锁已经释放
-        let merge = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&merge_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Merge(Mapping::new()),
-        });
-
-        let script = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&script_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        });
-
-        let rules = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&rules_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Rules(SeqMap::default()),
-        });
-
-        let proxies = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&proxies_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Proxies(SeqMap::default()),
-        });
-
-        let groups = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&groups_uid).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "".into(),
-            data: ChainType::Groups(SeqMap::default()),
-        });
-
-        let global_merge = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&"Merge".into()).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "Merge".into(),
-            data: ChainType::Merge(Mapping::new()),
-        });
-
-        let global_script = {
-            let item = {
-                let profiles = Config::profiles().await;
-                let profiles = profiles.latest_ref();
-                profiles.get_item(&"Script".into()).ok().cloned()
-            };
-            if let Some(item) = item {
-                <Option<ChainItem>>::from_async(&item).await
-            } else {
-                None
-            }
-        }
-        .unwrap_or_else(|| ChainItem {
-            uid: "Script".into(),
-            data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
-        });
-
-        (
-            current,
-            merge,
-            script,
-            rules,
-            proxies,
-            groups,
-            global_merge,
-            global_script,
-            name,
-        )
-    };
-
-    let mut result_map = HashMap::new(); // 保存脚本日志
-    let mut exists_keys = use_keys(&config); // 保存出现过的keys
-
-    // 全局Merge和Script
     if let ChainType::Merge(merge) = global_merge.data {
         exists_keys.extend(use_keys(&merge));
         config = use_merge(merge, config.to_owned());
@@ -247,7 +280,6 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
 
     if let ChainType::Script(script) = global_script.data {
         let mut logs = vec![];
-
         match use_script(script, config.to_owned(), profile_name.to_owned()) {
             Ok((res_config, res_logs)) => {
                 exists_keys.extend(use_keys(&res_config));
@@ -256,11 +288,24 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             }
             Err(err) => logs.push(("exception".into(), err.to_string().into())),
         }
-
         result_map.insert(global_script.uid, logs);
     }
 
-    // 订阅关联的Merge、Script、Rules、Proxies、Groups
+    (config, exists_keys, result_map)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn process_profile_items(
+    mut config: Mapping,
+    mut exists_keys: Vec<String>,
+    mut result_map: HashMap<String, ResultLog>,
+    rules_item: ChainItem,
+    proxies_item: ChainItem,
+    groups_item: ChainItem,
+    merge_item: ChainItem,
+    script_item: ChainItem,
+    profile_name: String,
+) -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     if let ChainType::Rules(rules) = rules_item.data {
         config = use_seq(rules, config.to_owned(), "rules");
     }
@@ -280,7 +325,6 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
 
     if let ChainType::Script(script) = script_item.data {
         let mut logs = vec![];
-
         match use_script(script, config.to_owned(), profile_name) {
             Ok((res_config, res_logs)) => {
                 exists_keys.extend(use_keys(&res_config));
@@ -289,11 +333,20 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             }
             Err(err) => logs.push(("exception".into(), err.to_string().into())),
         }
-
         result_map.insert(script_item.uid, logs);
     }
 
-    // 合并默认的config
+    (config, exists_keys, result_map)
+}
+
+async fn merge_default_config(
+    mut config: Mapping,
+    clash_config: Mapping,
+    socks_enabled: bool,
+    http_enabled: bool,
+    #[cfg(not(target_os = "windows"))] redir_enabled: bool,
+    #[cfg(target_os = "linux")] tproxy_enabled: bool,
+) -> Mapping {
     for (key, value) in clash_config.into_iter() {
         if key.as_str() == Some("tun") {
             let mut tun = config.get_mut("tun").map_or_else(Mapping::new, |val| {
@@ -353,7 +406,14 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         }
     }
 
-    // 内建脚本最后跑
+    config
+}
+
+fn apply_builtin_scripts(
+    mut config: Mapping,
+    clash_core: Option<String>,
+    enable_builtin: bool,
+) -> Mapping {
     if enable_builtin {
         ChainItem::builtin()
             .into_iter()
@@ -374,10 +434,10 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             });
     }
 
-    config = use_tun(config, enable_tun);
-    config = use_sort(config);
+    config
+}
 
-    // 应用独立的DNS配置（如果启用）
+fn apply_dns_settings(mut config: Mapping, enable_dns_settings: bool) -> Mapping {
     if enable_dns_settings {
         use crate::utils::dirs;
         use std::fs;
@@ -389,7 +449,6 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                 && let Ok(dns_yaml) = fs::read_to_string(&dns_path)
                 && let Ok(dns_config) = serde_yaml_ng::from_str::<serde_yaml_ng::Mapping>(&dns_yaml)
             {
-                // 处理hosts配置
                 if let Some(hosts_value) = dns_config.get("hosts")
                     && hosts_value.is_mapping()
                 {
@@ -410,9 +469,82 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
         }
     }
 
+    config
+}
+
+/// Enhance mode
+/// 返回最终订阅、该订阅包含的键、和script执行的结果
+pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
+    // gather config values
+    let cfg_vals = get_config_values().await;
+    let ConfigValues {
+        clash_config,
+        clash_core,
+        enable_tun,
+        enable_builtin,
+        socks_enabled,
+        http_enabled,
+        enable_dns_settings,
+        #[cfg(not(target_os = "windows"))]
+        redir_enabled,
+        #[cfg(target_os = "linux")]
+        tproxy_enabled,
+    } = cfg_vals;
+
+    // collect profile items
+    let profile = collect_profile_items().await;
+    let config = profile.config;
+    let merge_item = profile.merge_item;
+    let script_item = profile.script_item;
+    let rules_item = profile.rules_item;
+    let proxies_item = profile.proxies_item;
+    let groups_item = profile.groups_item;
+    let global_merge = profile.global_merge;
+    let global_script = profile.global_script;
+    let profile_name = profile.profile_name;
+
+    // process globals
+    let (config, exists_keys, result_map) =
+        process_global_items(config, global_merge, global_script, profile_name.clone());
+
+    // process profile-specific items
+    let (config, exists_keys, result_map) = process_profile_items(
+        config,
+        exists_keys,
+        result_map,
+        rules_item,
+        proxies_item,
+        groups_item,
+        merge_item,
+        script_item,
+        profile_name,
+    );
+
+    // merge default clash config
+    let config = merge_default_config(
+        config,
+        clash_config,
+        socks_enabled,
+        http_enabled,
+        #[cfg(not(target_os = "windows"))]
+        redir_enabled,
+        #[cfg(target_os = "linux")]
+        tproxy_enabled,
+    )
+    .await;
+
+    // builtin scripts
+    let mut config = apply_builtin_scripts(config, clash_core, enable_builtin);
+
+    config = use_tun(config, enable_tun);
+    config = use_sort(config);
+
+    // dns settings
+    config = apply_dns_settings(config, enable_dns_settings);
+
     let mut exists_set = HashSet::new();
     exists_set.extend(exists_keys);
-    exists_keys = exists_set.into_iter().collect();
+    let exists_keys: Vec<String> = exists_set.into_iter().collect();
 
     (config, exists_keys, result_map)
 }