Applied clippy fixes

src/parser/mod.rs

@@ -18,17 +18,17 @@ pub fn get_metadata(uri: &str) -> String {
         name: data.remarks,
         host: data.host.clone(),
         address: data.address.clone(),
-        port: data.port.clone(),
+        port: data.port,
         protocol,
     };
-    let serialized = serde_json::to_string(&meta_data).unwrap();
+    
-    return serialized;
+    serde_json::to_string(&meta_data).unwrap()
 }
 
 pub fn create_json_config(uri: &str, socks_port: Option<u16>, http_port: Option<u16>) -> String {
     let config = create_config(uri, socks_port, http_port);
-    let serialized = serde_json::to_string(&config).unwrap();
+    
-    return serialized;
+    serde_json::to_string(&config).unwrap()
 }
 
 pub fn create_config(
@@ -42,11 +42,11 @@ pub fn create_config(
             socks_port,
             http_port,
         });
-    let config = config_models::Config {
+    
+    config_models::Config {
         outbounds: vec![outbound_object],
         inbounds: inbound_config,
-    };
+    }
-    return config;
 }
 
 pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
@@ -56,7 +56,9 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
     let allow_insecure = data.allowInsecure == Some(String::from("true"))
         || data.allowInsecure == Some(String::from("1"));
 
