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

//! Tests for gradient interpolation (interpolation.rs)
//!
//! Extracted from src/utils/gradient/interpolation.rs

use revue::style::Color;
use revue::utils::gradient::interpolation::*;
use revue::utils::gradient::types::InterpolationMode;

// =========================================================================
// lerp_rgb tests
// =========================================================================

#[test]
fn test_lerp_rgb_t0_returns_from() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_rgb(from, to, 0.0);
    assert_eq!(result, from);
}

#[test]
fn test_lerp_rgb_t1_returns_to() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_rgb(from, to, 1.0);
    assert_eq!(result, to);
}

#[test]
fn test_lerp_rgb_t05_returns_middle() {
    let from = Color::rgb(0, 0, 0);
    let to = Color::rgb(254, 254, 254);
    let result = lerp_rgb(from, to, 0.5);
    // (0 + 254) / 2 = 127
    assert_eq!(result.r, 127);
    assert_eq!(result.g, 127);
    assert_eq!(result.b, 127);
}

#[test]
fn test_lerp_rgb_with_alpha() {
    let from = Color::rgba(255, 0, 0, 0);
    let to = Color::rgba(0, 0, 255, 255);
    let result = lerp_rgb(from, to, 0.5);
    assert_eq!(result.a, 128); // Middle alpha
}

#[test]
fn test_lerp_rgb_same_color() {
    let color = Color::rgb(100, 150, 200);
    let result = lerp_rgb(color, color, 0.5);
    assert_eq!(result, color);
}

// =========================================================================
// lerp_hsl tests
// =========================================================================

#[test]
fn test_lerp_hsl_t0_returns_from() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_hsl(from, to, 0.0, false);
    assert_eq!(result, from);
}

#[test]
fn test_lerp_hsl_t1_returns_to() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_hsl(from, to, 1.0, false);
    assert_eq!(result, to);
}

#[test]
fn test_lerp_hsl_short_path() {
    // Red (0°) to Yellow (60°)
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(255, 255, 0);
    let result = lerp_hsl(from, to, 0.5, true);
    // Should be orange-ish (around 30° hue)
    let _ = result;
}

#[test]
fn test_lerp_hsl_no_short_path() {
    // Red to Green with no short path
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_hsl(from, to, 0.5, false);
    // Should produce some interpolated color
    let _ = result;
}

// =========================================================================
// lerp_hsl_long tests
// =========================================================================

#[test]
fn test_lerp_hsl_long_t0_returns_from() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_hsl_long(from, to, 0.0);
    assert_eq!(result, from);
}

#[test]
fn test_lerp_hsl_long_t1_returns_to() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = lerp_hsl_long(from, to, 1.0);
    assert_eq!(result, to);
}

#[test]
fn test_lerp_hsl_long_takes_long_path() {
    // Red (0°) to Yellow (60°) via long path
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(255, 255, 0);
    let result = lerp_hsl_long(from, to, 0.5);
    // Long path should go the other way around
    let _ = result;
}

// =========================================================================
// interpolate function tests
// =========================================================================

#[test]
fn test_interpolate_rgb_mode() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = interpolate(from, to, 0.5, InterpolationMode::Rgb);
    assert_eq!(result.r, 128); // Average of 255 and 0
    assert_eq!(result.g, 128); // Average of 0 and 255
}

#[test]
fn test_interpolate_hsl_mode() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 0, 255);
    let result = interpolate(from, to, 0.5, InterpolationMode::Hsl);
    // HSL interpolation produces purple-ish color
    let _ = result;
}

#[test]
fn test_interpolate_hsl_short_mode() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = interpolate(from, to, 0.5, InterpolationMode::HslShort);
    // Short path from red to green via yellow
    let _ = result;
}

#[test]
fn test_interpolate_hsl_long_mode() {
    let from = Color::rgb(255, 0, 0);
    let to = Color::rgb(0, 255, 0);
    let result = interpolate(from, to, 0.5, InterpolationMode::HslLong);
    // Long path from red to green via magenta/blue
    let _ = result;
}

// =========================================================================
// Edge case tests
// =========================================================================

#[test]
fn test_lerp_rgb_negative_t_clamped() {
    let from = Color::rgb(128, 128, 128);
    let to = Color::rgb(255, 255, 255);
    // t = -0.5 should go toward black, but rounding may give unexpected results
    let result = lerp_rgb(from, to, -0.5);
    // Just verify we get a valid color
    let _ = result;
}

#[test]
fn test_lerp_rgb_greater_than_one() {
    let from = Color::rgb(128, 128, 128);
    let to = Color::rgb(255, 255, 255);
    // t = 1.5 should go beyond to
    let result = lerp_rgb(from, to, 1.5);
    // Just verify we get a valid color
    let _ = result;
}

#[test]
fn test_lerp_hsl_with_grayscale() {
    let from = Color::rgb(128, 128, 128);
    let to = Color::rgb(200, 200, 200);
    let result = lerp_hsl(from, to, 0.5, true);
    // Grayscale interpolation
    let _ = result;
}