rlvgl 0.2.2

A modular, idiomatic Rust reimplementation of the LVGL graphics library for embedded and simulator use.
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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

//! APP-02g integration tests: real theme translator per chapter
//! 02 §7.6. Covers the two v0 formats — `raw_palette_v1` (flat
//! hex map) and `chakra_tokens_v1` (top-level
//! colors/space/radii sections) — plus hex normalisation,
//! upper-snake-case const naming, and byte-determinism.
#![cfg(feature = "creator")]

#[path = "../src/bin/creator/app.rs"]
mod app;

use std::fs;
use std::path::{Path, PathBuf};

fn bsp_gen_unreachable(
    _vendor: &str,
    _board: &str,
    _chip: Option<&str>,
    _out_dir: &Path,
) -> anyhow::Result<String> {
    panic!("BSP-gen callback should not have been invoked in this test");
}

fn write_manifest(root: &Path, theme_format: &str) -> PathBuf {
    fs::create_dir_all(root.join("layouts")).unwrap();
    fs::write(root.join("layouts/home.rs"), "// layout\n").unwrap();
    let body = format!(
        r##"schema: rlvgl-app/v0
name: theme-fixture-app

target:
  vendor: esp
  board: beetle_esp32c3
  prong: bare_metal
  generator: hosted

theme:
  source: theme.json
  format: {theme_format}

screens:
  - id: home
    layout: layouts/home.rs
    layout_format: rust_inline_v1
    default: true
"##
    );
    let path = root.join("app.yaml");
    fs::write(&path, body).unwrap();
    path
}

fn run_orchestrator(manifest: &Path, ws_root: &Path) -> (tempfile::TempDir, app::Inventory) {
    let m = app::validate(manifest).expect("manifest validates");
    let out = tempfile::tempdir().unwrap();
    let mut orch = app::Orchestrator::new(
        m,
        manifest.parent().unwrap().to_path_buf(),
        ws_root.to_path_buf(),
        out.path().to_path_buf(),
    )
    .with_bsp_gen(bsp_gen_unreachable);
    let inv = orch.run().expect("orchestrator runs");
    (out, inv)
}

// ─── raw_palette_v1: flat hex map → pub mod colors ──────────────────

#[test]
fn raw_palette_v1_emits_colors_module() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "raw_palette_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "primary": "#3182CE",
  "background": "#ffffff",
  "text": "#000",
  "accent_light": "#f7fafc"
}
"##,
    )
    .unwrap();

    let (out, inv) = run_orchestrator(&manifest, tmp.path());

    let entry = inv
        .entries
        .iter()
        .find(|e| e.path == "src/theme.rs")
        .expect("inventory entry for theme.rs");
    assert_eq!(entry.stage, "theme");
    assert!(!entry.stub, "real theme translator must not flag stub");
    assert!(entry.hash.starts_with("blake3:"));

    let body = fs::read_to_string(out.path().join("src/theme.rs")).unwrap();
    assert!(body.contains("pub mod colors {"), "got:\n{body}");
    // Hex normalised to uppercase u32 literal.
    assert!(
        body.contains("pub const PRIMARY: u32 = 0x3182CE;"),
        "got:\n{body}"
    );
    // 6-digit lowercase normalised.
    assert!(
        body.contains("pub const BACKGROUND: u32 = 0xFFFFFF;"),
        "got:\n{body}"
    );
    // 3-digit hex expanded to 6.
    assert!(
        body.contains("pub const TEXT: u32 = 0x000000;"),
        "got:\n{body}"
    );
    // Snake-case key preserved as UPPER_SNAKE.
    assert!(
        body.contains("pub const ACCENT_LIGHT: u32 = 0xF7FAFC;"),
        "got:\n{body}"
    );
    // raw_palette_v1 emits ONLY the colors module.
    assert!(!body.contains("pub mod space"), "got:\n{body}");
    assert!(!body.contains("pub mod radii"), "got:\n{body}");
}

// ─── chakra_tokens_v1: full three-module shape ──────────────────────

#[test]
fn chakra_tokens_v1_emits_three_modules() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "chakra_tokens_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "colors": {
    "primary.500": "#3182CE",
    "gray.50": "#F7FAFC",
    "primaryLight": "#90CDF4"
  },
  "space": {
    "sp_4": 16,
    "sp_8": 32
  },
  "radii": {
    "md": 6,
    "lg": 12
  }
}
"##,
    )
    .unwrap();

    let (out, _inv) = run_orchestrator(&manifest, tmp.path());
    let body = fs::read_to_string(out.path().join("src/theme.rs")).unwrap();

    // Chapter 02 §7.6 example shape exactly.
    assert!(
        body.contains("pub const PRIMARY_500: u32 = 0x3182CE;"),
        "dotted key → underscore; got:\n{body}"
    );
    assert!(
        body.contains("pub const GRAY_50: u32 = 0xF7FAFC;"),
        "got:\n{body}"
    );
    // camelCase key → UPPER_SNAKE.
    assert!(
        body.contains("pub const PRIMARY_LIGHT: u32 = 0x90CDF4;"),
        "got:\n{body}"
    );

    // Space module — u16, integer values.
    assert!(body.contains("pub mod space {"), "got:\n{body}");
    assert!(body.contains("pub const SP_4: u16 = 16;"), "got:\n{body}");
    assert!(body.contains("pub const SP_8: u16 = 32;"), "got:\n{body}");

    // Radii module.
    assert!(body.contains("pub mod radii {"), "got:\n{body}");
    assert!(body.contains("pub const MD: u16 = 6;"), "got:\n{body}");
    assert!(body.contains("pub const LG: u16 = 12;"), "got:\n{body}");
}

