statusline 0.23.1

Simple and fast bash PS1 line with useful features
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

use crate::{Block, Color, Environment, Icon, IconMode, Pretty, Style, WithStyle as _};
use std::{ffi::OsStr, path::Path};

pub struct NixShell {
    // IN_NIX_SHELL=impure
    // IN_NIX_SHELL=pure
    purity: bool,
    // buildInputs=/nix/store/HASH-derivation /nix/store/HASH-derivation ...
    build_inputs: Vec<String>,
    native_build_inputs: Vec<String>,
}

super::register_block!(NixShell);

impl Block for NixShell {
    fn new(_: &Environment) -> Option<Self> {
        let purity = match std::env::var("IN_NIX_SHELL").ok()?.as_ref() {
            "impure" => false,
            "pure" => true,

            // Should not happen naturally
            _ => return None,
        };

        let inputs_from_env = |name| {
            std::env::var(name)
                .unwrap_or_default()
                .split_whitespace()
                .map(Path::new)
                .filter_map(Path::file_name)
                .filter_map(OsStr::to_str)
                .filter_map(|s| s.split_once('-'))
                // This format is weird. But at least it shows a bit of hash!
                .map(|(h, p)| format!("{}:{p}", &h[..6]))
                .collect()
        };

        // XXX: Do we also need propagatedXxxInputs?
        Some(NixShell {
            purity,
            build_inputs: inputs_from_env("buildInputs"),
            native_build_inputs: inputs_from_env("nativeBuildInputs"),
        })
    }
}

impl Pretty for NixShell {
    fn pretty(&self, f: &mut std::fmt::Formatter<'_>, mode: IconMode) -> std::fmt::Result {
        f.with_style(Color::BRIGHT_BLUE, Style::empty(), |f| {
            let purity = if self.purity { "" } else { "!" };
            write!(f, "[{purity}{}", self.icon(mode))?;

            let mut format_inputs = |name, inputs: &[String]| match &inputs {
                [] => Ok(()),
                [input] => write!(f, " {input}"),
                _ => write!(f, " {name}/{}", inputs.len()),
            };
            format_inputs("bi", &self.build_inputs)?;
            format_inputs("nbi", &self.native_build_inputs)?;

            write!(f, "]")?;
            Ok(())
        })
    }
}

impl Icon for NixShell {
    fn icon(&self, mode: IconMode) -> &'static str {
        use IconMode::*;
        match &mode {
            Text => "nix",
            Icons | MinimalIcons => "󱄅",
        }
    }
}