shli 0.4.1

Create shell-like TUIs
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
137
138
139
140
141
142
143
144
145
146
147
148
149

/// Simple state machine for processing escaping within command line strings.
///
/// An example usage:
/// ```
/// use shli::split::EscapingState;
///
/// // This will build the string `some_command "some string\"" "some other string`
/// let cmdline = "some_command \"some string\\\"\" \"some other string";
/// let mut state = EscapingState::process(cmdline);
///
/// // This assertion means that a following whitespace would be escaped.
/// // A finished command line string should not pass this assertion.
/// // This will succeed, because we made an error at `"some other string`.
/// assert!(state.whitespace_escaped())
/// ```
#[derive(Debug, Default)]
pub struct EscapingState {
    /// A single quote is active.
    pub single_quote: bool,
    /// A double quote is active.
    pub double_quote: bool,
    /// A backslash is active.
    pub backslash: bool,
}

impl EscapingState {
    pub fn new() -> EscapingState {
        EscapingState {
            single_quote: false,
            double_quote: false,
            backslash: false,
        }
    }

    /// Call this function to proceed on the input string.
    pub fn step(&mut self, ch: char) {
        match ch {
            '"' => {
                if !self.doublequote_escaped() {
                    self.double_quote = !self.double_quote
                }
            }
            '\'' => {
                if !self.singlequote_escaped() {
                    self.single_quote = !self.single_quote
                }
            }
            _ => {}
        }

        if self.backslash {
            self.backslash = false
        } else if ch == '\\' {
            self.backslash = true
        }
    }

    /// If the next character would be whitespace, would it be escaped
    /// or viewed as a component delimiter?
    pub fn whitespace_escaped(&self) -> bool {
        self.single_quote || self.double_quote || self.backslash
    }

    /// If the next character would be `"`, would it be escaped
    /// or would it start/end a string sequence, in which whitespace and single
    /// quote are escaped? (`"A B C \""`)
    pub fn doublequote_escaped(&self) -> bool {
        self.single_quote || self.backslash
    }

    /// If the next character would be `'`, would it be escaped
    /// or would it start/end a string sequence, in which whitespace and double
    /// quotes are escaped? (`'A B C \''`)
    pub fn singlequote_escaped(&self) -> bool {
        self.double_quote || self.backslash
    }

    /// If the next character would be a backslash (`\`), would it
    /// be escaped or would it itself be viewed as escape character?
    /// (`\\`)
    pub fn backslash_escaped(&self) -> bool {
        self.double_quote || self.backslash
    }

    /// Calls `step` for every character in line and returns
    /// the resulting state
    pub fn process(line: &str) -> EscapingState {
        let mut state = EscapingState::new();
        for ch in line.chars() {
            state.step(ch);
        }
        state
    }
}

/// Splits a commandline into its components/arguments.
/// Works similar to `split_whitespace`.
///
/// The main difference to `split_whitespace` is:
/// It respects whitespace escaping (`"`, `'`, `\`) as well as escaping
/// of the escaping characters (`\"`, `'\'`, …).
/// Thus, strings (`"A B C"`) will show up as single arguments.
pub fn split(cmdline: &str) -> Vec<String> {
    let mut parts = vec![];
    let mut act = String::new();
    let mut state = EscapingState::new();
    for ch in cmdline.chars() {
        if !state.whitespace_escaped() && ch.is_whitespace() {
            if !act.is_empty() {
                parts.push(act);
                act = String::new();
            }
            continue;
        }

        match ch {
            '"' => {
                if state.doublequote_escaped() {
                    act.push(ch);
                }
            }
            '\'' => {
                if state.singlequote_escaped() {
                    act.push(ch);
                }
            }
            '\\' => {
                if state.backslash_escaped() {
                    act.push(ch);
                }
            }
            ch => act.push(ch),
        }
        state.step(ch);
    }

    if !act.is_empty() {
        parts.push(act);
    }
    parts
}

pub fn ends_with_whitespace(text: &str) -> bool {
    if let Some(ch) = text.chars().last() {
        ch.is_whitespace()
    } else {
        false
    }
}