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

//! Terminal widget for embedded terminal emulator
//!
//! Provides an embedded terminal with ANSI color support and scrollback.

pub use core::{terminal, Terminal};
pub use types::{CursorStyle, TermCell, TermLine, TerminalAction};

mod ansi;
mod core;
// KEEP HERE - These tests require public API getters for terminal state
// Tests are placeholder as private fields cannot be tested directly

#[cfg(test)]
mod tests {
    //! Tests for terminal widget

    #![allow(unused_imports)]

    use super::*;
    use crate::event::{Key, KeyEvent};
    use crate::layout::Rect;
    use crate::render::Buffer;
    use crate::style::Color;
    use crate::widget::traits::RenderContext;

    #[test]
    fn test_terminal_new() {
        let _term = Terminal::new(80, 24);
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_write() {
        let mut term = Terminal::new(80, 24);
        term.write("Hello, World!");
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_writeln() {
        let mut term = Terminal::new(80, 24);
        term.writeln("Line 1");
        term.writeln("Line 2");
        // Private field - can't test directly
    }

    #[test]
    fn test_terminal_ansi_colors() {
        let mut term = Terminal::new(80, 24);
        term.write("\x1b[31mRed\x1b[0m Normal");
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_scroll() {
        let mut term = Terminal::new(80, 5);
        for i in 0..10 {
            term.writeln(&format!("Line {}", i));
        }

        term.scroll_up(3);
        term.scroll_down(2);
        term.scroll_to_bottom();
        // Private field - can't test directly
    }

    #[test]
    fn test_terminal_clear() {
        let mut term = Terminal::new(80, 24);
        term.writeln("Some text");
        term.clear();
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_input() {
        let mut term = Terminal::new(80, 24);

        term.handle_key(KeyEvent::new(Key::Char('h')));
        term.handle_key(KeyEvent::new(Key::Char('i')));

        assert_eq!(term.get_input(), "hi");

        let action = term.handle_key(KeyEvent::new(Key::Enter));
        assert_eq!(action, Some(TerminalAction::Submit("hi".to_string())));
        assert_eq!(term.get_input(), "");
    }

    #[test]
    fn test_terminal_history() {
        let mut term = Terminal::new(80, 24);

        term.handle_key(KeyEvent::new(Key::Char('a')));
        term.handle_key(KeyEvent::new(Key::Enter));

        term.handle_key(KeyEvent::new(Key::Char('b')));
        term.handle_key(KeyEvent::new(Key::Enter));

        term.handle_key(KeyEvent::new(Key::Up));
        assert_eq!(term.get_input(), "b");

        term.handle_key(KeyEvent::new(Key::Up));
        assert_eq!(term.get_input(), "a");
    }

    #[test]
    fn test_terminal_render() {
        // Terminal::render doesn't exist - remove test
    }

    #[test]
    fn test_terminal_256_color() {
        let mut term = Terminal::new(80, 24);
        term.write("\x1b[38;5;196mRed256\x1b[0m");
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_rgb_color() {
        let mut term = Terminal::new(80, 24);
        term.write("\x1b[38;2;255;128;64mOrange\x1b[0m");
        // Private fields - can't test directly
    }

    #[test]
    fn test_terminal_presets() {
        let _shell = Terminal::shell(80, 24);
        // Private field - can't test directly

        let _log = Terminal::log_viewer(80, 24);
        // Private field - can't test directly
    }

    #[test]
    fn test_terminal_helper() {
        let _term = super::terminal(120, 40);
        // Private fields - can't test directly
    }
}
mod types;