feat: support seq editor

src-tauri/src/enhance/chain.rs

@@ -1,3 +1,4 @@
+use super::SeqMap;
 use crate::{
     config::PrfItem,
     utils::{dirs, help},
@@ -15,6 +16,9 @@ pub struct ChainItem {
 pub enum ChainType {
     Merge(Mapping),
     Script(String),
+    Rules(SeqMap),
+    Proxies(SeqMap),
+    Groups(SeqMap),
 }
 
 #[derive(Debug, Clone)]
@@ -43,7 +47,19 @@ impl From<&PrfItem> for Option<ChainItem> {
             }),
             "merge" => Some(ChainItem {
                 uid,
-                data: ChainType::Merge(help::read_merge_mapping(&path).ok()?),
+                data: ChainType::Merge(help::read_mapping(&path).ok()?),
+            }),
+            "rules" => Some(ChainItem {
+                uid,
+                data: ChainType::Rules(help::read_seq_map(&path).ok()?),
+            }),
+            "proxies" => Some(ChainItem {
+                uid,
+                data: ChainType::Proxies(help::read_seq_map(&path).ok()?),
+            }),
+            "groups" => Some(ChainItem {
+                uid,
+                data: ChainType::Groups(help::read_seq_map(&path).ok()?),
             }),
             _ => None,
         }

src-tauri/src/enhance/mod.rs

@@ -2,12 +2,14 @@ mod chain;
 pub mod field;
 mod merge;
 mod script;
+pub mod seq;
 mod tun;
 
 use self::chain::*;
 use self::field::*;
 use self::merge::*;
 use self::script::*;
+use self::seq::*;
 use self::tun::*;
 use crate::config::Config;
 use crate::utils::tmpl;
@@ -48,7 +50,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
     };
 
     // 从profiles里拿东西
-    let (mut config, merge_item, script_item) = {
+    let (mut config, merge_item, script_item, rules_item, proxies_item, groups_item) = {
         let profiles = Config::profiles();
         let profiles = profiles.latest();
 
@@ -59,9 +61,7 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
             .and_then(<Option<ChainItem>>::from)
             .unwrap_or_else(|| ChainItem {
                 uid: "".into(),
-                data: ChainType::Merge(
-                    serde_yaml::from_str::<Mapping>(tmpl::ITEM_MERGE).unwrap_or_default(),
-                ),
+                data: ChainType::Merge(Mapping::new()),
             });
         let script = profiles
             .get_item(&profiles.current_script().unwrap_or_default())
@@ -71,14 +71,56 @@ pub async fn enhance() -> (Mapping, Vec<String>, HashMap<String, ResultLog>) {
                 uid: "".into(),
                 data: ChainType::Script(tmpl::ITEM_SCRIPT.into()),
             });
+        let rules = profiles
+            .get_item(&profiles.current_rules().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Rules(SeqMap::default()),
+            });
+        let proxies = profiles
+            .get_item(&profiles.current_proxies().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Proxies(SeqMap::default()),
+            });
+        let groups = profiles
+            .get_item(&profiles.current_groups().unwrap_or_default())
+            .ok()
+            .and_then(<Option<ChainItem>>::from)
+            .unwrap_or_else(|| ChainItem {
+                uid: "".into(),
+                data: ChainType::Groups(SeqMap::default()),
+            });
 
-        (current, merge, script)
+        (current, merge, script, rules, proxies, groups)
     };
 
     let mut result_map = HashMap::new(); // 保存脚本日志
     let mut exists_keys = use_keys(&config); // 保存出现过的keys
 
     // 处理用户的profile
+    match rules_item.data {
+        ChainType::Rules(rules) => {
+            config = use_seq(rules, config.to_owned(), "rules");
+        }
+        _ => {}
+    }
+    match proxies_item.data {
+        ChainType::Proxies(proxies) => {
+            config = use_seq(proxies, config.to_owned(), "proxies");
+        }
+        _ => {}
+    }
+    match groups_item.data {
+        ChainType::Groups(groups) => {
+            config = use_seq(groups, config.to_owned(), "proxy-groups");
+        }
+        _ => {}
+    }
     match merge_item.data {
         ChainType::Merge(merge) => {
             exists_keys.extend(use_keys(&merge));

src-tauri/src/enhance/seq.rs

@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+use serde_yaml::{Mapping, Sequence, Value};
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct SeqMap {
+    prepend: Sequence,
+    append: Sequence,
+    delete: Sequence,
+}
+
+pub fn use_seq(seq_map: SeqMap, config: Mapping, name: &str) -> Mapping {
+    let prepend = seq_map.prepend;
+    let append = seq_map.append;
+    let delete = seq_map.delete;
+
+    let origin_seq = config.get(&name).map_or(Sequence::default(), |val| {
+        val.as_sequence().unwrap().clone()
+    });
+    let mut seq = origin_seq.clone();
+
+    for item in prepend {
+        seq.insert(0, item);
+    }
+
+    for item in append {
+        seq.push(item);
+    }
+
+    for item in delete {
+        seq.retain(|x| x != &item);
+    }
+    let mut config = config.clone();
+    config.insert(Value::from(name), Value::from(seq));
+    return config;
+}