5617070 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

5617070 — Peter John 2026-11-02T14:02:19+05:30

T7: incidental files

Files changed (2) hide show

plum-cli/tests/game_web_test.rs +81 -0
plum-game/web/bridge_check.mjs +74 -0

plum-cli/tests/game_web_test.rs ADDED Viewed

@@ -0,0 +1,81 @@
+#![allow(non_snake_case)]
+use std::process::Command;
+fn plumBin() -> std::path::PathBuf {
+    let mut path = std::env::current_exe().unwrap();
+    path.pop();
+    if path.ends_with("deps") {
+        path.pop();
+    }
+    path.push("plum");
+    path
+}
+#[test]
+fn webBuildWritesTheDist() {
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap();
+    let scratch = std::env::temp_dir().join(format!("plum_game_web_{}", std::process::id()));
+    let assets = scratch.join("assets");
+    let dist = scratch.join("dist");
+    // Stand-in asset files: the build copies them without reading them.
+    let sprites = [
+        "GUI_a", "GUIMain", "Houses_a", "Tileset", "Trees_a", "Units_a",
+    ];
+    std::fs::create_dir_all(assets.join("sprites")).unwrap();
+    std::fs::create_dir_all(assets.join("data/defines")).unwrap();
+    for s in sprites {
+        std::fs::write(assets.join(format!("sprites/{s}.rxx")), b"x").unwrap();
+    }
+    std::fs::write(assets.join("data/defines/mapelem.dat"), b"x").unwrap();
+    std::fs::write(assets.join("extra.map"), b"x").unwrap();
+    let out = Command::new(plumBin())
+        .current_dir(root)
+        .args([
+            "game",
+            "--web",
+            "plum-game/tests/fixtures/host_fixture.plum",
+            "-o",
+        ])
+        .arg(&dist)
+        .arg("--assets")
+        .arg(&assets)
+        .args(["--preload", "extra.map"])
+        .output()
+        .expect("failed to run plum");
+    let all = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(out.status.success(), "plum game --web failed:\n{all}");
+    for f in [
+        "index.html",
+        "mq_js_bundle.js",
+        "plum_bridge.js",
+        "plum-game.wasm",
+        "plum.wasm",
+        "preload.txt",
+    ] {
+        assert!(dist.join(f).is_file(), "missing {f}");
+    }
+    let preload = std::fs::read_to_string(dist.join("preload.txt")).unwrap();
+    let lines: Vec<&str> = preload.lines().collect();
+    for s in sprites {
+        assert!(
+            lines.contains(&format!("sprites/{s}.rxx").as_str()),
+            "{s} not preloaded"
+        );
+    }
+    assert!(lines.contains(&"extra.map"));
+    for l in &lines {
+        assert!(
+            dist.join("assets").join(l).is_file(),
+            "assets/{l} not copied"
+        );
+    }
+    let _ = std::fs::remove_dir_all(&scratch);
+}

plum-game/web/bridge_check.mjs ADDED Viewed

@@ -0,0 +1,74 @@
+// Usage: node bridge_check.mjs <plum.wasm>
+//
+// Loads a compiled Plum game and checks that plum_bridge.js satisfies every
+// import, that every pg_* export it calls exists in src/web.rs, and that the
+// module runs init/update/draw against a stub host.
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+import assert from "node:assert/strict";
+const here = dirname(fileURLToPath(import.meta.url));
+const wasmPath = process.argv[2];
+if (!wasmPath) {
+  console.error("usage: node bridge_check.mjs <plum.wasm>");
+  process.exit(2);
+}
+vm.runInThisContext(readFileSync(join(here, "plum_bridge.js"), "utf8"));
+const { makeImports, hostNames } = globalThis.PlumBridge;
+// Every pg_* name the plugin calls is exported by the Rust host.
+const webRs = readFileSync(join(here, "../src/web.rs"), "utf8");
+const exported = new Set([...webRs.matchAll(/extern "C" fn (pg_\w+)/g)].map((m) => m[1]));
+for (const n of hostNames) assert.ok(exported.has(n), `web.rs does not export ${n}`);
+const module = await WebAssembly.compile(readFileSync(wasmPath));
+const imports = WebAssembly.Module.imports(module).filter((i) => i.module === "plum");
+const importObject = makeImports(module, stubHost(), { plum: null });
+const missing = imports.filter((i) => typeof importObject.plum[i.name] !== "function");
+assert.deepEqual(missing, [], "plum imports without a binding");
+// Stub host: records calls; handles load as failures.
+function stubHost() {
+  const memory = new WebAssembly.Memory({ initial: 4 });
+  let bump = 1024;
+  const calls = [];
+  const host = new Proxy(
+    { memory, calls, loaded: [] },
+    {
+      get(t, name) {
+        if (name in t) return t[name];
+        if (name === "pg_alloc") return (n) => ((bump += Math.max(n, 1)), bump - Math.max(n, 1));
+        if (name === "pg_free") return () => {};
+        return (...a) => {
+          calls.push([name, ...a]);
+          if (/load$/.test(name)) {
+            // (ptr, len): the Str arrived intact in host memory.
+            t.loaded.push(new TextDecoder().decode(new Uint8Array(memory.buffer, a[0], a[1])));
+            return -1;
+          }
+          if (/screen_(width|height)/.test(name)) return 800;
+          return 0;
+        };
+      },
+    },
+  );
+  return host;
+}
+const host = stubHost();
+const ctx = { plum: null };
+const instance = await WebAssembly.instantiate(module, makeImports(module, host, ctx));
+ctx.plum = instance.exports;
+for (const n of ["strLen", "strByte", "strNew", "strSetByte", "init", "update", "draw"]) {
+  assert.equal(typeof ctx.plum[n], "function", `plum.wasm has no ${n} export`);
+}
+const state = ctx.plum.init();
+ctx.plum.update(state, 0.016);
+ctx.plum.draw(state);
+assert.ok(host.calls.length > 0, "draw made no host calls");
+const loads = host.loaded;
+assert.ok(loads.every((s) => /^[\w .\/-]+$/.test(s)), `garbled Str: ${JSON.stringify(loads)}`);
+console.log(`ok: ${imports.length} plum imports bound, ${host.calls.length} host calls in one frame (loads: ${JSON.stringify(loads)})`);