hug 0.0.4

tui dashboard for uiio
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

use crate::args::RunArgs;
use crate::events::EventsDrainer;
use crate::launcher::{CommandEvent, CommandWatcher};
use crate::state::AppState;
use anyhow::Result;
use async_trait::async_trait;
use crb::agent::{Agent, Context, DoAsync, Next, OnEvent};
use crb::core::Slot;
use crb::superagent::{Interval, StreamSession, Supervisor, SupervisorSession, Tick};
use crossterm::event::{Event, KeyCode};
use ratatui::DefaultTerminal;

pub struct HubApp {
    args: RunArgs,
    terminal: Slot<DefaultTerminal>,
    state: AppState,
    interval: Interval,
}

impl HubApp {
    pub fn new(args: RunArgs) -> Self {
        Self {
            args,
            terminal: Slot::empty(),
            state: AppState::new(),
            interval: Interval::new(),
        }
    }
}

impl Supervisor for HubApp {
    type BasedOn = StreamSession<Self>;
    type GroupBy = ();
}

impl Agent for HubApp {
    type Context = SupervisorSession<Self>;

    fn begin(&mut self) -> Next<Self> {
        Next::do_async(Configure)
    }
}

struct Configure;

#[async_trait]
impl DoAsync<Configure> for HubApp {
    async fn handle(&mut self, _: Configure, ctx: &mut Context<Self>) -> Result<Next<Self>> {
        self.interval.set_interval_ms(100)?;
        ctx.consume(self.interval.events()?);

        let terminal = ratatui::try_init()?;
        self.terminal.fill(terminal)?;
        let drainer = EventsDrainer::new(&ctx);
        ctx.spawn_agent(drainer, ());

        let (watcher, _tx) = CommandWatcher::new(self.args.clone(), &ctx);
        ctx.spawn_agent(watcher, ());

        Ok(Next::events())
    }
}

#[async_trait]
impl OnEvent<Event> for HubApp {
    async fn handle(&mut self, event: Event, ctx: &mut Context<Self>) -> Result<()> {
        match event {
            Event::Key(event) => match event.code {
                KeyCode::Char('q') => {
                    ctx.do_next(Next::do_async(Terminate));
                }
                _ => {}
            },
            _ => {}
        };
        Ok(())
    }
}

#[async_trait]
impl OnEvent<CommandEvent> for HubApp {
    async fn handle(&mut self, event: CommandEvent, _ctx: &mut Context<Self>) -> Result<()> {
        match event {
            CommandEvent::Stdout { key, value } => {
                self.state.set(key, value);
                // ctx.do_next(Next::do_sync(Render));
            }
            CommandEvent::Terminated(_) => {
                // ctx.do_next(Next::do_sync(Render));
            }
        }
        Ok(())
    }
}

#[derive(Clone)]
struct Render;

#[async_trait]
impl OnEvent<Render> for HubApp {
    async fn handle(&mut self, _: Render, _ctx: &mut Context<Self>) -> Result<()> {
        let terminal = self.terminal.get_mut()?;
        terminal.draw(|frame| {
            self.state.render(frame);
        })?;
        Ok(())
    }
}

struct Terminate;

#[async_trait]
impl DoAsync<Terminate> for HubApp {
    async fn once(&mut self, _: &mut Terminate) -> Result<Next<Self>> {
        ratatui::try_restore()?;
        Ok(Next::done())
    }
}

#[async_trait]
impl OnEvent<Tick> for HubApp {
    async fn handle(&mut self, _: Tick, _ctx: &mut Context<Self>) -> Result<()> {
        Ok(())
    }
}