test(framework): imperative HTML-to-Rust codegen replacing runtime from_str

build.rs translates each tests/cases/**/*.html into a self-contained imperative #[test] under tests/generated/<topic>/<name>.rs via TestCtx high-level API (create_node/set_style/append/layout_imperative + getters). Legacy from_str/create_node_recursive/batch assert_html_case! removed. 978 passed, equivalent to prior runtime-parsing path.

Author: TtTRz

Cargo.lock

@@ -2,4 +2,5 @@
 /target
 Cargo.lock
 **/*.rs.bk
-.DS_store
+.DS_store
+/tests/generated/

float-pigment-forest/.gitignore

@@ -48,7 +48,6 @@ lazy_static = "1.4"
 fs_extra = { version = "1.3", optional = true }
 
 [dev-dependencies]
-rand = "0.8.5"
 criterion = "0.5.1"
 float-pigment-mlp = { workspace = true }
 rustc-hash = "1.1.0"
@@ -59,3 +58,6 @@ piston_window = "0.128.0"
 [lints.clippy]
 missing_safety_doc = "allow"
 clone_on_copy = "allow"
+
+[build-dependencies]
+float-pigment-mlp = { workspace = true }

float-pigment-forest/Cargo.toml

@@ -1,46 +1,299 @@
-// Scans tests/cases/**/*.html and generates #[test] functions that call
-// assert_html_case!(<absolute path>). Output goes to OUT_DIR/html_tests.rs,
-// which tests/mod.rs include!s.
+// HTML -> imperative Rust translator: each tests/cases/<topic>/<case>.html
+// is translated into a `#[test]` that exercises the TestCtx high-level API
+// (create_node / create_text / set_style / append + layout_imperative +
+// getters). Output goes to tests/generated/<topic>/<case>.rs plus a nested
+// mod tree (tests/generated/mod.rs → <topic>/mod.rs → <case>.rs), which
+// tests/mod.rs pulls in via `mod generated;`.
+//
+// The translator walks the parsed DOM and emits imperative calls in
+// document order. Layout assertions (data-expect-*) are collected during
+// the walk and emitted after `ctx.layout_imperative()` so they read back
+// computed values.
 use std::{fs, path::PathBuf};
 
