revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

//! Public API tests for Vim Mode system

use revue::widget::developer::vim::{VimAction, VimCommandResult, VimMode, VimMotion, VimState};

#[test]
fn test_vim_mode_name() {
    // Test all modes have proper names
    assert_eq!(VimMode::Normal.name(), "NORMAL");
    assert_eq!(VimMode::Insert.name(), "INSERT");
    assert_eq!(VimMode::Visual.name(), "VISUAL");
    assert_eq!(VimMode::VisualLine.name(), "V-LINE");
    assert_eq!(VimMode::VisualBlock.name(), "V-BLOCK");
    assert_eq!(VimMode::Command.name(), "COMMAND");
    assert_eq!(VimMode::Search.name(), "SEARCH");
    assert_eq!(VimMode::Replace.name(), "REPLACE");
}

#[test]
fn test_vim_mode_color() {
    // Test all modes have colors
    assert_eq!(VimMode::Normal.color().to_string(), "rgb(100, 150, 255)");
    assert_eq!(VimMode::Insert.color().to_string(), "rgb(100, 255, 100)");
    assert_eq!(VimMode::Visual.color().to_string(), "rgb(255, 150, 100)");
    assert_eq!(VimMode::VisualLine.color().to_string(), "rgb(255, 150, 100)");
    assert_eq!(VimMode::VisualBlock.color().to_string(), "rgb(255, 150, 100)");
    assert_eq!(VimMode::Command.color().to_string(), "rgb(255, 255, 100)");
    assert_eq!(VimMode::Search.color().to_string(), "rgb(255, 100, 255)");
    assert_eq!(VimMode::Replace.color().to_string(), "rgb(255, 100, 100)");
}

#[test]
fn test_vim_state_new() {
    // Test new vim state creation
    let vim = VimState::new();
    assert_eq!(vim.mode(), VimMode::Normal);
    assert_eq!(vim.count(), 1); // Default count is 1
    assert_eq!(vim.command_buffer(), "");
    assert_eq!(vim.search_pattern(), "");
    assert_eq!(vim.register(), "");
}

#[test]
fn test_vim_state_mode() {
    // Test mode management
    let mut vim = VimState::new();

    // Test initial mode
    assert_eq!(vim.mode(), VimMode::Normal);

    // Test changing mode
    vim.set_mode(VimMode::Insert);
    assert_eq!(vim.mode(), VimMode::Insert);

    // Test setting back to normal clears operator and count
    vim.set_mode(VimMode::Normal);
    assert_eq!(vim.mode(), VimMode::Normal);
}

#[test]
fn test_vim_state_count() {
    // Test count functionality
    let mut vim = VimState::new();

    // Test default count
    assert_eq!(vim.count(), 1);

    // Test handling keys with digits
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('2')));
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('5')));

    assert_eq!(vim.count(), 25);
}

#[test]
fn test_vim_state_command_buffer() {
    // Test command buffer functionality
    let mut vim = VimState::new();

    // Test empty buffer initially
    assert_eq!(vim.command_buffer(), "");

    // Test setting command buffer through command mode
    vim.set_mode(VimMode::Command);
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char(':')));
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('w')));
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('q')));

    assert_eq!(vim.command_buffer(), ":wq");
}

#[test]
fn test_vim_state_register() {
    // Test register functionality
    let mut vim = VimState::new();

    // Test empty register initially
    assert_eq!(vim.register(), "");

    // Test setting register content
    vim.set_register("test content");
    assert_eq!(vim.register(), "test content");
}

#[test]
fn test_vim_state_map() {
    // Test custom key mapping
    let mut vim = VimState::new();

    // Test adding a mapping
    vim.map("dd", VimAction::Delete(Some(VimMotion::LineStart)));

    // Note: Actual mapping functionality would be tested if the mapping was public
    // This test just verifies the public API exists
}

#[test]
fn test_vim_state_handle_key_normal_mode() {
    // Test key handling in normal mode
    let mut vim = VimState::new();

    // Test navigation keys
    let action = vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('h')));
    assert_eq!(action, VimAction::Move(VimMotion::Left));

    let action = vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('j')));
    assert_eq!(action, VimAction::Move(VimMotion::Down));

    let action = vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('k')));
    assert_eq!(action, VimAction::Move(VimMotion::Up));

    let action = vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('l')));
    assert_eq!(action, VimAction::Move(VimMotion::Right));
}

#[test]
fn test_vim_state_handle_mode_transitions() {
    // Test mode transitions
    let mut vim = VimState::new();

    // Test transition to insert mode
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('i')));
    assert_eq!(vim.mode(), VimMode::Insert);

    // Test escape back to normal mode
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Escape));
    assert_eq!(vim.mode(), VimMode::Normal);

    // Test transition to visual mode
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Char('v')));
    assert_eq!(vim.mode(), VimMode::Visual);

    // Test escape back to normal mode
    vim.handle_key(&revue::event::KeyEvent::new(revue::event::Key::Escape));
    assert_eq!(vim.mode(), VimMode::Normal);
}

#[test]
fn test_vim_command_result() {
    // Test command result enum
    let write_result = VimCommandResult::Write;
    let quit_result = VimCommandResult::Quit;
    let write_quit_result = VimCommandResult::WriteQuit;
    let force_quit_result = VimCommandResult::ForceQuit;
    let edit_result = VimCommandResult::Edit(Some("file.txt".to_string()));
    let set_result = VimCommandResult::Set("number".to_string());
    let goto_line_result = VimCommandResult::GoToLine(42);
    let unknown_result = VimCommandResult::Unknown("unknown".to_string());

    // Verify the results exist and can be matched
    match write_result {
        VimCommandResult::Write => assert!(true),
        _ => assert!(false),
    }
}

#[test]
fn test_vim_state_execute_command() {
    // Test command execution
    let mut vim = VimState::new();

    // Test basic commands
    assert_eq!(vim.execute_command("w"), VimCommandResult::Write);
    assert_eq!(vim.execute_command("q"), VimCommandResult::Quit);
    assert_eq!(vim.execute_command("wq"), VimCommandResult::WriteQuit);
    assert_eq!(vim.execute_command("q!"), VimCommandResult::ForceQuit);
    assert_eq!(vim.execute_command("e"), VimCommandResult::Edit(None));
    assert_eq!(vim.execute_command("e file.txt"), VimCommandResult::Edit(Some("file.txt".to_string())));
    assert_eq!(vim.execute_command("set number"), VimCommandResult::Set("number".to_string()));

    // Test line number command
    assert_eq!(vim.execute_command("42"), VimCommandResult::GoToLine(42));

    // Test unknown command
    assert_eq!(vim.execute_command("unknown"), VimCommandResult::Unknown("unknown".to_string()));
}

#[test]
fn test_vim_motion_equality() {
    // Test motion equality
    let left1 = VimMotion::Left;
    let left2 = VimMotion::Left;
    let right = VimMotion::Right;

    assert_eq!(left1, left2);
    assert_ne!(left1, right);
}

#[test]
fn test_vim_action_equality() {
    // Test action equality
    let move_left1 = VimAction::Move(VimMotion::Left);
    let move_left2 = VimAction::Move(VimMotion::Left);
    let delete = VimAction::Delete(Some(VimMotion::Right));

    assert_eq!(move_left1, move_left2);
    assert_ne!(move_left1, delete);
}