minor refactoring

Author: monosans

Cargo.lock

@@ -3,9 +3,12 @@ use std::sync::LazyLock;
 use color_eyre::eyre::{OptionExt as _, WrapErr as _};
 
 pub static PROXY_REGEX: LazyLock<fancy_regex::Regex> = LazyLock::new(|| {
-    fancy_regex::Regex::new(
-        r"(?:^|[^\dA-Za-z])(?:(?P<protocol>https?|socks[45]):\/\/)?(?:(?P<username>[^\s:@]+):(?P<password>[^\s:@]+)@)?(?P<host>(?:[\-\.\dA-Za-z]+|(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])(?:\.(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){3})):(?P<port>\d|[1-9]\d{1,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])(?=[^\dA-Za-z]|$)"
-    ).unwrap()
+    fancy_regex::RegexBuilder::new(
+        r"(?:^|[^\dA-Za-z])(?:(?P<protocol>https?|socks[45]):\/\/)?(?:(?P<username>[^\s:@]+):(?P<password>[^\s:@]+)@)?(?P<host>(?:[\-\.\dA-Za-z]+|(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])(?:\.(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){3})):(?P<port>\d|[1-9]\d{1,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])(?=[^\dA-Za-z]|$)",
+    )
+    .case_insensitive(true)
+    .build()
+    .unwrap()
 });
 
 static IPV4_REGEX: LazyLock<fancy_regex::Regex> = LazyLock::new(|| {

src/parsers.rs

@@ -1,4 +1,4 @@
-use std::{fmt, sync::Arc};
+use std::{fmt, fmt::Write as _, sync::Arc};
 
 use color_eyre::eyre::{OptionExt as _, WrapErr as _, eyre};
 
@@ -21,7 +21,7 @@ impl TryFrom<&str> for ProxyType {
     type Error = color_eyre::Report;
 
     fn try_from(string: &str) -> color_eyre::Result<Self> {
-        match string {
+        match string.to_ascii_lowercase().as_str() {
             "http" | "https" => Ok(Self::Http),
             "socks4" => Ok(Self::Socks4),
             "socks5" => Ok(Self::Socks5),
@@ -60,24 +60,34 @@ pub struct Proxy {
     pub exit_ip: Option<String>,
 }
 
-impl Proxy {
-    pub async fn check(
-        &mut self,
-        config: Arc<Config>,
-    ) -> color_eyre::Result<()> {
-        let mut proxy = reqwest::Proxy::all(format!(
+impl TryFrom<&mut Proxy> for reqwest::Proxy {
+    type Error = color_eyre::Report;
+
+    fn try_from(value: &mut Proxy) -> Result<Self, Self::Error> {
+        let proxy = Self::all(format!(
             "{}://{}:{}",
-            self.protocol, self.host, self.port
+            value.protocol, value.host, value.port
         ))
         .wrap_err("failed to create reqwest::Proxy")?;
+
         if let (Some(username), Some(password)) =
-            (self.username.as_ref(), self.password.as_ref())
+            (value.username.as_ref(), value.password.as_ref())
         {
-            proxy = proxy.basic_auth(username, password);
+            Ok(proxy.basic_auth(username, password))
+        } else {
+            Ok(proxy)
         }
+    }
+}
+
+impl Proxy {
+    pub async fn check(
+        &mut self,
+        config: Arc<Config>,
+    ) -> color_eyre::Result<()> {
         let client = reqwest::Client::builder()
             .user_agent(USER_AGENT)
-            .proxy(proxy)
+            .proxy(self.try_into()?)
             .timeout(config.timeout)
             .pool_max_idle_per_host(0)
             .tcp_keepalive(None)
@@ -134,20 +144,14 @@ impl Proxy {
     pub fn as_str(&self, include_protocol: bool) -> String {
         let mut s = String::new();
         if include_protocol {
-            s.push_str(&self.protocol.to_string());
-            s.push_str("://");
+            write!(&mut s, "{}://", self.protocol).unwrap();
         }
         if let (Some(username), Some(password)) =
             (self.username.as_ref(), self.password.as_ref())
         {
-            s.push_str(username);
-            s.push(':');
-            s.push_str(password);
-            s.push('@');
+            write!(&mut s, "{username}:{password}@").unwrap();
         }
-        s.push_str(&self.host);
-        s.push(':');
-        s.push_str(&self.port.to_string());
+        write!(&mut s, "{}:{}", self.host, self.port).unwrap();
         s
     }
 }

src/proxy.rs

@@ -19,13 +19,15 @@ impl ProxyStorage {
     }
 
     pub fn get_grouped(&self) -> HashMap<ProxyType, Vec<&Proxy>> {
-        let mut groups: HashMap<ProxyType, Vec<&Proxy>> = self
+        let mut groups: HashMap<_, _> = self
             .enabled_protocols
             .iter()
             .map(|p| (p.clone(), Vec::new()))
             .collect();
         for proxy in &self.proxies {
-            groups.entry(proxy.protocol.clone()).or_default().push(proxy);
+            if let Some(proxies) = groups.get_mut(&proxy.protocol) {
+                proxies.push(proxy);
+            }
         }
         groups
     }

src/storage.rs

@@ -214,7 +214,7 @@ fn draw(f: &mut Frame, state: &AppState, logger_state: &TuiWidgetState) {
     let mut proxy_types: Vec<_> = state.sources_total.keys().collect();
     proxy_types.sort();
 
-    for (i, proxy_type) in proxy_types.iter().enumerate() {
+    for (i, proxy_type) in proxy_types.into_iter().enumerate() {
         let block =
             Block::bordered().title(proxy_type.to_string().to_uppercase());
         f.render_widget(block.clone(), proxies_layout[i]);
@@ -286,11 +286,11 @@ fn draw(f: &mut Frame, state: &AppState, logger_state: &TuiWidgetState) {
         );
     }
 
-    let mut lines = vec![
-        Line::from("Up/PageUp/k - scroll logs up"),
-        Line::from("Down/PageDown/j - scroll logs down"),
-    ];
-    if matches!(state.mode, AppMode::Done) {
+    let done = matches!(state.mode, AppMode::Done);
+    let mut lines = Vec::with_capacity(2 + usize::from(done));
+    lines.push(Line::from("Up/PageUp/k - scroll logs up"));
+    lines.push(Line::from("Down/PageDown/j - scroll logs down"));
+    if done {
         lines.push(
             Line::from("Enter/ESC/q/Ctrl-C - exit")
                 .style(Style::default().fg(Color::Red)),