lipgloss 0.1.0

Style definitions for nice terminal layouts. The core of the lipgloss-rs library.
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

use lipgloss::position::{
    place_horizontal, place_vertical, Position, BOTTOM, CENTER, LEFT, RIGHT, TOP,
};
use lipgloss::renderer::Renderer;

/// Create a renderer for testing (matches Go's blackhole struct functionality)
fn blackhole_renderer() -> Renderer {
    Renderer::new()
}

#[test]
fn test_place_horizontal() {
    let test_cases = vec![
        // odd spacing
        (10, "Hello", LEFT, "Hello     "),
        (10, "Hello", Position(0.0), "Hello     "),
        (10, "Hello", Position(0.000000001), "Hello     "),
        (10, "Hello", RIGHT, "     Hello"),
        (10, "Hello", Position(1.0), "     Hello"),
        (10, "Hello", Position(0.999999999), "     Hello"),
        (10, "Hello", Position(0.49), "  Hello   "),
        (10, "Hello", CENTER, "  Hello   "),
        (10, "Hello", Position(0.51), "   Hello  "),
    ];

    for (i, (width, text, pos, expected)) in test_cases.iter().enumerate() {
        let renderer = blackhole_renderer();
        let actual = renderer.place_horizontal(*width, *pos, text, &[]);
        assert_eq!(
            actual, *expected,
            "Test {}: expected {:?}, got {:?}",
            i, expected, actual
        );
    }
}

#[test]
fn test_place_vertical() {
    let test_cases = vec![
        (3, "Hello", TOP, "Hello\n     \n     "),
        (3, "Hello", Position(0.0), "Hello\n     \n     "),
        (3, "Hello", Position(0.000000001), "Hello\n     \n     "),
        (3, "Hello", BOTTOM, "     \n     \nHello"),
        (3, "Hello", Position(1.0), "     \n     \nHello"),
        (3, "Hello", Position(0.999999999), "     \n     \nHello"),
        (4, "Hello", Position(0.49), "     \nHello\n     \n     "),
        (4, "Hello", CENTER, "     \nHello\n     \n     "),
        (4, "Hello", Position(0.51), "     \n     \nHello\n     "),
    ];

    for (i, (height, content, position, expected)) in test_cases.iter().enumerate() {
        let renderer = blackhole_renderer();
        let actual = renderer.place_vertical(*height, *position, content, &[]);
        assert_eq!(
            actual, *expected,
            "Test {}: expected {:?}, got {:?}",
            i, expected, actual
        );
    }
}

#[test]
fn test_place_horizontal_global_functions() {
    // Test the global functions work the same as renderer methods
    let test_cases = vec![
        (10, "Hello", LEFT, "Hello     "),
        (10, "Hello", CENTER, "  Hello   "),
        (10, "Hello", RIGHT, "     Hello"),
    ];

    for (width, text, pos, expected) in test_cases {
        let actual = place_horizontal(width, pos, text, &[]);
        assert_eq!(actual, expected);
    }
}

#[test]
fn test_place_vertical_global_functions() {
    // Test the global functions work the same as renderer methods
    let test_cases = vec![
        (3, "Hello", TOP, "Hello\n     \n     "),
        (4, "Hello", CENTER, "     \nHello\n     \n     "),
        (3, "Hello", BOTTOM, "     \n     \nHello"),
    ];

    for (height, content, position, expected) in test_cases {
        let actual = place_vertical(height, position, content, &[]);
        assert_eq!(actual, expected);
    }
}

#[test]
fn test_position_value_clamping() {
    // Test that position values are properly clamped
    assert_eq!(Position(-0.5).value(), 0.0);
    assert_eq!(Position(0.5).value(), 0.5);
    assert_eq!(Position(1.5).value(), 1.0);
}

#[test]
fn test_symmetric_center_positioning() {
    // Test that center positioning is symmetric for different widths
    let test_cases = vec![
        (6, "Hi", "  Hi  "),    // even width
        (7, "Hi", "  Hi   "),   // odd width
        (8, "Hi", "   Hi   "),  // even width
        (9, "Hi", "   Hi    "), // odd width
    ];

    for (width, text, expected) in test_cases {
        let actual = place_horizontal(width, CENTER, text, &[]);
        assert_eq!(
            actual, expected,
            "Width {}: expected {:?}, got {:?}",
            width, expected, actual
        );
    }
}

#[test]
fn test_symmetric_center_positioning_vertical() {
    // Test that center positioning is symmetric for different heights
    let test_cases = vec![
        (4, "Hi", "  \nHi\n  \n  "),     // even height
        (5, "Hi", "  \n  \nHi\n  \n  "), // odd height
    ];

    for (height, text, expected) in test_cases {
        let actual = place_vertical(height, CENTER, text, &[]);
        assert_eq!(
            actual, expected,
            "Height {}: expected {:?}, got {:?}",
            height, expected, actual
        );
    }
}

#[test]
fn test_multiline_horizontal_placement() {
    // Test placing multiline text
    let text = "Hello\nWorld";
    let actual = place_horizontal(10, CENTER, text, &[]);
    let expected = "  Hello   \n  World   ";
    assert_eq!(actual, expected);
}

#[test]
fn test_zero_gap_handling() {
    // Test when content is same size or larger than target
    assert_eq!(place_horizontal(5, CENTER, "Hello", &[]), "Hello");
    assert_eq!(place_horizontal(3, CENTER, "Hello", &[]), "Hello");
    assert_eq!(place_vertical(1, CENTER, "Hello", &[]), "Hello");
}