-    let outbound = Outbound {
+    
+
+    Outbound {
         protocol: name,
         tag: String::from("proxy"),
         streamSettings: StreamSettings {
@@ -79,7 +81,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            wsSettings: if network_type == String::from("ws") {
+            wsSettings: if network_type == "ws" {
                 Some(WsSettings {
                     Host: data.host.clone(),
                     path: data.path.clone(),
@@ -88,7 +90,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            tcpSettings: if network_type == String::from("tcp") {
+            tcpSettings: if network_type == "tcp" {
                 Some(TCPSettings {
                     header: Some(TCPHeader {
                         r#type: Some(data.header_type.unwrap_or(String::from("none"))),
@@ -109,7 +111,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            grpcSettings: if network_type == String::from("grpc") {
+            grpcSettings: if network_type == "grpc" {
                 Some(GRPCSettings {
                     authority: data.authority,
                     multiMode: Some(false),
@@ -118,7 +120,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            quicSettings: if network_type == String::from("quic") {
+            quicSettings: if network_type == "quic" {
                 Some(QuicSettings {
                     header: Some(NonHeaderObject {
                         r#type: Some(String::from("none")),
@@ -129,7 +131,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            kcpSettings: if network_type == String::from("kcp") {
+            kcpSettings: if network_type == "kcp" {
                 Some(KCPSettings {
                     mtu: None,
                     tti: None,
@@ -143,7 +145,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             } else {
                 None
             },
-            xhttpSettings: if network_type == String::from("xhttp") {
+            xhttpSettings: if network_type == "xhttp" {
                 Some(XHTTPSettings {
                     host: data.host.clone(),
                     path: data.path.clone(),
@@ -155,14 +157,12 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
             },
         },
         settings: outbound_settings,
-    };
+    }
-
-    return outbound;
 }
 
 fn get_uri_data(uri: &str) -> (String, RawData, OutboundSettings) {
     let protocol = uri_identifier::get_uri_protocol(uri);
-    return match protocol {
+    match protocol {
         Some(uri_identifier::Protocols::Vless) => {
             let d = vless::data::get_data(uri);
             let s = vless::create_outbound_settings(&d);
@@ -194,5 +194,5 @@ fn get_uri_data(uri: &str) -> (String, RawData, OutboundSettings) {
         None => {
             panic!("The protocol is not supported");
         }
-    };
+    }
 }

src/parser/shadow_socks/data.rs

@@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData {
     let (raw_data, name) = data.split_once("#").unwrap_or((data, ""));
     let (raw_uri, _) = raw_data.split_once("?").unwrap_or((raw_data, ""));
     let parsed_address = parse_ss_address(raw_uri);
-    return RawData {
+    RawData {
         remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")),
         server_method: url_decode(Some(parsed_address.method)),
         address: Some(parsed_address.address),
@@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData {
         allowInsecure: None,
         vnext_security: None,
         username: None,
-    };
+    }
 }
 
 fn parse_ss_address(raw_data: &str) -> models::ShadowSocksAddress {
@@ -65,10 +65,10 @@ fn parse_ss_address(raw_data: &str) -> models::ShadowSocksAddress {
         .split_once(":")
         .expect("No `:` found in the decoded base64");
 
-    return models::ShadowSocksAddress {
+    models::ShadowSocksAddress {
         method: String::from(method),
         password: String::from(password),
         address: parsed.host().unwrap().to_string(),
         port: parsed.port().unwrap().as_u16(),
-    };
+    }
 }

src/parser/shadow_socks/mod.rs

@@ -3,7 +3,7 @@ mod models;
 use crate::config_models::*;
 
 pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
-    return OutboundSettings::ShadowSocks(ShadowSocksOutboundSettings {
+    OutboundSettings::ShadowSocks(ShadowSocksOutboundSettings {
         servers: vec![ShadowSocksServerObject {
             address: data.address.clone(),
             port: data.port,
@@ -11,5 +11,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
             level: Some(0),
             method: data.server_method.clone(),
         }],
-    });
+    })
 }

src/parser/socks/data.rs

@@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData {
     let (raw_data, name) = data.split_once("#").unwrap_or((data, ""));
     let (raw_uri, _) = raw_data.split_once("?").unwrap_or((raw_data, ""));
     let parsed_address = parse_socks_address(raw_uri);
-    return RawData {
+    RawData {
         remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")),
         username: url_decode(parsed_address.username),
         address: Some(parsed_address.address),
@@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData {
         quic_security: None,
         allowInsecure: None,
         vnext_security: None,
-    };
+    }
 }
 
 fn parse_socks_address(raw_data: &str) -> models::SocksAddress {
@@ -54,7 +54,7 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress {
 
     let parsed = address_wo_slash.parse::<Uri>().unwrap();
 
-    return match maybe_userinfo {
+    match maybe_userinfo {
         Some(userinfo) => {
             let url_decoded = url_decode_str(&userinfo).unwrap_or(userinfo);
             let username_and_password = general_purpose::STANDARD
@@ -64,7 +64,7 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress {
                         std::str::from_utf8(&a).expect("Base64 did not yield a valid utf-8 string"),
                     )
                 })
-                .unwrap_or(String::from(url_decoded.clone()));
+                .unwrap_or(url_decoded.clone());
 
             let (username, password) = username_and_password
                 .split_once(":")
@@ -83,5 +83,5 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress {
             address: parsed.host().unwrap().to_string(),
             port: parsed.port().unwrap().as_u16(),
         },
-    };
+    }
 }

src/parser/socks/mod.rs

@@ -3,7 +3,7 @@ mod models;
 use crate::config_models::*;
 
 pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
-    return OutboundSettings::Socks(SocksOutboundSettings {
+    OutboundSettings::Socks(SocksOutboundSettings {
         servers: vec![SocksServerObject {
             users: match (&data.username, &data.uuid) {
                 (Some(username), Some(uuid)) => Some(vec![SocksUser {
@@ -16,5 +16,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
             port: data.port,
             level: Some(0),
         }],
-    });
+    })
 }

src/parser/trojan/data.rs

@@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData {
     let parsed_address = parse_trojan_address(data.split_once("?").unwrap().0);
     let query: Vec<(&str, &str)> = querystring::querify(raw_query);
 
-    return RawData {
+    RawData {
         remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")),
         uuid: Some(parsed_address.uuid),
         port: Some(parsed_address.port),
@@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData {
         allowInsecure: get_parameter_value(&query, "allowInsecure"),
         server_method: None,
         username: None,
-    };
+    }
 }
 
 fn parse_trojan_address(raw_data: &str) -> models::TrojanAddress {
@@ -56,9 +56,9 @@ fn parse_trojan_address(raw_data: &str) -> models::TrojanAddress {
 
     let parsed = address_wo_slash.parse::<Uri>().unwrap();
 
-    return models::TrojanAddress {
+    models::TrojanAddress {
         uuid: url_decode(Some(uuid)).unwrap(),
         address: parsed.host().unwrap().to_string(),
         port: parsed.port().unwrap().as_u16(),
-    };
+    }
 }

src/parser/trojan/mod.rs

@@ -3,12 +3,12 @@ mod models;
 use crate::config_models::*;
 
 pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
-    return OutboundSettings::Trojan(TrojanOutboundSettings {
+    OutboundSettings::Trojan(TrojanOutboundSettings {
         servers: vec![TrojanServerObject {
             address: data.address.clone(),
             port: data.port,
             password: data.uuid.clone(),
             level: Some(0),
         }],
-    });
+    })
 }

src/parser/uri_identifier.rs

@@ -26,7 +26,7 @@ pub fn get_uri_protocol(uri: &str) -> Option<Protocols> {
     if uri.starts_with("trojan://") {
         return Some(Protocols::Trojan);
     }
-    return None;
+    None
 }
 
 #[cfg(test)]
@@ -37,7 +37,7 @@ mod tests {
         let protocol = get_uri_protocol(
             "123-vless://3d1c3f04-729d-59d3-bdb6-3f3f4352e173@root.ii.one:2083?security=reality&sni=www.spamhaus.org&fp=safari&pbk=7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04&sid=6ba85179e30d4fc2&type=tcp&flow=xtls-rprx-vision#Ha-ac",
         );
-        assert!(matches!(protocol, None));
+        assert!(protocol.is_none());
     }
     #[test]
     fn recognize_vless_protocol() {

src/parser/vless/data.rs

@@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData {
     let parsed_address = parse_vless_address(data.split_once("?").unwrap().0);
     let query: Vec<(&str, &str)> = querystring::querify(raw_query);
 
-    return RawData {
+    RawData {
         remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")),
         uuid: Some(parsed_address.uuid),
         port: Some(parsed_address.port),
@@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData {
         allowInsecure: get_parameter_value(&query, "allowInsecure"),
         server_method: None,
         username: None,
-    };
+    }
 }
 
 fn parse_vless_address(raw_data: &str) -> models::VlessAddress {
@@ -56,9 +56,9 @@ fn parse_vless_address(raw_data: &str) -> models::VlessAddress {
 
     let parsed = address_wo_slash.parse::<Uri>().unwrap();
 
-    return models::VlessAddress {
+    models::VlessAddress {
         uuid: url_decode(Some(uuid)).unwrap(),
         address: parsed.host().unwrap().to_string(),
         port: parsed.port().unwrap().as_u16(),
-    };
+    }
 }

src/parser/vless/mod.rs

@@ -3,7 +3,7 @@ mod models;
 use crate::config_models::*;
 
 pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
-    return OutboundSettings::Vless(VlessOutboundSettings {
+    OutboundSettings::Vless(VlessOutboundSettings {
         vnext: vec![VnextServerObject {
             port: data.port,
             address: data.address.clone(),
@@ -15,5 +15,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
                 security: None,
             }]),
         }],
-    });
+    })
 }

src/parser/vmess/data.rs

@@ -8,23 +8,22 @@ use serde_json::Value;
 pub fn get_data(uri: &str) -> RawData {
     let data = uri.split_once("vmess://").unwrap().1;
 
-    return match general_purpose::STANDARD
+    match general_purpose::STANDARD
         .decode(url_decode_str(data).unwrap_or(String::from(data)))
     {
         Ok(decoded) => get_raw_data_from_base64(&decoded),
         Err(_) => get_raw_data_from_uri(data),
-    };
+    }
 }
 
-fn get_raw_data_from_base64(decoded_base64: &Vec<u8>) -> RawData {
+fn get_raw_data_from_base64(decoded_base64: &[u8]) -> RawData {
     let json_str = std::str::from_utf8(decoded_base64).unwrap();
     let json = serde_json::from_str::<Value>(json_str).unwrap();
 
-    return RawData {
+    RawData {
         remarks: url_decode(get_str_field(&json, "ps")).unwrap_or(String::from("")),
         uuid: get_str_field(&json, "id"),
-        port: get_str_field(&json, "port")
+        port: get_str_field(&json, "port").map(|s| s.parse::<u16>().expect("port is not a number")),
-            .and_then(|s| Some(s.parse::<u16>().expect("port is not a number"))),
         address: get_str_field(&json, "add"),
         alpn: url_decode(get_str_field(&json, "alpn")),
         path: url_decode(get_str_field(&json, "path")),
@@ -59,11 +58,11 @@ fn get_raw_data_from_base64(decoded_base64: &Vec<u8>) -> RawData {
         allowInsecure: None,
         server_method: None,
         username: None,
-    };
+    }
 }
 
 fn get_str_field(json: &Value, field: &str) -> Option<String> {
-    return json.get(field).and_then(|v| v.as_str()).map(String::from);
+    json.get(field).and_then(|v| v.as_str()).map(String::from)
 }
 
 fn get_raw_data_from_uri(data: &str) -> RawData {
@@ -75,7 +74,7 @@ fn get_raw_data_from_uri(data: &str) -> RawData {
     let parsed_address = parse_vmess_address(data.split_once("?").unwrap().0);
     let query: Vec<(&str, &str)> = querystring::querify(raw_query);
 
-    return RawData {
+    RawData {
         remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")),
         uuid: Some(parsed_address.uuid),
         port: Some(parsed_address.port),
@@ -105,7 +104,7 @@ fn get_raw_data_from_uri(data: &str) -> RawData {
         allowInsecure: get_parameter_value(&query, "allowInsecure"),
         server_method: None,
         username: None,
-    };
+    }
 }
 
 fn parse_vmess_address(raw_data: &str) -> VmessAddress {
@@ -119,9 +118,9 @@ fn parse_vmess_address(raw_data: &str) -> VmessAddress {
 
     let parsed = address_wo_slash.parse::<Uri>().unwrap();
 
-    return VmessAddress {
+    VmessAddress {
         uuid: url_decode(Some(uuid)).unwrap(),
         address: parsed.host().unwrap().to_string(),
         port: parsed.port().unwrap().as_u16(),
-    };
+    }
 }

src/parser/vmess/mod.rs

@@ -3,7 +3,7 @@ mod models;
 use crate::config_models::*;
 
 pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
-    return OutboundSettings::Vmess(VmessOutboundSettings {
+    OutboundSettings::Vmess(VmessOutboundSettings {
         vnext: vec![VnextServerObject {
             port: data.port,
             address: data.address.clone(),
@@ -15,5 +15,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings {
                 security: data.vnext_security.clone(),
             }]),
         }],
-    });
+    })
 }

src/utils/inbound_generator.rs

@@ -7,25 +7,19 @@ pub struct InboundGenerationOptions {
 
 pub fn generate_inbound_config(options: InboundGenerationOptions) -> Vec<config_models::Inbound> {
     let mut inbounds: Vec<config_models::Inbound> = vec![];
-    match options.socks_port {
+    if let Some(port) = options.socks_port {
-        Some(port) => {
         inbounds.push(generate_socks_inbound(port));
     }
-        None => {}
-    }
 
-    match options.http_port {
+    if let Some(port) = options.http_port {
-        Some(port) => {
         inbounds.push(generate_http_inbound(port));
     }
-        None => {}
-    }
 
-    return inbounds;
+    inbounds
 }
 
 pub fn generate_http_inbound(http_port: u16) -> config_models::Inbound {
-    return config_models::Inbound {
+    config_models::Inbound {
         protocol: String::from("http"),
         port: http_port,
         tag: String::from("http-in"),
@@ -42,11 +36,11 @@ pub fn generate_http_inbound(http_port: u16) -> config_models::Inbound {
                 String::from("quic"),
             ]),
         }),
-    };
+    }
 }
 
 pub fn generate_socks_inbound(socks_port: u16) -> config_models::Inbound {
-    return config_models::Inbound {
+    config_models::Inbound {
         protocol: String::from("socks"),
         port: socks_port,
         tag: String::from("socks-in"),
@@ -63,5 +57,5 @@ pub fn generate_socks_inbound(socks_port: u16) -> config_models::Inbound {
                 String::from("quic"),
             ]),
         }),
-    };
+    }
 }

src/utils/mod.rs

@@ -1,17 +1,17 @@
 pub mod inbound_generator;
 
 pub fn url_decode_str(value: &str) -> Option<String> {
-    return urlencoding::decode(value)
+    urlencoding::decode(value)
         .ok()
-        .map(|decoded| decoded.into_owned());
+        .map(|decoded| decoded.into_owned())
 }
 
 pub fn url_decode(value: Option<String>) -> Option<String> {
-    return value.and_then(|s| {
+    value.and_then(|s| {
         urlencoding::decode(&s)
             .ok()
             .map(|decoded| decoded.into_owned())
-    });
+    })
 }
 
 pub fn parse_raw_json(input: &str) -> Option<serde_json::Value> {
@@ -24,8 +24,8 @@ pub fn parse_raw_json(input: &str) -> Option<serde_json::Value> {
 }
 
 pub fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option<String> {
-    return query
+    query
         .iter()
-        .find(|q| String::from(q.0) == String::from(param))
+        .find(|q| q.0 == param)
-        .map(|q| q.1.to_string());
+        .map(|q| q.1.to_string())
 }

src/xray_runner.rs

@@ -50,7 +50,7 @@ impl XrayRunner {
             println!("Stopping xray-core process...");
 
             // Try graceful shutdown first
-            if let Err(_) = process.kill().await {
+            if (process.kill().await).is_err() {
                 eprintln!("Failed to kill xray-core process gracefully");
             }
 
@@ -62,7 +62,7 @@ impl XrayRunner {
         }
 
         // Cleanup config file
-        if let Some(_) = self.config_file.take() {
+        if self.config_file.take().is_some() {
             println!("Cleaned up temporary config file");
         }