// ─── chakra_tokens_v1: unknown top-level keys silently ignored ──────

#[test]
fn chakra_tokens_v1_ignores_unknown_top_level_keys() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "chakra_tokens_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "colors": { "primary": "#3182CE" },
  "fonts": { "heading": "Inter" },
  "shadows": { "sm": "0 1px 2px rgba(0,0,0,0.1)" },
  "typography": { "h1": { "fontSize": "48px" } }
}
"##,
    )
    .unwrap();

    // Per §7.6: non-trivial token types (typography, shadows) are a
    // v1 concern; the orchestrator silently ignores them at v0.
    let (out, _inv) = run_orchestrator(&manifest, tmp.path());
    let body = fs::read_to_string(out.path().join("src/theme.rs")).unwrap();
    assert!(body.contains("pub const PRIMARY: u32 = 0x3182CE;"));
    assert!(
        !body.contains("Inter"),
        "unknown sections ignored; got:\n{body}"
    );
    assert!(
        !body.contains("shadows"),
        "unknown sections ignored; got:\n{body}"
    );
    assert!(
        !body.contains("h1"),
        "unknown sections ignored; got:\n{body}"
    );
}

// ─── chakra_tokens_v1: missing space/radii is OK ────────────────────

#[test]
fn chakra_tokens_v1_with_only_colors_emits_only_colors() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "chakra_tokens_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "colors": { "primary": "#3182CE" }
}
"##,
    )
    .unwrap();

    let (out, _inv) = run_orchestrator(&manifest, tmp.path());
    let body = fs::read_to_string(out.path().join("src/theme.rs")).unwrap();
    assert!(body.contains("pub mod colors"));
    assert!(!body.contains("pub mod space"), "got:\n{body}");
    assert!(!body.contains("pub mod radii"), "got:\n{body}");
}

// ─── Invalid hex is rejected hard ───────────────────────────────────

#[test]
fn invalid_hex_is_rejected() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "raw_palette_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{ "primary": "blue" }"##,
    )
    .unwrap();

    let m = app::validate(&manifest).expect("manifest validates");
    let out = tempfile::tempdir().unwrap();
    let mut orch = app::Orchestrator::new(
        m,
        manifest.parent().unwrap().to_path_buf(),
        tmp.path().to_path_buf(),
        out.path().to_path_buf(),
    )
    .with_bsp_gen(bsp_gen_unreachable);
    let err = orch
        .run()
        .expect_err("invalid hex must be rejected")
        .to_string();
    assert!(
        err.contains("primary") && (err.contains("hex") || err.contains("rrggbb")),
        "got: {err}"
    );
}

// ─── Determinism: theme emission is byte-identical across runs ──────

#[test]
fn theme_emit_is_byte_deterministic() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "chakra_tokens_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "colors": { "z_color": "#111111", "a_color": "#222222" },
  "space": { "z_space": 8, "a_space": 4 }
}
"##,
    )
    .unwrap();

    let (out1, inv1) = run_orchestrator(&manifest, tmp.path());
    let (out2, inv2) = run_orchestrator(&manifest, tmp.path());

    let body1 = fs::read_to_string(out1.path().join("src/theme.rs")).unwrap();
    let body2 = fs::read_to_string(out2.path().join("src/theme.rs")).unwrap();
    assert_eq!(body1, body2, "theme.rs drifts across runs");

    // Sorted output: A_COLOR comes before Z_COLOR despite input order.
    let a_idx = body1.find("A_COLOR").unwrap();
    let z_idx = body1.find("Z_COLOR").unwrap();
    assert!(a_idx < z_idx, "colors not sorted; got:\n{body1}");

    let h1 = inv1
        .entries
        .iter()
        .find(|e| e.path == "src/theme.rs")
        .unwrap()
        .hash
        .clone();
    let h2 = inv2
        .entries
        .iter()
        .find(|e| e.path == "src/theme.rs")
        .unwrap()
        .hash
        .clone();
    assert_eq!(h1, h2);
}

// ─── Space u16 overflow is rejected hard ────────────────────────────

#[test]
fn space_value_exceeding_u16_is_rejected() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = write_manifest(tmp.path(), "chakra_tokens_v1");
    fs::write(
        manifest.parent().unwrap().join("theme.json"),
        r##"{
  "space": { "huge": 70000 }
}
"##,
    )
    .unwrap();

    let m = app::validate(&manifest).expect("manifest validates");
    let out = tempfile::tempdir().unwrap();
    let mut orch = app::Orchestrator::new(
        m,
        manifest.parent().unwrap().to_path_buf(),
        tmp.path().to_path_buf(),
        out.path().to_path_buf(),
    )
    .with_bsp_gen(bsp_gen_unreachable);
    let err = orch
        .run()
        .expect_err("u16 overflow must be rejected")
        .to_string();
    assert!(err.contains("u16") && err.contains("70000"), "got: {err}");
}