+use float_pigment_mlp::{
+    context::{Context, Parse},
+    node::{attribute::Attribute, NodeType},
+};
+
 fn main() {
     let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap();
     let cases_dir = PathBuf::from(&manifest).join("tests/cases");
-    let mut tests = String::new();
-    tests.push_str("// AUTO-GENERATED by build.rs. Do not edit.\n\n");
-
-    if !cases_dir.exists() {
-        let out = std::env::var("OUT_DIR").unwrap();
-        fs::write(format!("{out}/html_tests.rs"), tests).unwrap();
-        return;
-    }
-
-    let mut entries = walk(&cases_dir, &cases_dir);
-    entries.sort();
-    for (rel, abs) in entries {
-        if abs.extension().and_then(|e| e.to_str()) != Some("html") {
-            continue;
-        }
-        // function name: relative path, separators -> underscore
-        let fn_name = rel
-            .with_extension("")
-            .to_string_lossy()
-            .replace(['/', '\\', '-', ' '], "_");
-        let abs_str = abs.to_str().unwrap();
-        let content = fs::read_to_string(&abs).unwrap_or_default();
-        let ignore_attr = if content.contains("data-ignore=\"true\"") {
-            "#[ignore]\n"
-        } else {
-            ""
-        };
-        tests.push_str(&format!(
-            "{ignore_attr}#[test]\nfn html__{fn_name}() {{\n    assert_html_case!(\"{abs_str}\");\n}}\n\n"
-        ));
-    }
-
-    let out = std::env::var("OUT_DIR").unwrap();
-    fs::write(format!("{out}/html_tests.rs"), tests).unwrap();
+    let gen_dir = PathBuf::from(&manifest).join("tests/generated");
+    // 清空旧生成（删整个 generated 再重建，避免残留）
+    let _ = fs::remove_dir_all(&gen_dir);
+    fs::create_dir_all(&gen_dir).unwrap();
+
+    // topic -> Vec<(case_name, body, ignore)>
+    let mut by_topic: std::collections::BTreeMap<String, Vec<(String, String, bool)>> =
+        std::collections::BTreeMap::new();
+
+    if cases_dir.exists() {
+        let mut entries = walk(&cases_dir, &cases_dir);
+        entries.sort();
+        for (rel, abs) in entries {
+            if abs.extension().and_then(|e| e.to_str()) != Some("html") {
+                continue;
+            }
+            let rel_str = rel.with_extension("").to_string_lossy().replace('\\', "/");
+            let mut parts = rel_str.split('/');
+            let topic = parts.next().unwrap_or("misc").to_string();
+            let name = parts.collect::<Vec<_>>().join("_");
+            let html = fs::read_to_string(&abs).unwrap_or_default();
+            let ignore = html.contains("data-ignore=\"true\"");
+            let body = translate_html(&html);
+            by_topic.entry(topic).or_default().push((name, body, ignore));
+        }
+    }
+
+    // 生成每 topic 目录 + mod.rs + 各 case .rs。
+    // topic/name 原样用作目录名/文件名（文件系统允许 `-`），但需 sanitize
+    // 为合法 Rust 标识符（`-` 非法）用于 mod 名与 fn 名。当前 cases 无 `-`，
+    // 此 sanitize 为防御性 —— 与旧 build.rs `replace(['/', '\\', '-', ' '], "_")` 一致。
+    let mut top_mod = String::from("// AUTO-GENERATED by build.rs. Do not edit.\n\n");
+    for (topic, cases) in &by_topic {
+        let topic_dir = gen_dir.join(topic);
+        fs::create_dir_all(&topic_dir).unwrap();
+        let topic_ident = topic.replace('-', "_");
+        let mut topic_mod = String::from("// AUTO-GENERATED. Do not edit.\n\n");
+        for (name, body, ignore) in cases {
+            let name_ident = name.replace('-', "_");
+            let fn_name = format!("html__{}_{}", topic_ident, name_ident);
+            let ignore_attr = if *ignore { "#[ignore]\n" } else { "" };
+            let case_rs = format!(
+                "// AUTO-GENERATED from tests/cases/{topic}/{name}.html. Do not edit.\nuse crate::TestCtx;\n\n{ignore_attr}#[test]\nfn {fn_name}() {{\n{body}}}\n"
+            );
+            fs::write(topic_dir.join(format!("{name}.rs")), case_rs).unwrap();
+            topic_mod.push_str(&format!("mod {name_ident};\n"));
+        }
+        fs::write(topic_dir.join("mod.rs"), topic_mod).unwrap();
+        top_mod.push_str(&format!("mod {topic_ident};\n"));
+    }
+    fs::write(gen_dir.join("mod.rs"), top_mod).unwrap();
     println!("cargo:rerun-if-changed=tests/cases");
+    println!("cargo:rerun-if-changed=build.rs");
+}
+
+/// Parse the HTML and emit imperative TestCtx calls.
+///
+/// Order: create_node/create_text + set_style + append (pre-order DOM walk),
+/// then `ctx.layout_imperative()`, then the collected assert_eq! calls.
+fn translate_html(html: &str) -> String {
+    let mut parse_ctx = Context::create(None);
+    parse_ctx.parse(html);
+    let mut out = String::from("    let mut ctx = TestCtx::new();\n");
+    let mut counter = Counter::default();
+    // The parser always wraps content in a Fragment root. `gen_node` mirrors
+    // `TestCtx::create_node_recursive` by materialising that Fragment as a
+    // Block wrapper Node, so the generated tree structurally matches the
+    // legacy `from_str` path (important for layout assertions on top-level
+    // elements — they sit inside the wrapper, not as the layout root).
+    if let Some(tree) = parse_ctx.tree() {
+        if let Some(root) = tree.root() {
+            let _ = gen_node(&mut out, root, None, &mut counter);
+        }
+    }
+    out.push_str("    ctx.layout_imperative();\n");
+    for a in &counter.asserts {
+        out.push_str(a);
+    }
+    out
+}
+
+struct Counter {
+    n: usize,
+    t: usize,
+    asserts: Vec<String>,
+}
+impl Default for Counter {
+    fn default() -> Self {
+        Self {
+            n: 0,
+            t: 0,
+            asserts: vec![],
+        }
+    }
+}
+
+/// Walk a DOM node, emit create_node/create_text + set_style + append, and
+/// collect data-expect-* assertions. Returns the variable name bound to this
+/// node (for the parent's `append` call).
+fn gen_node(out: &mut String, node: &NodeType, parent: Option<&str>, c: &mut Counter) -> String {
+    match node {
+        NodeType::Element(e) => {
+            let var = format!("n{}", c.n);
+            c.n += 1;
+            out.push_str(&format!(
+                "    let {var} = ctx.create_node({});\n",
+                rust_str_literal(e.tag())
+            ));
+            let attrs = e.attributes();
+            if let Some(style) = attrs.get("style") {
+                if !style.is_empty() {
+                    out.push_str(&format!(
+                        "    ctx.set_style({var}, {});\n",
+                        rust_str_literal(&style)
+                    ));
+                }
+            }
+            // Measure-text slots: tags recognised by `is_measure_text_slot`
+            // (currently just `text-slot`) carry synthetic `len` / `fontSize`
+            // attributes that drive an intrinsic-size measure func. Emit a
+            // `set_measure_text` call so build_dfs wires up TextInfo exactly
+            // like the legacy `create_node_recursive`. Defaults match the
+            // legacy path: len=0, fontSize=16.
+            if is_measure_text_slot(e.tag()) {
+                let len = attrs
+                    .get("len")
+                    .and_then(|v| v.trim().parse::<usize>().ok())
+                    .unwrap_or(0);
+                let font_size = attrs
+                    .get("fontSize")
+                    .and_then(|v| v.trim().parse::<f32>().ok())
+                    .unwrap_or(16.0);
+                out.push_str(&format!(
+                    "    ctx.set_measure_text({var}, {len}, {});\n",
+                    parse_value(&font_size.to_string())
+                ));
+            }
+            collect_asserts(&var, attrs, c);
+            if let Some(p) = parent {
+                out.push_str(&format!("    ctx.append({}, {var});\n", p));
+            }
+            // Collect children into a Vec first to drop the RefMut borrow
+            // before recursing (gen_node may itself borrow the same element's
+            // siblings via the parent's RefCell — defensive; recursion target
+            // is a different Rc<NodeType> so this is not strictly required,
+            // but it keeps the borrow story obviously correct).
+            let children: Vec<_> = e.children_mut().iter().cloned().collect();
+            for child in children.iter() {
+                gen_node(out, child.as_ref(), Some(&var), c);
+            }
+            var
+        }
+        NodeType::Text(t) => {
+            let var = format!("t{}", c.t);
+            c.t += 1;
+            out.push_str(&format!(
+                "    let {var} = ctx.create_text({});\n",
+                rust_str_literal(t.text())
+            ));
+            if let Some(p) = parent {
+                out.push_str(&format!("    ctx.append({}, {var});\n", p));
+            }
+            var
+        }
+        NodeType::Fragment(f) => {
+            // Fragment always materialises as a Block wrapper Node — this
+            // mirrors `TestCtx::create_node_recursive`, where a Fragment
+            // becomes `Node::new_ptr()` (default Display::Block) and its
+            // children are appended underneath. Skipping the wrapper breaks
+            // layout assertions on top-level elements (they would become the
+            // layout root instead of sitting inside a Block container).
+            let var = format!("n{}", c.n);
+            c.n += 1;
+            out.push_str(&format!(
+                "    let {var} = ctx.create_node({});\n",
+                rust_str_literal("div")
+            ));
+            if let Some(p) = parent {
+                out.push_str(&format!("    ctx.append({}, {var});\n", p));
+            }
+            let children: Vec<_> = f.children_mut().iter().cloned().collect();
+            for child in children.iter() {
+                let _ = gen_node(out, child.as_ref(), Some(&var), c);
+            }
+            var
+        }
+    }
+}
+
+/// Collect data-expect-* / expect_* assertions for a node. Assertions are
+/// appended after `ctx.layout_imperative()` in `translate_html`.
+fn collect_asserts(var: &str, attrs: &Attribute, c: &mut Counter) {
+    // (html_attr_alt, html_attr_primary, getter)
+    const MAP: &[(&str, &str, &str)] = &[
+        ("expect_width", "data-expect-width", "width"),
+        ("expect_height", "data-expect-height", "height"),
+        ("expect_left", "data-expect-left", "left"),
+        ("expect_top", "data-expect-top", "top"),
+        ("expect_margin_top", "data-expect-margin-top", "margin_top"),
+        (
+            "expect_margin_right",
+            "data-expect-margin-right",
+            "margin_right",
+        ),
+        (
+            "expect_margin_bottom",
+            "data-expect-margin-bottom",
+            "margin_bottom",
+        ),
+        (
+            "expect_margin_left",
+            "data-expect-margin-left",
+            "margin_left",
+        ),
+    ];
+    for (alt, primary, getter) in MAP {
+        let v = attrs.get(primary).or_else(|| attrs.get(alt));
+        if let Some(v) = v {
+            // `.round()` mirrors the legacy `PartialLayoutPosition` eq impl,
+            // which compares `expect == layout.to_f32().round()`. Without
+            // rounding, percentage/flex layout values with f32 precision
+            // drift (e.g. 99.90234 vs 100.0) would spuriously fail.
+            c.asserts.push(format!(
+                "    assert_eq!(ctx.{getter}({var}).round(), {});\n",
+                parse_value(&v)
+            ));
+        }
+    }
+}
+
+/// Format an HTML scalar value as an f32 literal. Integers get a trailing
+/// `.0` so the literal has type f32 and matches the getter return type.
+fn parse_value(v: &str) -> String {
+    let v = v.trim();
+    if v.contains('.') {
+        v.to_string()
+    } else {
+        format!("{}.0", v)
+    }
+}
+
+/// Tag set that the legacy `create_node_recursive` treats as a measure-text
+/// slot. Kept in sync with `is_measure_text_slot` in tests/mod.rs; build.rs
+/// cannot import the test helper, so we duplicate the predicate here.
+fn is_measure_text_slot(tag: &str) -> bool {
+    tag == "text-slot"
+}
+
+/// Build a Rust string literal that round-trips the input text. Prefers raw
+/// strings (`r#"..."#`, escalating the `#` count) so generated code reads
+/// cleanly; falls back to a fully escaped `"..."` literal only when the text
+/// contains every raw-string terminator we try.
+fn rust_str_literal(s: &str) -> String {
+    // Try escalating raw-string hash counts. `"#` rules out r#"..."#, etc.
+    for hashes in 1..=5 {
+        let pat = format!("\"{}", "#".repeat(hashes));
+        if !s.contains(&pat) {
+            let h = "#".repeat(hashes);
+            return format!("r{h}\"{s}\"{h}");
+        }
+    }
+    // Fallback: escaped string literal.
+    let mut out = String::from('"');
+    for ch in s.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            other => out.push(other),
+        }
+    }
+    out.push('"');
+    out
 }
 
 fn walk(root: &PathBuf, dir: &PathBuf) -> Vec<(PathBuf, PathBuf)> {