diff --git a/Cargo.lock b/Cargo.lock index 1f39265..6251ee2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -105,7 +105,7 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "microfetch" -version = "0.3.5" +version = "0.3.3" dependencies = [ "color-eyre", "nix", diff --git a/Cargo.toml b/Cargo.toml index 347b0bc..b551c5d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "microfetch" -version = "0.3.5" +version = "0.3.3" edition = "2021" [dependencies] diff --git a/README.md b/README.md index f27384d..decae73 100644 --- a/README.md +++ b/README.md @@ -35,35 +35,24 @@ than welcome to use it on your system: it's pretty [fast...](#benchmarks) - Version - Architecture - Current shell (from $SHELL, trimmed if store path) - - Current Desktop (DE/WM/Compositor and display backend) + - WM/Compositor and display backend - Memory Usage/Total Memory - Storage Usage/Total Storage (for `/` only) - Shell Colors - Did I mention fast? -## Installation - -Microfetch is packaged in [nixpkgs](https://github.com/nixos/nixpkgs). You can -get it through the unstable channel for the time being. The Nix flake can also -be used for bleeding-edge builds. - -Non-Nix users will have to build Microfetch with `cargo`. - -Microfetch is _currently_ not available anywhere else. Though, does it _really_ -have to be? - ## Benchmarks Microfetch's performance is mostly hardware-dependant, however, the overall trend seems to be < 2ms on any modern (2015 and after) CPU. Below are the benchmarks with Hyperfine on my desktop system. -| Command | Mean [ms] | Min [ms] | Max [ms] | Relative | Written by raf? | -| :----------- | ----------: | -------: | -------: | -------------: | --------------: | -| `microfetch` | 1.3 ± 0.0 | 1.3 | 1.4 | 1.00 | yes | -| `pfetch` | 254.2 ± 4.8 | 246.7 | 264.9 | 191.97 ± 7.10 | no | -| `neofetch` | 735.4 ± 9.5 | 721.1 | 752.8 | 555.48 ± 19.08 | no | -| `fastfetch` | 31.9 ± 0.8 | 30.8 | 33.8 | 24.08 ± 0.98 | no | +| Command | Mean [ms] | Min [ms] | Max [ms] | Relative | +| :----------- | ----------: | -------: | -------: | -------------: | +| `microfetch` | 1.3 ± 0.0 | 1.3 | 1.4 | 1.00 | +| `pfetch` | 254.2 ± 4.8 | 246.7 | 264.9 | 191.97 ± 7.10 | +| `neofetch` | 735.4 ± 9.5 | 721.1 | 752.8 | 555.48 ± 19.08 | +| `fastfetch` | 31.9 ± 0.8 | 30.8 | 33.8 | 24.08 ± 0.98 | _As far as I'm concerned, Microfetch is faster than almost every fetch tool there is. The only downside of using Rust is introducing more "bloated" diff --git a/src/colors.rs b/src/colors.rs index a8aee60..1aa8096 100644 --- a/src/colors.rs +++ b/src/colors.rs @@ -6,6 +6,8 @@ pub const YELLOW: &str = "\x1b[33m"; pub const RED: &str = "\x1b[31m"; pub const MAGENTA: &str = "\x1b[35m"; -pub fn print_dots() -> String { - format!("{BLUE} {CYAN} {GREEN} {YELLOW} {RED} {MAGENTA} {RESET}") +pub fn print_dots() -> Result { + let colors = format!("{BLUE} {CYAN} {GREEN} {YELLOW} {RED} {MAGENTA} {RESET}"); + + Ok(colors) } diff --git a/src/desktop.rs b/src/desktop.rs index bf0da35..9d72325 100644 --- a/src/desktop.rs +++ b/src/desktop.rs @@ -1,35 +1,20 @@ -pub fn get_desktop_info() -> String { - fn capitalize_first_letter(s: &str) -> String { - if s.is_empty() { - return String::new(); - } +use color_eyre::Result; +use std::{env, io}; - let mut chars = s.chars(); - let first_char = chars.next().unwrap().to_uppercase().to_string(); - let rest: String = chars.collect(); - first_char + &rest - } - - // Retrieve the environment variables and handle Result types - let desktop_env = std::env::var("XDG_CURRENT_DESKTOP"); - let display_backend_result = std::env::var("XDG_SESSION_TYPE"); - - // Capitalize the first letter of the display backend value - let display_backend = capitalize_first_letter(display_backend_result.as_deref().unwrap_or("")); +pub fn get_desktop_info() -> Result { + let desktop_env = env::var("XDG_CURRENT_DESKTOP"); + let display_backend = env::var("XDG_SESSION_TYPE"); // Trim "none+" from the start of desktop_env if present - // Use "Unknown" if desktop_env is empty or has an error + // XXX: This is a workaround for NixOS modules that set XDG_CURRENT_DESKTOP to "none+foo" + // instead of just "foo" + // Use "Unknown" if desktop_env or display_backend is empty let desktop_env = match desktop_env { - Err(_) => "Unknown".to_string(), - Ok(s) => s.trim_start_matches("none+").to_string(), + Err(_) => String::from("Unknown"), + Ok(s) => s.trim_start_matches("none+").to_owned(), }; - // Handle the case where display_backend might be empty after capitalization - let display_backend = if display_backend.is_empty() { - "Unknown".to_string() - } else { - display_backend - }; + let display_backend = display_backend.unwrap_or_else(|_| String::from("Unknown")); - format!("{desktop_env} ({display_backend})") + Ok(format!("{desktop_env} ({display_backend})")) } diff --git a/src/main.rs b/src/main.rs index 950a766..f725d29 100644 --- a/src/main.rs +++ b/src/main.rs @@ -17,15 +17,15 @@ fn main() -> Result<(), Report> { color_eyre::install()?; let fields = Fields { - user_info: get_username_and_hostname(), + user_info: get_username_and_hostname()?, os_name: get_os_pretty_name()?, kernel_version: get_system_info()?, - shell: get_shell(), + shell: get_shell()?, uptime: get_current()?, - desktop: get_desktop_info(), + window_manager: get_desktop_info()?, memory_usage: get_memory_usage(sysinfo()?), storage: get_root_disk_usage()?, - colors: print_dots(), + colors: print_dots()?, }; print_system_info(&fields); @@ -43,25 +43,13 @@ struct Fields { kernel_version: String, shell: String, uptime: String, - desktop: String, + window_manager: String, memory_usage: String, storage: String, colors: String, } fn print_system_info(fields: &Fields) { - let Fields { - user_info, - os_name, - kernel_version, - shell, - uptime, - desktop, - memory_usage, - storage, - colors, - } = fields; - println!( " {CYAN} ▟█▖ {BLUE}▝█▙ ▗█▛ {user_info} ~{RESET} @@ -69,8 +57,19 @@ fn print_system_info(fields: &Fields) { {CYAN} ▀▀▀▀▀▀▀▀▀▀▀▘{BLUE}▝██ {CYAN}▟█▖ {CYAN} {BLUE}Kernel{RESET}  {kernel_version} {BLUE} ▟█▛ {BLUE}▝█▘{CYAN}▟█▛ {CYAN} {BLUE}Shell{RESET}  {shell} {BLUE}▟█████▛ {CYAN}▟█████▛ {CYAN} {BLUE}Uptime{RESET}  {uptime} - {BLUE} ▟█▛{CYAN}▗█▖ {CYAN}▟█▛ {CYAN} {BLUE}Desktop{RESET}  {desktop} + {BLUE} ▟█▛{CYAN}▗█▖ {CYAN}▟█▛ {CYAN} {BLUE}WM{RESET}  {window_manager} {BLUE} ▝█▛ {CYAN}██▖{BLUE}▗▄▄▄▄▄▄▄▄▄▄▄ {CYAN}󰍛 {BLUE}Memory{RESET}  {memory_usage} {BLUE} ▝ {CYAN}▟█▜█▖{BLUE}▀▀▀▀▀██▛▀▀▘ {CYAN}󱥎 {BLUE}Storage (/){RESET}  {storage} - {CYAN} ▟█▘ ▜█▖ {BLUE}▝█▛ {CYAN} {BLUE}Colors{RESET}  {colors}"); + {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, + ); } diff --git a/src/release.rs b/src/release.rs index 4c6a9b8..8a33844 100644 --- a/src/release.rs +++ b/src/release.rs @@ -23,5 +23,5 @@ pub fn get_os_pretty_name() -> Result { .to_string() }); - Ok(pretty_name.unwrap_or("Unknown".to_string())) + Ok(pretty_name.unwrap_or_else(|| "Unknown".to_string())) } diff --git a/src/system.rs b/src/system.rs index ab10cd5..551a833 100644 --- a/src/system.rs +++ b/src/system.rs @@ -7,19 +7,19 @@ use std::io::{self}; use crate::colors::{CYAN, GREEN, RED, RESET, YELLOW}; -pub fn get_username_and_hostname() -> String { - let username = env::var("USER").unwrap_or("unknown_user".to_string()); - let hostname = nix::unistd::gethostname().unwrap_or("unknown_host".to_string().into()); +pub fn get_username_and_hostname() -> Result { + let username = env::var("USER").unwrap_or_else(|_| "unknown_user".to_string()); + let hostname = nix::unistd::gethostname()?; let hostname = hostname.to_string_lossy(); - format!("{YELLOW}{username}{RED}@{GREEN}{hostname}") + Ok(format!("{YELLOW}{username}{RED}@{GREEN}{hostname}")) } -pub fn get_shell() -> String { - let shell_path = env::var("SHELL").unwrap_or("unknown_shell".to_string()); +pub fn get_shell() -> Result { + let shell_path = env::var("SHELL").unwrap_or_else(|_| "unknown_shell".to_string()); let shell_name = shell_path.rsplit('/').next().unwrap_or("unknown_shell"); - shell_name.to_string() + Ok(shell_name.to_string()) } pub fn get_root_disk_usage() -> Result {