rmux-core 0.2.0

Core session, pane, layout, format, hook, and buffer model 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

use super::{
    format_expand1, format_skip, is_truthy, resolve_variable, ExpandState, FormatVariables,
};

/// Evaluates a tmux multi-pair conditional: `cond1,val1,cond2,val2,...,default`.
pub(super) fn format_conditional<V>(state: &mut ExpandState, body: &str, variables: &V) -> String
where
    V: FormatVariables + ?Sized,
{
    let bytes = body.as_bytes();
    let mut pos = 0;

    loop {
        // Find the condition (up to next `,`).
        let rest = &bytes[pos..];
        let cond_end = match format_skip(rest, b",") {
            Some(off) => off,
            None => {
                // No more commas — this is the final unpaired arg (default).
                return format_expand1(state, &body[pos..], variables);
            }
        };

        let condition_str = &body[pos..pos + cond_end];

        // Evaluate condition: try variable lookup first, then expand.
        let found = resolve_variable(condition_str, variables);
        let condition_value = if found.is_empty() {
            // Try expanding. If expansion has no effect, assume false.
            let expanded = format_expand1(state, condition_str, variables);
            if expanded == condition_str {
                String::new()
            } else {
                expanded
            }
        } else {
            found
        };

        // Advance past condition comma.
        pos += cond_end + 1;

        // Find the value (up to next `,`).
        let rest = &bytes[pos..];
        let val_end = format_skip(rest, b",");

        if is_truthy(&condition_value) {
            // Condition is true — expand and return the value.
            return if let Some(ve) = val_end {
                let value_str = &body[pos..pos + ve];
                format_expand1(state, value_str, variables)
            } else {
                format_expand1(state, &body[pos..], variables)
            };
        }

        // Condition is false — skip the value.
        match val_end {
            Some(ve) => pos += ve + 1,
            None => {
                // No more commas — no default, return empty.
                return String::new();
            }
        }
    }
}

/// N-ary boolean operator: `&&` (and=true) or `||` (and=false).
/// Splits body on `,`, short-circuits.
pub(super) fn format_bool_op_n<V>(
    state: &mut ExpandState,
    body: &str,
    and: bool,
    variables: &V,
) -> String
where
    V: FormatVariables + ?Sized,
{
    let bytes = body.as_bytes();
    let mut result = and;
    let mut pos = 0;

    loop {
        // Should we keep going?
        if and && !result {
            break;
        }
        if !and && result {
            break;
        }

        let rest = &bytes[pos..];
        let end = format_skip(rest, b",");

        let raw = match end {
            Some(off) => &body[pos..pos + off],
            None => &body[pos..],
        };

        let expanded = format_expand1(state, raw, variables);
        if and {
            result = result && is_truthy(&expanded);
        } else {
            result = result || is_truthy(&expanded);
        }

        match end {
            Some(off) => pos += off + 1,
            None => break,
        }
    }

    if result { "1" } else { "0" }.to_owned()
}