pinix 0.3.3

Progress In Nix - Pacman inspired frontend for Nix
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::fmt::{self, Display};

use console::style;
use indicatif::ProgressStyle;
use once_cell::sync::Lazy;
use regex::Regex;

static MATCH_BUILD_TARGET: Lazy<Regex> = Lazy::new(|| {
    Regex::new(concat!(
        r"^",
        r"(?P<prefix>\/nix\/store\/[a-z0-9]+)-",
        r"(?P<name>.*?)",
        r"(?:-(?P<version>\d{4}-\d{2}-\d{2}|[ab\d.]+))?",
        r"(?:\.drv)?",
        r"$",
    ))
    .expect("invalid RegEx")
});

fn match_build_target(raw_str: &str) -> Option<(&str, &str, Option<&str>)> {
    let matched = MATCH_BUILD_TARGET.captures(raw_str)?;

    Some((
        matched
            .name("prefix")
            .expect("no name found in build target")
            .as_str(),
        matched
            .name("name")
            .expect("no name found in build target")
            .as_str(),
        matched.name("version").map(|m| m.as_str()),
    ))
}

pub fn format_short_build_target(raw_str: &str) -> String {
    let Some((_prefix, name, version)) = match_build_target(raw_str) else {
        return style(raw_str).yellow().to_string();
    };

    let mut result = style(name).blue().to_string();

    if let Some(version) = version {
        result = format!("{result}-{}", style(version));
    }

    result
}

pub fn format_build_target(raw_str: &str) -> String {
    let Some((prefix, name, version)) = match_build_target(raw_str) else {
        return style(raw_str).yellow().to_string();
    };

    let mut result = format!("{prefix}-{}", style(name).blue());

    if let Some(version) = version {
        result = format!("{result}-{version}");
    }

    result
}

#[derive(Debug)]
pub struct MultiBar<'s, const N: usize>(pub [(&'s str, u64); N]);

impl<'s, const N: usize> MultiBar<'s, N> {
    /// Total length of the bar
    pub(crate) fn length(&self) -> u64 {
        self.0.iter().map(|(_, len)| *len).sum()
    }

    /// Transforms the bar to be of target size
    pub(crate) fn scale(&self, size: u64) -> Self {
        let length = std::cmp::max(self.length(), 1);
        let mut prev_prop = 0;
        let mut curr_prop = 0;

        let inner = self.0.map(|(c, len)| {
            curr_prop += len;
            let nb_chars = size * curr_prop / length - size * prev_prop / length;
            prev_prop = curr_prop;
            (c, nb_chars)
        });

        Self(inner)
    }
}

impl<const N: usize> fmt::Display for MultiBar<'_, N> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for &(c, len) in &self.0 {
            for _ in 0..len {
                f.write_str(c)?;
            }
        }

        Ok(())
    }
}

pub fn template_style<R1, R2>(
    size: u16,
    show_duration: bool,
    main: impl FnOnce(u16) -> R1,
    bar: impl FnOnce(u16) -> R2,
) -> ProgressStyle
where
    R1: Display,
    R2: Display,
{
    let bar_size = size / 3;

    let (main_size, elapsed) = {
        if size > 90 {
            let duration_template = {
                if show_duration {
                    style(" {elapsed:<5}").dim()
                } else {
                    style("      ")
                }
            };

            ((size - bar_size - 6), duration_template)
        } else {
            ((size - bar_size), style(""))
        }
    };

    ProgressStyle::with_template(&format!("{}{}{elapsed}", main(main_size), bar(bar_size)))
        .expect("invalid template")
        .progress_chars("## ")
}