skim 4.9.0

Fuzzy Finder in rust!
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

use super::*;

fn completions_for(sh: &Shell) -> String {
    let mut buf = Vec::new();
    generate_completions(sh, &mut buf);
    String::from_utf8(buf).expect("completion output is valid UTF-8")
}

#[test]
fn completions_bash_contains_sk() {
    let out = completions_for(&Shell::Bash);
    assert!(out.contains("sk"), "bash completion should reference 'sk'");
    assert!(
        out.contains("--query") || out.contains("query"),
        "bash completion should include --query"
    );
}

#[test]
fn completions_zsh_contains_sk() {
    let out = completions_for(&Shell::Zsh);
    assert!(out.contains("sk"), "zsh completion should reference 'sk'");
    assert!(
        out.contains("--multi") || out.contains("multi"),
        "zsh completion should include --multi"
    );
}

#[test]
fn completions_fish_contains_sk() {
    let out = completions_for(&Shell::Fish);
    assert!(out.contains("sk"), "fish completion should reference 'sk'");
}

#[test]
fn completions_nushell_is_non_empty() {
    let out = completions_for(&Shell::Nushell);
    assert!(!out.is_empty(), "nushell completion should not be empty");
}

#[test]
fn completions_elvish_is_non_empty() {
    let out = completions_for(&Shell::Elvish);
    assert!(!out.is_empty(), "elvish completion should not be empty");
}

#[test]
fn completions_powershell_is_non_empty() {
    let out = completions_for(&Shell::PowerShell);
    assert!(!out.is_empty(), "powershell completion should not be empty");
}

fn key_bindings_for(sh: &Shell) -> String {
    let mut buf = Vec::new();
    generate_key_bindings(sh, &mut buf).expect("key-bindings generation failed");
    String::from_utf8(buf).expect("key-bindings output is valid UTF-8")
}

#[test]
fn key_bindings_bash() {
    let out = key_bindings_for(&Shell::Bash);
    assert!(
        out.starts_with("# skim key bindings for bash"),
        "unexpected bash header"
    );
    assert!(out.contains("__skim_select__()"), "missing __skim_select__ function");
}

#[test]
fn key_bindings_zsh() {
    let out = key_bindings_for(&Shell::Zsh);
    assert!(out.starts_with("# skim key bindings for zsh"), "unexpected zsh header");
    for func in [
        "__skimcmd()",
        "__skim_comprun()",
        "__skim_extract_command()",
        "__skim_generic_path_completion()",
        "_skim_complete()",
        "_skim_complete_kill()",
    ] {
        assert!(out.contains(func), "missing zsh function {func}");
    }
}

#[test]
fn key_bindings_fish() {
    let out = key_bindings_for(&Shell::Fish);
    assert!(
        out.starts_with("#!/bin/fish"),
        "fish key-bindings should start with shebang"
    );
    for func in [
        "function __skimcmd",
        "function __skim_parse_commandline",
        "function __skim_get_dir",
    ] {
        assert!(out.contains(func), "missing fish function '{func}'");
    }
}

#[test]
fn key_bindings_unsupported_shells_are_empty() {
    for sh in [Shell::Elvish, Shell::Nushell, Shell::PowerShell] {
        assert!(
            key_bindings_for(&sh).is_empty(),
            "{sh:?} should produce no key-bindings output"
        );
    }
}