rmux-server 0.1.2

Tokio daemon and request dispatcher for the RMUX 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
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

use super::*;

#[tokio::test]
async fn attached_mode_tree_acceptance_uses_mode_before_prefix_or_pty() {
    let handler = RequestHandler::new();
    let requester_pid = std::process::id();
    let alpha = session_name("alpha");
    let _control_rx = create_attached_session(&handler, requester_pid, &alpha).await;
    assert!(matches!(
        handler
            .handle(Request::NewWindow(NewWindowRequest {
                target: alpha.clone(),
                name: Some("w1".to_owned()),
                detached: true,
                start_directory: None,
                environment: None,
                command: None,
                target_window_index: None,
                insert_at_target: false,
            }))
            .await,
        Response::NewWindow(_)
    ));

    let commands = handler
        .parse_control_commands("choose-tree -Zw")
        .await
        .expect("choose-tree parses");
    handler
        .execute_parsed_commands_for_test(requester_pid, commands)
        .await
        .expect("choose-tree activates mode-tree");

    assert_eq!(
        pane_mode_status(&handler, &alpha).await,
        "1:tree-mode::\n0:::\n"
    );
    assert_eq!(
        display_target_format(
            &handler,
            PaneTarget::new(alpha.clone(), 0),
            "#{window_name}|#{pane_in_mode}|#{pane_mode}"
        )
        .await,
        "[rmux]|1|tree-mode\n"
    );
    {
        let state = handler.state.lock().await;
        let window_name = state
            .sessions
            .session(&alpha)
            .and_then(|session| session.window_at(0))
            .and_then(|window| window.name().map(str::to_owned));
        assert_eq!(window_name.as_deref(), Some("[rmux]"));
    }
    handler
        .handle_attached_live_input_for_test(requester_pid, b"\x0e\r")
        .await
        .expect("mode-tree accepts attached keys");

    assert_eq!(active_windows(&handler, &alpha).await, "0:0\n1:1\n");
    assert_eq!(pane_mode_status(&handler, &alpha).await, "0:::\n0:::\n");
}

#[tokio::test]
async fn attached_compact_prefix_wq_uses_choose_tree_before_the_following_key() {
    let handler = RequestHandler::new();
    let requester_pid = std::process::id();
    let alpha = session_name("alpha");
    let _control_rx = create_attached_session(&handler, requester_pid, &alpha).await;
    assert!(matches!(
        handler
            .handle(Request::NewWindow(NewWindowRequest {
                target: alpha.clone(),
                name: Some("w1".to_owned()),
                detached: true,
                start_directory: None,
                environment: None,
                command: None,
                target_window_index: None,
                insert_at_target: false,
            }))
            .await,
        Response::NewWindow(_)
    ));

    handler
        .handle_attached_live_input_for_test(requester_pid, b"\x02wq")
        .await
        .expect("compact choose-tree close input");

    assert_eq!(pane_mode_status(&handler, &alpha).await, "0:::\n0:::\n");
    assert_eq!(
        display_target_format(
            &handler,
            PaneTarget::new(alpha.clone(), 0),
            "#{window_name}|#{pane_in_mode}|#{pane_mode}"
        )
        .await,
        default_shell_pane_status()
    );
}

#[tokio::test]
async fn attached_compact_prefix_tq_uses_clock_mode_before_the_following_key() {
    let handler = RequestHandler::new();
    let requester_pid = std::process::id();
    let alpha = session_name("alpha");
    let _control_rx = create_attached_session(&handler, requester_pid, &alpha).await;

    handler
        .handle_attached_live_input_for_test(requester_pid, b"\x02tq")
        .await
        .expect("compact clock-mode close input");

    assert_eq!(pane_mode_status(&handler, &alpha).await, "0:::\n");
    assert_eq!(
        display_target_format(
            &handler,
            PaneTarget::new(alpha.clone(), 0),
            "#{window_name}|#{pane_in_mode}|#{pane_mode}"
        )
        .await,
        default_shell_pane_status()
    );
}