tab-command 0.5.7

the cli command module for the tab terminal multiplexer
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

use tokio::sync::{broadcast, mpsc, watch};

use crate::{
    message::fuzzy::FuzzyEvent, message::fuzzy::FuzzySelection, message::fuzzy::FuzzyShutdown,
    message::terminal::TerminalSend, message::terminal::TerminalShutdown, prelude::*,
    state::fuzzy::FuzzyMatchState, state::fuzzy::FuzzyOutputEvent, state::fuzzy::FuzzyQueryState,
    state::fuzzy::FuzzySelectState, state::fuzzy::FuzzyTabsState, state::workspace::WorkspaceState,
};

lifeline_bus!(pub struct FuzzyBus);

impl Message<FuzzyBus> for Option<FuzzyTabsState> {
    type Channel = watch::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzyQueryState {
    type Channel = watch::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzyMatchState {
    type Channel = watch::Sender<Self>;
}

impl Message<FuzzyBus> for Option<FuzzySelectState> {
    type Channel = watch::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzyEvent {
    type Channel = broadcast::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzySelection {
    type Channel = mpsc::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzyOutputEvent {
    type Channel = mpsc::Sender<Self>;
}

impl Message<FuzzyBus> for FuzzyShutdown {
    type Channel = mpsc::Sender<Self>;
}

pub struct TerminalFuzzyCarrier {
    _recv: Lifeline,
    _selection: Lifeline,
    _forward_shutdown: Lifeline,
}

impl CarryFrom<TerminalBus> for FuzzyBus {
    type Lifeline = anyhow::Result<TerminalFuzzyCarrier>;

    fn carry_from(&self, from: &TerminalBus) -> Self::Lifeline {
        let _recv = {
            let mut rx = from.rx::<Option<WorkspaceState>>()?.log();
            let mut tx = self.tx::<Option<FuzzyTabsState>>()?;

            Self::task("recv", async move {
                while let Some(msg) = rx.recv().await {
                    tx.send(msg.map(WorkspaceState::into)).await.ok();
                }
            })
        };

        let _selection = {
            let mut rx = self.rx::<FuzzySelection>()?;
            let mut tx = from.tx::<TerminalSend>()?;

            Self::task("recv", async move {
                while let Some(msg) = rx.recv().await {
                    tx.send(TerminalSend::FuzzySelection(msg.0)).await.ok();
                }
            })
        };

        let _forward_shutdown = {
            let mut rx = self.rx::<FuzzyShutdown>()?;
            let mut tx = from.tx::<TerminalShutdown>()?;

            Self::task("recv", async move {
                if let Some(_shutdown) = rx.recv().await {
                    tx.send(TerminalShutdown {}).await.ok();
                }
            })
        };

        Ok(TerminalFuzzyCarrier {
            _recv,
            _selection,
            _forward_shutdown,
        })
    }
}