punfetch 0.3.6

A blazingly fast system fetch program to pair with onefetch
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::path::PathBuf;

use clap::{arg, command, Parser, ValueEnum};
use image::open;
use owo_colors::{AnsiColors, DynColors};
use sysinfo::SystemExt;
use term_size::dimensions;

use punfetch::{info::*, Distro, Printer};

#[derive(Parser)]
#[command(author, version, about)]
struct Args {
    /// Distribution to search art for (e.g. "Manjaro" or "Ubuntu")
    #[arg(long)]
    distro: Option<String>,
    /// Image to display in place of the distro art
    #[arg(short, long)]
    image: Option<PathBuf>,
    /// Show the logo
    #[arg(long, value_name = "WHEN", default_value = "always")]
    #[clap(value_enum)]
    show_logo: ShowLogo,
    /// Color mode to use
    #[arg(long, value_name = "MODE", default_value = "hex")]
    #[clap(value_enum)]
    color_mode: ColorMode,
    /// Text color to use. Accepts ansi or hex color codes
    #[arg(long, value_name = "COLOR")]
    color: Option<String>,
}

#[derive(Default, Clone, ValueEnum)]
enum ShowLogo {
    #[default]
    Always,
    Never,
    Auto,
}

impl ShowLogo {
    fn should_show(&self) -> bool {
        match self {
            Self::Always => true,
            Self::Never => false,
            Self::Auto => dimensions().map(|(w, _)| w > 95).unwrap_or(false),
        }
    }
}

#[derive(Default, Debug, Clone, ValueEnum, PartialEq, Eq)]
pub enum ColorMode {
    #[default]
    HEX,
    ANSI,
    NONE,
}

impl ColorMode {
    fn mode(&self) -> Option<bool> {
        match self {
            Self::HEX => Some(true),
            Self::ANSI => Some(false),
            Self::NONE => None,
        }
    }
}

fn main() {
    let args = Args::parse();
    let mut printer = Printer::default();

    let sys = sys();
    let host_info = HostInfo::new(&sys);
    let distro = Distro::search(host_info.distro.clone());

    let colors = args.color_mode.mode();
    printer.with_color(
        args.color
            .map(|c| DynColors::Ansi(AnsiColors::from(c.as_str())))
            .unwrap_or(distro.color(colors)),
    );

    if args.show_logo.should_show() {
        if let Some(path) = args.image {
            match open(path) {
                Ok(image) => printer.with_image(image),
                Err(e) => eprintln!("Error opening image: {e}"),
            }
        } else {
            printer.with_ascii(distro.ascii(colors));
        }
    }

    printer.with_info(UserInfo::new(&sys));
    printer.with_info(host_info);
    printer.with_info(PercentBar::from(sys.disks()));
    printer.with_info(SystemInfo::new(&sys));
    printer.with_info(ColorBar::default());

    printer.render()
}