auraline 0.5.4

utility that renders information into a string suitable to be embedded in the shell prompt.
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

use frunk::hlist;
use frunk::poly_fn;
use frunk::HCons;
use frunk::HNil;
use owo_colors::Styled;
use std::future::Future;
use std::sync::Arc;
use tokio::task::JoinError;

use crate::color::build_bold_style;
use crate::color::build_color_style;
use crate::providers::git::git_ahead_behind_icon;
use crate::providers::git::git_branch_icon;
use crate::providers::git::git_branch_name;
use crate::providers::git::git_commit_name;
use crate::providers::git::git_describe;
use crate::providers::git::git_stash_counter;
use crate::providers::git::git_status_icon;
use crate::providers::git::git_worktree;
use crate::providers::netns::namespace as net_namespace;
use crate::providers::ssh::show as ssh_show;
use crate::providers::netif::show as netif_show;
use crate::providers::os::show as os_show;
use crate::providers::manifest::show as manifest_show;

use crate::Options;
use owo_colors::Style;

macro_rules! item {
    ($provider:expr, $opt:expr) => {{
        let cloned_opts = Arc::clone(&$opt);
        tokio::spawn(async move { $provider(&cloned_opts).await.map(|s| Style::new().style(s)) })
    }};
    ($provider:expr, $opt:expr, $styl:expr) => {{
        let cloned_opts = Arc::clone(&$opt);
        let style = $styl;
        tokio::spawn(async move { $provider(&cloned_opts).await.map(|s| style.style(s)) })
    }};
}

type ResultStatic = Result<Option<Styled<&'static str>>, JoinError>;
type ResultString = Result<Option<Styled<String>>, JoinError>;

pub async fn print_prompt(opts: Arc<Options>) -> Result<(), JoinError> {
    let path = opts.path.clone();
    with_path(&path, async move {
        let color_style = build_color_style(opts.theme.as_deref());
        let bold_style = build_bold_style();
        let styled_prompt = hlist! [
            item![ os_show, opts, color_style ],
            item![ ssh_show,opts, bold_style ],
            item![ netif_show, opts, bold_style],
            item![ net_namespace, opts, color_style ],
            item![ manifest_show, opts, color_style ],
            item![ git_branch_icon, opts ],
            item![ git_status_icon, opts, color_style ],
            item![ git_stash_counter, opts ],
            item![ git_worktree, opts, bold_style ],
            item![ git_branch_name, opts, color_style.bold() ],
            item![ git_commit_name, opts, bold_style ],
            item![ git_describe, opts, bold_style ],
            item![ git_ahead_behind_icon, opts],
        ];

        let styled_results = styled_prompt.hjoin().await;

        styled_results.map(
            poly_fn!(
                |s: ResultStatic| -> () {
                   if let Ok(Some(s)) = s {
                       print!("{s} ")
                   }
                },
                |s: ResultString| -> () {
                    if let Ok(Some(s)) = s {
                        print!("{s} ")
                    }
                },
            )
        );

        Ok(())
    })
    .await
}

async fn with_path<F>(path: &Option<String>, action: F) -> Result<(), JoinError>
where
    F: Future<Output = Result<(), JoinError>>,
{
    match path {
        Some(p) => {
            let cur = std::env::current_dir().unwrap();
            std::env::set_current_dir(p).expect("could not change directory");
            let result = action.await;
            std::env::set_current_dir(cur).expect("could not change directory");
            result
        }
        None => action.await,
    }
}

trait HListJoin {
    type Output;
    async fn hjoin(self) -> Self::Output;
}

impl HListJoin for HNil {
    type Output = HNil;
    async fn hjoin(self) -> Self::Output {
        HNil
    }
}

impl<H, T> HListJoin for HCons<H, T>
where
    H: Future + Send,
    T: HListJoin + Send,
    T::Output: Send,
{
    type Output = HCons<H::Output, T::Output>;
    async fn hjoin(self) -> Self::Output {
        let (head_res, tail_res) = tokio::join!(self.head, self.tail.hjoin());
        HCons {
            head: head_res,
            tail: tail_res,
        }
    }
}