termgrid-core 1.5.5

Deterministic terminal grid state engine with invariant enforcement and backend decoupling.
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

use termgrid_core::{
    Frame, GlyphRegistry, Rect, RenderOp, RenderProfile, Renderer, Span, Style, WrapOpts,
};

fn reg() -> GlyphRegistry {
    GlyphRegistry::new(RenderProfile::bbsstalgia_xtermjs_unicode11_example())
}

fn cell_changed(a: &termgrid_core::Cell, b: &termgrid_core::Cell) -> bool {
    a != b
}

fn covered_by(rects: &[Rect], x: u16, y: u16) -> bool {
    rects
        .iter()
        .any(|r| x >= r.x && y >= r.y && x < r.x.saturating_add(r.w) && y < r.y.saturating_add(r.h))
}

#[test]
fn damage_covers_all_changed_cells_for_simple_ops() {
    let reg = reg();
    let mut r = Renderer::new(12, 4, reg).unwrap();

    let before = r.grid().clone();

    let f = Frame {
        ops: vec![
            RenderOp::Put {
                x: 0,
                y: 0,
                text: "Hi".to_string(),
                style: Style::plain(),
            },
            RenderOp::FillRect {
                x: 3,
                y: 1,
                w: 4,
                h: 2,
                glyph: " ".to_string(),
                style: Style {
                    bold: true,
                    ..Style::plain()
                },
            },
            RenderOp::TextBlockStyled {
                x: 0,
                y: 3,
                w: 10,
                spans: vec![Span::new("One two three", Style::plain())],
                wrap: WrapOpts::default(),
                h: 1,
            },
        ],
    };

    let dmg = r.apply_with_damage(&f);

    assert!(!dmg.full_redraw);
    assert!(!dmg.rects.is_empty());

    let after = r.grid().clone();

    for y in 0..after.height {
        for x in 0..after.width {
            let a = before.get(x, y).unwrap();
            let b = after.get(x, y).unwrap();
            if cell_changed(a, b) {
                assert!(
                    covered_by(&dmg.rects, x, y),
                    "changed cell not covered: ({x},{y}) dmg={dmg:?}"
                );
            }
        }
    }
}

#[test]
fn damage_caps_to_full_redraw_when_too_many_rects() {
    let reg = reg();
    let mut r = Renderer::new(40, 10, reg).unwrap();

    // Many tiny, non-adjacent ops -> many rects -> should flip to full redraw.
    // Ensure no rectangles touch so merge_in_place() cannot coalesce them.
    let mut ops = Vec::new();
    for y in (0u16..10u16).step_by(2) {
        for x in (0u16..40u16).step_by(2) {
            ops.push(RenderOp::PutGlyph {
                x,
                y,
                glyph: "x".to_string(),
                style: Style::plain(),
            });
        }
    }
    // This creates 20*5 = 100 distinct 1x1 dirty rects (> cap of 64).
    let f = Frame { ops };

    let dmg = r.apply_with_damage(&f);
    assert!(dmg.full_redraw);
    assert!(dmg.rects.is_empty());
}