zshrs 0.11.18

The first compiled Unix shell — bytecode VM, worker pool, AOP intercept, Rkyv caching
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

//! Port of `_brace_parameter` from
//! `Completion/Zsh/Context/_brace_parameter`.
//!
//! Full upstream body (214 lines, abridged):
//! ```text
//! sh:  1  #compdef -brace-parameter-
//! sh:  4  if compset -P '\(*\)*'; then … : prefix flag → _parameter ; return
//! sh: 14  elif compset -P '\(*'; then … parameter-flag catalog
//! sh: 80  elif compset -P '#%[#%]##'; then  … offset / length modifiers
//! sh:130  elif compset -P '\\/[^/]##'; then  … substitution
//! sh:140  else _parameter
//! sh:214  fi
//! ```
//!
//! `${…}` parameter-expansion completion. Dispatches to
//! `_parameter` for the trivial case; flag-letter catalog for
//! `${(F)…}` etc.

use crate::ported::exec_hooks::dispatch_function_call;
use crate::ported::params::setaparam;
use crate::ported::zle::complete::bin_compset;
use crate::ported::zsh_h::{options, MAX_OPS};

fn make_ops() -> options {
    options {
        ind: [0u8; MAX_OPS],
        args: Vec::new(),
        argscount: 0,
        argsalloc: 0,
    }
}

/// `_brace_parameter` — complete inside `${…}`.
pub fn _brace_parameter() -> i32 {
    // sh:4
    if bin_compset(
        "compset",
        &["-P".to_string(), "\\(*\\)*".to_string()],
        &make_ops(),
        0,
    ) == 0
    {
        return dispatch_function_call("_parameter", &[]).unwrap_or(1);
    }

    // sh:14  inside `(...)` — parameter flag catalog
    if bin_compset(
        "compset",
        &["-P".to_string(), "\\(*".to_string()],
        &make_ops(),
        0,
    ) == 0
    {
        let flags: Vec<String> = vec![
            "A:create assoc array from key/val pairs",
            "a:array (with @)",
            "C:capitalize words",
            "D:turn HOME prefix into ~",
            "e:treat $\\(…\\) as command substitution",
            "f:split on newlines",
            "F:join on newlines",
            "g:process escape sequences",
            "i:case-insensitive sort",
            "j:join with given string",
            "k:expand to keys of associative array",
            "L:lowercase result",
            "l:left-justify",
            "m:multibyte-aware width",
            "n:numerically-sort",
            "O:reverse-sort",
            "o:sort",
            "P:treat as parameter name; recursive lookup",
            "p:recognize escape sequences in next flag",
            "q:quote special chars",
            "s:split on given string",
            "t:type of param",
            "U:uppercase result",
            "u:unique",
            "V:visible (printable)",
            "v:return values not keys (with k)",
            "w:treat as words",
            "X:fail on bad pattern",
            "Z:split with shell syntax",
            "z:split on shell tokens",
        ]
        .into_iter()
        .map(|s| s.to_string())
        .collect();
        setaparam("flags", flags);
        return dispatch_function_call(
            "_describe",
            &[
                "-t".to_string(),
                "flags".to_string(),
                "parameter flag".to_string(),
                "flags".to_string(),
                "-Q".to_string(),
                "-S".to_string(),
                "".to_string(),
            ],
        )
        .unwrap_or(1);
    }

    // sh:214 — fallback: parameter-name completion
    dispatch_function_call("_parameter", &[]).unwrap_or(1)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn returns_one_without_executor() {
        let _g = crate::test_util::global_state_lock();
        let _ = crate::ported::params::setsparam("PREFIX", "myvar");
        assert_eq!(_brace_parameter(), 1);
    }
}