store printed fields in a struct

Shut up, clippy.

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.3.3"
 edition = "2021"
 
 [dependencies]
-nix = {version = "0.29", features = ["fs", "hostname"]}
+nix = { version = "0.29", features = ["fs", "hostname", "feature"] }
 color-eyre = { version = "0.6", default-features = false }
 
 [profile.dev]

src/main.rs

@@ -16,43 +16,40 @@ use nix::sys::sysinfo::sysinfo;
 fn main() -> Result<(), Report> {
     color_eyre::install()?;
 
-    let user_info = get_username_and_hostname()?;
+    let fields = Fields {
-    let os_name = get_os_pretty_name()?;
+        user_info: get_username_and_hostname()?,
-    let kernel_version = get_system_info()?;
+        os_name: get_os_pretty_name()?,
-    let shell = get_shell()?;
+        kernel_version: get_system_info()?,
-    let uptime = get_current()?;
+        shell: get_shell()?,
-    let window_manager = get_desktop_info()?;
+        uptime: get_current()?,
-    let sys_info = sysinfo()?;
+        window_manager: get_desktop_info()?,
-    let memory_usage = get_memory_usage(sys_info);
+        memory_usage: get_memory_usage(sysinfo()?),
-    let storage = get_root_disk_usage()?;
+        storage: get_root_disk_usage()?,
-    let colors = print_dots()?;
+        colors: print_dots()?,
+    };
 
-    print_system_info(
+    print_system_info(&fields);
-        &user_info,
-        &os_name,
-        &kernel_version,
-        &shell,
-        &uptime,
-        &window_manager,
-        &memory_usage,
-        &storage,
-        &colors,
-    );
 
     Ok(())
 }
 
-fn print_system_info(
+// Struct to hold all the fields we need to print
-    user_info: &str,
+// helps avoid clippy warnings about argument count
-    os_name: &str,
+// and makes it easier to pass around, though its
-    kernel_version: &str,
+// not like we need to
-    shell: &str,
+struct Fields {
-    uptime: &str,
+    user_info: String,
-    window_manager: &str,
+    os_name: String,
-    memory_usage: &str,
+    kernel_version: String,
-    storage: &str,
+    shell: String,
-    colors: &str,
+    uptime: String,
-) {
+    window_manager: String,
+    memory_usage: String,
+    storage: String,
+    colors: String,
+}
+
+fn print_system_info(fields: &Fields) {
     println!(
         "
  {CYAN}     ▟█▖    {BLUE}▝█▙ ▗█▛          {user_info} ~{RESET}
@@ -64,6 +61,15 @@ fn print_system_info(
  {BLUE}  ▝█▛  {CYAN}██▖{BLUE}▗▄▄▄▄▄▄▄▄▄▄▄       {CYAN}󰍛  {BLUE}Memory{RESET}        {memory_usage}
  {BLUE}   ▝  {CYAN}▟█▜█▖{BLUE}▀▀▀▀▀██▛▀▀▘       {CYAN}󱥎  {BLUE}Storage (/){RESET}   {storage}
  {CYAN}     ▟█▘ ▜█▖    {BLUE}▝█▛          {CYAN}  {BLUE}Colors{RESET}        {colors}
-    "
+",
+        user_info = fields.user_info,
+        os_name = fields.os_name,
+        kernel_version = fields.kernel_version,
+        shell = fields.shell,
+        uptime = fields.uptime,
+        window_manager = fields.window_manager,
+        memory_usage = fields.memory_usage,
+        storage = fields.storage,
+        colors = fields.colors,
     );
 }

src/release.rs

@@ -1,30 +1,15 @@
 use color_eyre::Result;
-use std::fs::{self, read_to_string};
+use std::fs::read_to_string;
 use std::io;
 
-// Try to detect OS type as accurately as possible and without depending on uname.
+pub fn get_system_info() -> nix::Result<String> {
-// /etc/os-release should generally imply Linux, and /etc/bsd-release would imply BSD system.
+    let utsname = nix::sys::utsname::uname()?;
-fn detect_os() -> Result<&'static str, io::Error> {
+    Ok(format!(
-    if fs::metadata("/etc/os-release").is_ok() || fs::metadata("/usr/lib/os-release").is_ok() {
+        "{} {} ({})",
-        Ok("Linux")
+        utsname.sysname().to_str().unwrap_or("Unknown"),
-    } else if fs::metadata("/etc/rc.conf").is_ok() || fs::metadata("/etc/bsd-release").is_ok() {
+        utsname.release().to_str().unwrap_or("Unknown"),
-        Ok("BSD")
+        utsname.machine().to_str().unwrap_or("Unknown")
-    } else {
+    ))
-        Ok("Unknown")
-    }
-}
-
-pub fn get_system_info() -> Result<String, io::Error> {
-    let system = detect_os()?;
-
-    let kernel_release = read_to_string("/proc/sys/kernel/osrelease")?;
-    let kernel_release = kernel_release.trim();
-
-    let architecture = read_to_string("/proc/sys/kernel/arch")?;
-    let architecture = architecture.trim();
-
-    let result = format!("{system} {kernel_release} ({architecture})");
-    Ok(result)
 }
 
 pub fn get_os_pretty_name() -> Result<String, io::Error> {