typeset 3.1.2

A DSL for defining source code pretty printers
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
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

//! Tests for individual compiler passes
//!
//! These tests verify that each compiler pass works correctly in isolation
//! and that the overall pipeline produces correct results.

use typeset::{
    braces, comp, compile, compile_safe, compile_safe_with_depth, fix, grp, join_with_commas,
    join_with_spaces, nest, pack, parens, render, seq, text,
};

/// Test the complete compiler pipeline with various layout constructs
#[test]
fn test_all_layout_constructs() {
    // Create a layout that uses all major constructs
    let layout = comp(
        text("Program:".to_string()),
        nest(comp(
            fix(text("fn".to_string())),
            comp(
                text("main()".to_string()),
                braces(grp(join_with_commas(vec![
                    text("stmt1".to_string()),
                    text("stmt2".to_string()),
                    seq(comp(
                        text("if".to_string()),
                        parens(text("condition".to_string())),
                        true,
                        false,
                    )),
                ]))),
                true,
                false,
            ),
            true,
            false,
        )),
        false,
        false,
    );

    let doc = compile(layout);
    let output = render(doc, 4, 60);

    // Verify the output contains expected elements
    assert!(output.contains("Program:"));
    assert!(output.contains("fn"));
    assert!(output.contains("main()"));
    assert!(output.contains("stmt1"));
    assert!(output.contains("stmt2"));
    assert!(output.contains("condition"));
}

/// Test memory safety with deep nesting
#[test]
fn test_deep_nesting() {
    let mut layout = text("base".to_string());

    // Create moderately nested structure (reduced to avoid stack overflow)
    for i in 0..20 {
        layout = nest(comp(text(format!("level_{}", i)), layout, true, false));
    }

    // Should compile without stack overflow
    let result = compile_safe(layout);
    assert!(result.is_ok());

    if let Ok(doc) = result {
        let output = render(doc, 2, 100);
        assert!(output.contains("base"));
        assert!(output.contains("level_0"));
        assert!(output.contains("level_19"));
    }
}

/// Test wide layouts with many compositions
#[test]
fn test_wide_layouts() {
    let mut layout = text("first".to_string());

    // Create wide structure with many compositions (reduced to prevent stack overflow)
    for i in 1..20 {
        layout = comp(layout, text(format!("item_{}", i)), true, false);
    }

    let result = compile_safe_with_depth(layout, 200);
    assert!(result.is_ok());

    if let Ok(doc) = result {
        let output = render(doc, 2, 500); // Wide render
        assert!(output.contains("first"));
        assert!(output.contains("item_1"));
        assert!(output.contains("item_19"));
    }
}

/// Test that fix construct prevents breaking
#[test]
fn test_fix_prevents_breaking() {
    let breakable = comp(
        text("breakable".to_string()),
        text("content".to_string()),
        true,
        false,
    );

    let fixed = fix(comp(
        text("fixed".to_string()),
        text("content".to_string()),
        true,
        false,
    ));

    let layout = comp(breakable, fixed, false, false);

    let doc = compile(layout);
    let output = render(doc, 2, 10); // Very narrow to force breaking

    // The fixed part should stay together even when narrow
    assert!(output.contains("fixed content"));
}

/// Test group breaking behavior
#[test]
fn test_group_breaking() {
    let grouped_content = grp(join_with_spaces(vec![
        text("grouped".to_string()),
        text("content".to_string()),
        text("that".to_string()),
        text("should".to_string()),
        text("break".to_string()),
        text("together".to_string()),
    ]));

    let layout = comp(text("Before".to_string()), grouped_content, true, false);

    // Test with wide width (should fit on one line)
    let doc = compile(layout.clone());
    let wide_output = render(doc, 2, 100);

    let lines: Vec<&str> = wide_output.split('\n').collect();
    // Should be on fewer lines when there's space
    let wide_line_count = lines.len();

    // Test with narrow width (should break)
    let doc = compile(layout);
    let narrow_output = render(doc, 2, 10);

    let narrow_lines: Vec<&str> = narrow_output.split('\n').collect();
    let narrow_line_count = narrow_lines.len();

    // Should break consistently (all or nothing for the group)
    assert!(wide_line_count <= narrow_line_count);
}

/// Test sequence breaking (breaks all if one breaks)
#[test]
fn test_sequence_breaking() {
    let seq_content = seq(join_with_spaces(vec![
        text("seq1".to_string()),
        text("seq2".to_string()),
        text("seq3".to_string()),
        text("seq4".to_string()),
    ]));

    let layout = comp(text("Before".to_string()), seq_content, true, false);

    let doc = compile(layout);
    let output = render(doc, 2, 15); // Narrow enough to trigger breaking

    // If sequence breaks, all items should be on separate lines
    if output.contains('\n') {
        let content_part = output.split("Before").nth(1).unwrap_or("");
        let _items: Vec<&str> = content_part.split_whitespace().collect();

        // Each sequence item should be easily identifiable
        assert!(output.contains("seq1"));
        assert!(output.contains("seq2"));
        assert!(output.contains("seq3"));
        assert!(output.contains("seq4"));
    }
}

/// Test pack alignment with complex content
#[test]
fn test_pack_alignment_complex() {
    let pack_content = pack(join_with_commas(vec![
        comp(
            text("key1".to_string()),
            text("value1".to_string()),
            true,
            false,
        ),
        comp(
            text("key2".to_string()),
            text("value2".to_string()),
            true,
            false,
        ),
        comp(
            text("longer_key".to_string()),
            text("value3".to_string()),
            true,
            false,
        ),
    ]));

    let layout = comp(text("Config:".to_string()), pack_content, true, false);

    let doc = compile(layout);
    let output = render(doc, 2, 25); // Force some breaking

    // Should have proper alignment
    assert!(output.contains("Config:"));
    assert!(output.contains("key1"));
    assert!(output.contains("key2"));
    assert!(output.contains("longer_key"));
}

/// Test mixed layout constructs work together
#[test]
fn test_mixed_constructs() {
    let layout = grp(seq(comp(
        fix(text("FIXED".to_string())),
        nest(pack(join_with_commas(vec![
            text("item_a".to_string()),
            text("item_b".to_string()),
            text("item_c".to_string()),
        ]))),
        true,
        false,
    )));

    // Should compile without issues
    let result = compile_safe(layout);
    assert!(result.is_ok());

    if let Ok(doc) = result {
        let output = render(doc, 3, 30);
        assert!(output.contains("FIXED"));
        assert!(output.contains("item_a"));
        assert!(output.contains("item_b"));
        assert!(output.contains("item_c"));
    }
}

/// Test edge cases with empty and null layouts
#[test]
fn test_edge_cases() {
    // Test with null layout
    let null_layout = typeset::null();
    let doc = compile(null_layout);
    let output = render(doc, 2, 80);
    assert_eq!(output, "");

    // Test composition with null
    let with_null = comp(text("Before".to_string()), typeset::null(), true, false);
    let doc = compile(with_null);
    let output = render(doc, 2, 80);
    assert_eq!(output, "Before");

    // Test empty text
    let empty_text = text("".to_string());
    let doc = compile(empty_text);
    let output = render(doc, 2, 80);
    assert_eq!(output, "");
}