reovim-module-vim 0.14.3

Vim policy module for reovim - keybindings and behavior
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

use super::super::*;

#[test]
fn test_operators_list() {
    let ops = operators();
    assert_eq!(ops.len(), 6);

    // Check operators are present
    let ids: Vec<_> = ops.iter().map(|o| o.id()).collect();
    assert!(ids.contains(&"delete"));
    assert!(ids.contains(&"yank"));
    assert!(ids.contains(&"change"));
}

#[test]
fn test_delete_is_text_modifying() {
    let delete = DeleteOperator;
    assert!(delete.is_text_modifying());
    assert!(!delete.is_linewise());
}

#[test]
fn test_operators_ids_unique() {
    let ops = operators();
    let ids: Vec<_> = ops.iter().map(|o| o.id()).collect();
    // Check all IDs are unique
    let mut seen = std::collections::HashSet::new();
    for id in &ids {
        assert!(seen.insert(id), "Duplicate operator id: {id}");
    }
}

#[test]
fn test_operator_commands_not_empty() {
    let cmds = operator_commands();
    assert!(!cmds.is_empty());
}

#[test]
fn test_operator_commands_count() {
    let cmds = operator_commands();
    assert_eq!(cmds.len(), 6); // delete, yank, change, lowercase, uppercase, toggle-case
}

#[test]
fn test_delete_operator_debug() {
    let delete = DeleteOperator;
    assert!(format!("{delete:?}").contains("DeleteOperator"));
}

#[test]
fn test_yank_operator_debug() {
    let yank = YankOperator;
    assert!(format!("{yank:?}").contains("YankOperator"));
}

#[test]
fn test_change_operator_debug() {
    let change = ChangeOperator;
    assert!(format!("{change:?}").contains("ChangeOperator"));
}

#[test]
fn test_operators_all_not_linewise() {
    let ops = operators();
    for op in &ops {
        assert!(!op.is_linewise(), "operator '{}' should not be linewise by default", op.id());
    }
}

#[test]
fn test_operators_text_modifying_flags() {
    let ops = operators();
    let text_modifying: Vec<_> = ops
        .iter()
        .filter(|o| o.is_text_modifying())
        .map(|o| o.id())
        .collect();
    assert!(text_modifying.contains(&"delete"));
    assert!(text_modifying.contains(&"change"));
    assert!(!text_modifying.contains(&"yank"));
}

#[test]
fn test_delete_operator_clone_copy() {
    let del = DeleteOperator;
    let copied: DeleteOperator = del;
    assert_eq!(copied.id(), "delete");
}

#[test]
fn test_yank_operator_clone_copy() {
    let yank = YankOperator;
    let copied: YankOperator = yank;
    assert_eq!(copied.id(), "yank");
}

#[test]
fn test_operator_commands_has_all_ids() {
    let cmds = operator_commands();
    let ids: Vec<_> = cmds.iter().map(|c| c.id()).collect();
    assert!(ids.iter().any(|id| id.name() == "delete"));
    assert!(ids.iter().any(|id| id.name() == "yank"));
    assert!(ids.iter().any(|id| id.name() == "change"));
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_operator_commands_all_vim_module() {
    let cmds = operator_commands();
    for cmd in &cmds {
        assert_eq!(
            cmd.id().module().as_str(),
            "vim",
            "command '{}' should be in vim module",
            cmd.id().name()
        );
    }
}