ethr 0.1.1

Ethereal shell prompts. Pragmatic meets aesthetic.
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

#![allow(unused)]

#[derive(Clone, Copy)]
struct Color(u8, u8, u8);
impl Color {
    fn to_ansi(&self) -> String {
        format!("\x1b[38;2;{};{};{}m", self.0, self.1, self.2)
    }
    fn to_ansi_bg(&self) -> String {
        format!("\x1b[48;2;{};{};{}m", self.0, self.1, self.2)
    }

    fn mix(&self, other: &Self, f: f32) -> Color {
        if f > 1.0 || f < 0.0 {
            panic!("Bad mix factor, must be between [0,1]");
        }

        Color(
            ((self.0 as f32) * (1.0 - f) + (other.0 as f32) * f) as u8,
            ((self.1 as f32) * (1.0 - f) + (other.1 as f32) * f) as u8,
            ((self.2 as f32) * (1.0 - f) + (other.2 as f32) * f) as u8,
        )
    }

    fn hex_str(&self) -> String {
        format!("#{}{}{}", format_radix(self.0 as u32, 16), format_radix(self.1 as u32, 16), format_radix(self.2 as u32, 16))
    }
}

fn format_radix(mut x: u32, radix: u32) -> String {
    let mut result = vec![];

    loop {
        let m = x % radix;
        x = x / radix;

        result.push(std::char::from_digit(m, radix).unwrap());
        if x == 0 {
            break;
        }
    }
    result.into_iter().rev().collect()
}


fn cprint(c: &str, c1: Color, c2: Color) {
    print!("{}{}{}\x1b[0m", c1.to_ansi(), c2.to_ansi_bg(), c);
}

fn tmux_print(c: &str, c1: Color, c2: Color) {
    print!("#[fg={},bg={}]{}#[fg=default,bg=default]", c1.hex_str(), c2.hex_str(), c);
}



fn hex_to_color(hx: u32) -> Color {
    Color(
        ((hx >> 16) & 0xff) as u8,
        ((hx >> 8) & 0xff) as u8,
        (hx & 0xff) as u8,
    )
}


const GLYPH: &str = "";

pub fn print(a1: String, a2: String, a3: String, a4: String) -> Result<(), String> {
    let c1 = hex_to_color(u32::from_str_radix(a1.as_str(), 16).unwrap_or(0));
    let c2 = hex_to_color(u32::from_str_radix(a2.as_str(), 16).unwrap_or(0));
    let n = (u32::from_str_radix(a3.as_str(), 10).unwrap());
    let msg = a4;

    // cprint(&msg, Color(255, 255, 255), c1);
    cprint(&msg, Color(255, 255, 255), c1);

    let step: f32 = 1.0/(n as f32);

    for i in 1..(n+1) {
        let fnow = (i as f32)*step;
        let fprev = (i as f32 -1.0)*step;

        let cnow = c1.mix(&c2, fnow);
        let cprev = c1.mix(&c2, fprev);

        // cprint(GLYPH, cprev, cnow);
        cprint(GLYPH, cprev, cnow);
        
    }; Ok(())
}