rmux-server 0.10.0

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
127
128
129
130
131
132
133
134
135
136

use super::*;

#[tokio::test]
async fn parsed_queue_accepts_tmux_swap_window_flag_clusters() {
    for case in [
        SwapClusterCase {
            session: "swap-ds",
            command: "swap-window -ds one -tswap-ds:0",
            add_d_window: false,
            expected_names: &["one", "rmux"],
        },
        SwapClusterCase {
            session: "swap-dt",
            command: "swap-window -dt +1 -sswap-dt:0",
            add_d_window: false,
            expected_names: &["one", "rmux"],
        },
        SwapClusterCase {
            session: "swap-sd",
            command: "swap-window -sd -t swap-sd:1",
            add_d_window: true,
            expected_names: &["rmux", "d", "one"],
        },
    ] {
        assert_parsed_swap_cluster(case).await;
    }
}

#[tokio::test]
async fn parsed_queue_does_not_expand_the_swap_window_flag_surface() {
    let handler = RequestHandler::new();
    let alpha = session_name("alpha");
    assert!(matches!(
        handler
            .handle(Request::NewSession(NewSessionRequest {
                session_name: alpha.clone(),
                detached: true,
                size: Some(TerminalSize { cols: 80, rows: 24 }),
                environment: None,
            }))
            .await,
        Response::NewSession(_)
    ));
    create_named_window(&handler, &alpha, "one", 1).await;

    let parsed = CommandParser::new()
        .parse("swap-window -ad -s alpha:0 -t alpha:1")
        .expect("unknown flags still tokenize");
    let error = handler
        .execute_parsed_commands_for_test(std::process::id(), parsed)
        .await
        .expect_err("-a must remain unsupported for swap-window");

    assert_eq!(
        error.to_string(),
        "server error: command swap-window: unknown flag -a"
    );
}

struct SwapClusterCase {
    session: &'static str,
    command: &'static str,
    add_d_window: bool,
    expected_names: &'static [&'static str],
}

async fn assert_parsed_swap_cluster(case: SwapClusterCase) {
    let handler = RequestHandler::new();
    let session_name = session_name(case.session);
    assert!(matches!(
        handler
            .handle(Request::NewSession(NewSessionRequest {
                session_name: session_name.clone(),
                detached: true,
                size: Some(TerminalSize { cols: 80, rows: 24 }),
                environment: None,
            }))
            .await,
        Response::NewSession(_)
    ));

    create_named_window(&handler, &session_name, "one", 1).await;
    if case.add_d_window {
        create_named_window(&handler, &session_name, "d", 2).await;
    }

    let parsed = CommandParser::new()
        .parse(case.command)
        .unwrap_or_else(|error| panic!("{} should tokenize: {error}", case.command));
    handler
        .execute_parsed_commands(
            std::process::id(),
            parsed,
            QueueExecutionContext::without_caller_cwd().with_current_target(Some(Target::Pane(
                PaneTarget::with_window(session_name.clone(), 0, 0),
            ))),
        )
        .await
        .unwrap_or_else(|error| panic!("{} should execute: {error}", case.command));

    let state = handler.state.lock().await;
    let session = state
        .sessions
        .session(&session_name)
        .expect("session exists");
    let names = session
        .windows()
        .values()
        .map(|window| window.name().expect("named fixture window"))
        .collect::<Vec<_>>();
    assert_eq!(names, case.expected_names, "{}", case.command);
}

async fn create_named_window(
    handler: &RequestHandler,
    session_name: &SessionName,
    name: &str,
    index: u32,
) {
    assert!(matches!(
        handler
            .handle(Request::NewWindow(Box::new(NewWindowRequest {
                target: session_name.clone(),
                name: Some(name.to_owned()),
                detached: true,
                start_directory: None,
                environment: None,
                command: None,
                process_command: None,
                target_window_index: Some(index),
                insert_at_target: false,
            })))
            .await,
        Response::NewWindow(_)
    ));
}