refactor: simplify code with .ok()

src/lib.rs

@@ -246,18 +246,12 @@ pub fn os(general_readout: &GeneralReadout) -> Option<String> {
                 }
             }
         }
-        _ => match general_readout.os_name() {
+        _ => general_readout.os_name().ok(),
-            Ok(os) => Some(os),
-            Err(_) => None,
-        },
     }
 }
 
 pub fn kernel(kernel_readout: &KernelReadout) -> Option<String> {
-    match kernel_readout.os_release() {
+    kernel_readout.os_release().ok()
-        Ok(kernel_version) => Some(kernel_version),
-        Err(_) => None,
-    }
 }
 
 fn seconds_to_string(time: usize) -> String {
@@ -283,10 +277,7 @@ fn seconds_to_string(time: usize) -> String {
 }
 
 pub fn uptime(general_readout: &GeneralReadout) -> Option<String> {
-    match general_readout.uptime() {
+    Some(seconds_to_string(general_readout.uptime().ok()?))
-        Ok(uptime) => Some(seconds_to_string(uptime)),
-        Err(_) => None,
-    }
 }
 
 pub fn host(general_readout: &GeneralReadout) -> Option<String> {
@@ -348,13 +339,11 @@ pub fn host(general_readout: &GeneralReadout) -> Option<String> {
                 Some(final_str)
             }
         }
-        _ => match general_readout.machine() {
+        // on non-linux systems, try general_readout.machine(), use cpu model name as fallback
-            Ok(host) => Some(host),
+        _ => general_readout
-            Err(_) => match general_readout.cpu_model_name() {
+            .machine()
-                Ok(host) => Some(host),
+            .ok()
-                Err(_) => None,
+            .or_else(|| general_readout.cpu_model_name().ok()),
-            },
-        },
     }
 }
 
@@ -374,43 +363,31 @@ pub fn logo(logo_name: &str) -> Logo {
 }
 
 pub fn shell(general_readout: &GeneralReadout) -> Option<String> {
-    match general_readout.shell(
+    general_readout
-        libmacchina::traits::ShellFormat::Relative,
+        .shell(
-        libmacchina::traits::ShellKind::Default,
+            libmacchina::traits::ShellFormat::Relative,
-    ) {
+            libmacchina::traits::ShellKind::Default,
-        Ok(shell) => Some(shell),
+        )
-        Err(_) => match dotenvy::var("SHELL") {
+        .ok()
-            Ok(shell) => Some(shell),
+        .or_else(|| dotenvy::var("SHELL").ok())
-            Err(_) => None,
-        },
-    }
 }
 
 pub fn editor() -> Option<String> {
-    match env::var("VISUAL") {
+    env::var("VISUAL")
-        Ok(editor) => Some(editor.trim().to_owned()),
+        .or_else(|_| env::var("EDITOR"))
-        Err(_) => match env::var("EDITOR") {
+        .ok()
-            Ok(editor) => Some(editor.trim().to_owned()),
+        .map(|editor| editor.trim().to_owned())
-            Err(_) => None,
-        },
-    }
 }
 
 pub fn wm(general_readout: &GeneralReadout) -> Option<String> {
-    match general_readout.window_manager() {
+    general_readout.window_manager().ok()
-        Ok(wm) => Some(wm),
-        Err(_) => None,
-    }
 }
 
 pub fn de(general_readout: &GeneralReadout) -> Option<String> {
-    match general_readout.desktop_environment() {
+    general_readout
-        Ok(de) => Some(de),
+        .desktop_environment()
-        Err(_) => match dotenvy::var("XDG_CURRENT_DESKTOP") {
+        .ok()
-            Ok(de) => Some(de),
+        .or_else(|| dotenvy::var("XDG_CURRENT_DESKTOP").ok())
-            Err(_) => None,
-        },
-    }
 }
 
 pub fn palette() -> String {

src/main.rs

@@ -150,8 +150,7 @@ fn pfetch(info: Vec<(pfetch::Color, String, String)>, logo: pfetch::Logo, logo_e
     println!("{pfetch_str}");
 
     // enable line wrap
-    crossterm::execute!(std::io::stdout(), crossterm::terminal::EnableLineWrap)
+    crossterm::execute!(std::io::stdout(), crossterm::terminal::EnableLineWrap).unwrap_or_default();
-        .unwrap_or_default();
 }
 
 struct Readouts {
@@ -168,21 +167,11 @@ fn get_info(
 ) -> Option<String> {
     match info {
         PfetchInfo::Ascii => None,
-        PfetchInfo::Title => {
+        PfetchInfo::Title => pfetch::user_at_hostname(
-            let hostname_override = match dotenvy::var("HOSTNAME") {
+            &readouts.general_readout,
-                Ok(hostname) => Some(hostname),
+            &dotenvy::var("USER").ok(),
-                Err(_) => None,
+            &dotenvy::var("HOSTNAME").ok(),
-            };
+        ),
-            let username_override = match dotenvy::var("USER") {
-                Ok(username) => Some(username),
-                Err(_) => None,
-            };
-            pfetch::user_at_hostname(
-                &readouts.general_readout,
-                &username_override,
-                &hostname_override,
-            )
-        }
         PfetchInfo::Os => pfetch::os(&readouts.general_readout),
         PfetchInfo::Host => pfetch::host(&readouts.general_readout),
         PfetchInfo::Kernel => pfetch::kernel(&readouts.kernel_readout),
@@ -291,20 +280,12 @@ fn main() {
         .iter()
         .filter_map(|info| match info {
             PfetchInfo::Os => Some((logo.primary_color, info.to_string(), os.clone())),
-            _ => {
+            _ => get_info(info, &readouts, skip_slow_package_managers).map(|info_str| match info {
-                let info_result = get_info(info, &readouts, skip_slow_package_managers);
+                PfetchInfo::Title => (logo.secondary_color, info_str, "".to_string()),
-                match info_result {
+                PfetchInfo::BlankLine => (logo.primary_color, "".to_string(), "".to_string()),
-                    Some(info_str) => match info {
+                PfetchInfo::Palette => (logo.primary_color, info_str, "".to_string()),
-                        PfetchInfo::Title => Some((logo.secondary_color, info_str, "".to_string())),
+                _ => (logo.primary_color, info.to_string(), info_str),
-                        PfetchInfo::BlankLine => {
+            }),
-                            Some((logo.primary_color, "".to_string(), "".to_string()))
-                        }
-                        PfetchInfo::Palette => Some((logo.primary_color, info_str, "".to_string())),
-                        _ => Some((logo.primary_color, info.to_string(), info_str)),
-                    },
-                    None => None,
-                }
-            }
         })
         .collect();