rmux-core 0.9.1

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

use super::mutation::split_array_assignment;
use super::registry::{DefaultValue, OptionQuery, OptionValueType};
use super::storage::{OptionEntry, OptionEntryValue};
use crate::command_parser::escape_argument;

pub(super) fn render_show_line(name: &str, value: &str, value_only: bool) -> String {
    if value_only {
        value.to_owned()
    } else if value.is_empty() {
        name.to_owned()
    } else {
        format!("{name} {}", render_show_value(value))
    }
}

pub(super) fn render_known_show_line(
    query: &OptionQuery,
    name: &str,
    value: &str,
    value_only: bool,
) -> String {
    if !value_only
        && value.is_empty()
        && matches!(
            query.value_type(),
            OptionValueType::String | OptionValueType::Command
        )
    {
        return format!("{name} ''");
    }
    render_show_line(name, value, value_only)
}

fn render_show_value(value: &str) -> String {
    escape_argument(value)
}

pub(super) fn show_option_name(name: &str, index: Option<u32>) -> String {
    match index {
        Some(index) => format!("{name}[{index}]"),
        None => name.to_owned(),
    }
}

pub(super) fn render_entry_show_lines(entry: &OptionEntry, value_only: bool) -> Vec<String> {
    match &entry.value {
        OptionEntryValue::Scalar(_) => {
            vec![render_show_line(&entry.name, entry.rendered(), value_only)]
        }
        OptionEntryValue::Array(_) => entry
            .array_entries()
            .into_iter()
            .map(|(index, value)| {
                render_show_line(
                    &show_option_name(&entry.name, Some(index)),
                    &value,
                    value_only,
                )
            })
            .collect(),
    }
}

pub(super) fn default_array_show_values(query: &OptionQuery) -> Vec<(u32, String)> {
    match query.default_value() {
        Some(DefaultValue::Scalar(value)) => split_array_assignment(value, query.separator())
            .into_iter()
            .enumerate()
            .map(|(index, value)| (index as u32, value))
            .collect(),
        Some(DefaultValue::Array(values)) => values
            .iter()
            .enumerate()
            .map(|(index, value)| (index as u32, (*value).to_owned()))
            .collect(),
        None => Vec::new(),
    }
}

pub(super) fn format_rendered_option_value(query: &OptionQuery, value: String) -> String {
    match query.value_type() {
        OptionValueType::Flag => {
            if value == "on" {
                "1".to_owned()
            } else {
                "0".to_owned()
            }
        }
        _ => value,
    }
}