@barefootjs/rust 0.1.0

package/runtime/tests/query.rs

@@ -0,0 +1,50 @@
+//! `runtime::query` -- ported from
+//! `packages/adapter-jinja/python/tests/test_query.py` (itself a port of
+//! `packages/adapter-perl/t/query.t`).
+//!
+//! The full CROSS-BACKEND behaviour (control flow + form-encoding parity
+//! with the browser's `URLSearchParams`) is defined ONCE in the shared
+//! golden helper vectors and run by `tests/helper_vectors.rs`. This file
+//! keeps a few representative cases for always-on coverage plus a
+//! Rust-runtime-specific defensive case the golden vectors can't express: a
+//! `null` value (JSON has no `undefined`; a JSON `null` stringifies to
+//! `"null"` under JS `String()`, so it can't be a shared vector -- this
+//! runtime coerces `null` to `''` and omits the empty pair, mirroring the
+//! Perl/Python ports' documented `undef`/`None` handling).
+
+use barefootjs::num::JsValue;
+use barefootjs::runtime;
+
+fn s(v: &str) -> JsValue {
+    JsValue::from(v)
+}
+fn b(v: bool) -> JsValue {
+    JsValue::Bool(v)
+}
+
+#[test]
+fn order_preserved_repeated_key_overwrites_at_first_position() {
+    let triples = [b(true), s("sort"), s("title"), b(true), s("tag"), s("go"), b(true), s("sort"), s("date")];
+    assert_eq!(runtime::query(&s("/blog"), &triples), "/blog?sort=date&tag=go");
+}
+
+#[test]
+fn form_encoding_tilde_star_space() {
+    let triples = [b(true), s("t"), s("a~b *c")];
+    assert_eq!(runtime::query(&s("/s"), &triples), "/s?t=a%7Eb+*c");
+}
+
+#[test]
+fn array_value_appends_pair_per_nonempty_member() {
+    let triples = [b(true), s("tag"), JsValue::Array(vec![s("a"), s(""), s("b")])];
+    assert_eq!(runtime::query(&s("/list"), &triples), "/list?tag=a&tag=b");
+}
+
+#[test]
+fn none_value_coerced_to_empty_and_omitted() {
+    let triples = [b(true), s("tag"), JsValue::Null];
+    assert_eq!(runtime::query(&s("/list"), &triples), "/list");
+
+    let triples2 = [b(true), s("tag"), JsValue::Null, b(true), s("keep"), s("me")];
+    assert_eq!(runtime::query(&s("/list"), &triples2), "/list?keep=me");
+}

package/runtime/tests/render_child.rs

@@ -0,0 +1,210 @@
+//! `render_child` renderer-invocation contract, ported from
+//! `packages/adapter-jinja/python/tests/test_render_child.py` (itself a
+//! port of `packages/adapter-perl/t/render_child.t`).
+//!
+//! Renderer contract (#1897): a child's scope/slot identity chains off the
+//! CALLER's `bf` instance (`self` inside `Object::call_method`), not off
+//! whichever instance originally registered the renderer. Unlike the
+//! Python port (which can stub a bare `BarefootJS` instance and call
+//! `render_child` directly with a hand-built backend), this crate's
+//! `render_child` takes a live `&minijinja::State` -- there is no public
+//! way to construct one outside an active render -- so these tests drive
+//! the SAME contract through real `.j2` template renders (mirroring what
+//! `bf-render` does), which is the natural Rust-shaped equivalent and
+//! additionally exercises the actual `Object::call_method` dispatch path.
+
+use barefootjs::num::JsValue;
+use barefootjs::runtime::{js_to_mj, ChildRendererSpec};
+use barefootjs::{backend_minijinja, BfInstance, RenderSession};
+use minijinja::value::Value as MjValue;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+struct TempDir(PathBuf);
+
+impl TempDir {
+    fn new(tag: &str) -> TempDir {
+        let dir = std::env::temp_dir().join(format!("bf-render-child-test-{tag}-{}-{}", std::process::id(), std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()));
+        std::fs::create_dir_all(&dir).unwrap();
+        TempDir(dir)
+    }
+    fn write(&self, name: &str, content: &str) {
+        std::fs::write(self.0.join(name), content).unwrap();
+    }
+}
+
+impl Drop for TempDir {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(&self.0).ok();
+    }
+}
+
+/// `vars` for [`backend_minijinja::render_entry`] (top-level render), which
+/// still takes JSON-shaped `&JsValue`.
+fn no_defaults() -> JsValue {
+    JsValue::Object(BTreeMap::new())
+}
+
+/// `ChildRendererSpec::ssr_defaults`, which is `minijinja::Value` (props
+/// stay `Value` end-to-end through `render_child` -- see its docstring).
+fn no_ssr_defaults() -> MjValue {
+    MjValue::from(BTreeMap::<String, MjValue>::new())
+}
+
+#[test]
+fn nested_render_child_chains_scope_off_the_caller_not_the_registrant() {
+    let dir = TempDir::new("nested");
+    dir.write("root.j2", "{{ bf.render_child('mid', {'_bf_slot': 's0'}) | safe }}");
+    dir.write("mid.j2", "[{{ bf.scope_attr() }}:{{ bf.render_child('leaf', {'_bf_slot': 'inner'}) | safe }}]");
+    dir.write("leaf.j2", "leaf@{{ bf.scope_attr() }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    session.register_child_renderer(
+        "mid".to_string(),
+        ChildRendererSpec { component_name: "Mid".to_string(), template: "mid".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+    session.register_child_renderer(
+        "leaf".to_string(),
+        ChildRendererSpec { component_name: "Leaf".to_string(), template: "leaf".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+
+    let root = BfInstance::root(Arc::clone(&session), "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+
+    // `mid`'s scope is `<root scope>_s0`; `leaf` is rendered from INSIDE
+    // `mid`'s template (where `bf` is the `mid` instance), so its scope
+    // chains off `mid`'s scope (`Root_test_s0_inner`), NOT off the root's
+    // scope directly (`Root_test_inner`) -- proving the caller-chaining
+    // contract.
+    assert_eq!(out, "[Root_test_s0:leaf@Root_test_s0_inner]");
+}
+
+#[test]
+fn missing_renderer_propagates_as_render_error() {
+    let dir = TempDir::new("missing");
+    dir.write("root.j2", "{{ bf.render_child('missing') }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    let root = BfInstance::root(session, "Root_test");
+    let err = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap_err();
+    assert!(err.to_string().contains("No renderer registered for child component 'missing'"), "unexpected error: {err}");
+}
+
+#[test]
+fn reserved_word_prop_is_mangled() {
+    let dir = TempDir::new("reserved");
+    dir.write("root.j2", "{{ bf.render_child('kw', {'class': 'x', 'id': 'y'}) }}");
+    dir.write("kw.j2", "{{ class_ }}-{{ id }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    session.register_child_renderer(
+        "kw".to_string(),
+        ChildRendererSpec { component_name: "Kw".to_string(), template: "kw".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    assert_eq!(out, "x-y");
+}
+
+#[test]
+fn rest_bag_routing_and_ssr_defaults_merge() {
+    let dir = TempDir::new("restbag");
+    // `Card` declares `title` as a named param and destructures the rest
+    // into `rest`; `subtitle` isn't a declared param, so it must land in
+    // `rest`, not as a top-level stash var.
+    dir.write("root.j2", "{{ bf.render_child('card', {'title': 'Hi', 'subtitle': 'Sub', 'extra': 'E'}) }}");
+    dir.write("card.j2", "{{ title }}|{{ rest.subtitle }}|{{ rest.extra }}|{{ theme }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    let mut defaults = BTreeMap::new();
+    defaults.insert("theme".to_string(), JsValue::from("dark"));
+    session.register_child_renderer(
+        "card".to_string(),
+        ChildRendererSpec {
+            component_name: "Card".to_string(),
+            template: "card".to_string(),
+            ssr_defaults: js_to_mj(&JsValue::Object(defaults)),
+            rest_props_name: Some("rest".to_string()),
+            param_names: vec!["title".to_string()],
+        },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    assert_eq!(out, "Hi|Sub|E|dark");
+}
+
+#[test]
+fn loop_child_without_slot_gets_a_fresh_component_prefixed_scope() {
+    let dir = TempDir::new("loopchild");
+    dir.write("root.j2", "{{ bf.render_child('item', {}) }}|{{ bf.render_child('item', {}) }}");
+    dir.write("item.j2", "{{ bf.scope_attr() }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    session.register_child_renderer(
+        "item".to_string(),
+        ChildRendererSpec { component_name: "Item".to_string(), template: "item".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    let parts: Vec<&str> = out.split('|').collect();
+    assert_eq!(parts.len(), 2);
+    for p in &parts {
+        assert!(p.starts_with("Item_"), "expected an Item_<rand> scope id, got {p:?}");
+    }
+    assert_ne!(parts[0], parts[1], "two loop-child renders must get distinct scope ids");
+}
+
+#[test]
+fn childless_invocation_renders_with_no_props() {
+    let dir = TempDir::new("childless");
+    dir.write("root.j2", "{{ bf.render_child('leaf') }}");
+    dir.write("leaf.j2", "leaf-ok");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    session.register_child_renderer(
+        "leaf".to_string(),
+        ChildRendererSpec { component_name: "Leaf".to_string(), template: "leaf".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    assert_eq!(out, "leaf-ok");
+}
+
+#[test]
+fn children_safe_value_survives_render_child_and_bf_string_unescaped() {
+    // Regression for the "children lost their safe flag" bug: a JSX
+    // children capture (`{% set cap %}...{% endset %}`, mirroring what the
+    // TS emitter generates for children forwarding) is a SAFE `Value`.
+    // Passed as a child prop through `bf.string(...)` (as the emitter does
+    // at every text/attribute-position value) and through
+    // `bf.render_child`'s prop plumbing, it must reach the child template
+    // STILL safe -- i.e. NOT HTML-escaped -- proving both fixes: (1)
+    // `render_child` keeps props as `Value` end-to-end instead of
+    // round-tripping through `JsValue` (which has no safe/unsafe
+    // distinction), and (2) `bf.string` passes an already-safe string
+    // input through unchanged (mirrors the Python runtime's `js_string`,
+    // where a `str` input -- including a `Markup` -- is returned as-is).
+    let dir = TempDir::new("safechildren");
+    dir.write(
+        "root.j2",
+        "{% set cap %}<span>hi</span>{% endset %}{{ bf.render_child('wrap', {'inner': bf.string(cap)}) | safe }}",
+    );
+    dir.write("wrap.j2", "[{{ inner }}]");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    session.register_child_renderer(
+        "wrap".to_string(),
+        ChildRendererSpec { component_name: "Wrap".to_string(), template: "wrap".to_string(), ssr_defaults: no_ssr_defaults(), rest_props_name: None, param_names: vec![] },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    assert_eq!(out, "[<span>hi</span>]");
+}

package/runtime/tests/search_params.rs

@@ -0,0 +1,68 @@
+//! `barefootjs::SearchParams` -- Rust-specific concerns, ported from
+//! `packages/adapter-jinja/python/tests/test_search_params.py` (itself a
+//! port of `packages/adapter-perl/t/search_params.t`).
+//!
+//! The cross-language VALUE semantics of `get` are owned by the
+//! language-independent golden vectors (`search_params_get` in
+//! `tests/helper_vectors.rs`), so Go/Perl/Python/Rust parity there is
+//! mechanical. This file covers only what those value vectors can't: the
+//! constructor seam, lenient parsing (never panics), and UTF-8 decoding.
+//! (Mirrors `src/search_params.rs`'s inline `#[cfg(test)]` module -- kept
+//! as its own top-level file too, per the design doc's file layout, since
+//! it is the direct structural port of the Python test module.)
+
+use barefootjs::SearchParams;
+
+#[test]
+fn constructor_and_get() {
+    let sp = SearchParams::new("sort=price");
+    assert_eq!(sp.get("sort"), Some("price"));
+    assert_eq!(SearchParams::new("").get("sort"), None);
+}
+
+#[test]
+fn none_composition_coalesces_only_none() {
+    // The adapters lower `searchParams().get(k) ?? d` to a minijinja
+    // expression that coalesces only an absent key (not a bare `or`,
+    // which would also default a present-but-empty value) -- so an
+    // absent key falls back to the author's default while a
+    // present-but-empty value keeps ''.
+    let absent = SearchParams::new("other=x");
+    assert_eq!(absent.get("sort").unwrap_or("none"), "none");
+
+    let empty = SearchParams::new("sort=");
+    assert_eq!(empty.get("sort").unwrap_or("none"), "");
+}
+
+#[test]
+fn utf8_percent_decoding() {
+    let sp = SearchParams::new("q=%E2%9C%93");
+    assert_eq!(sp.get("q"), Some("\u{2713}"));
+}
+
+#[test]
+fn lenient_parsing_never_panics() {
+    let _ = SearchParams::new("");
+    assert_eq!(SearchParams::new("&&&").get("x"), None);
+    assert_eq!(SearchParams::new("=novalue").get("x"), None);
+}
+
+#[test]
+fn to_value_exposes_get_method_to_templates() {
+    // Smoke-test the `minijinja::value::Object` wiring end-to-end via a
+    // real template render (`bf-render`'s own path), rather than only unit
+    // testing `SearchParams::get` directly.
+    let dir = std::env::temp_dir().join(format!("bf-search-params-test-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("t.j2"), "{{ searchParams.get('sort') }}|{{ (searchParams.get('missing') if (searchParams.get('missing') is defined and searchParams.get('missing') is not none) else 'default') }}").unwrap();
+
+    let env = barefootjs::backend_minijinja::build_environment(&dir);
+    let session = barefootjs::RenderSession::new();
+    let root = barefootjs::BfInstance::root(session, "test");
+    let vars = barefootjs::num::JsValue::Object(Default::default());
+    let extra = vec![("searchParams".to_string(), SearchParams::new("sort=price").to_value())];
+    let out = barefootjs::backend_minijinja::render_entry(&env, "t", root.as_mj_value(), &vars, &extra).unwrap();
+    assert_eq!(out, "price|default");
+
+    std::fs::remove_dir_all(&dir).ok();
+}

package/runtime/tests/spread_attrs.rs

@@ -0,0 +1,94 @@
+//! `runtime::spread_attrs` -- ported from
+//! `packages/adapter-jinja/python/tests/test_spread_attrs.py` (itself a
+//! port of `packages/adapter-perl/t/spread_attrs.t`).
+//!
+//! JSX intrinsic-element spread runtime helper (#1407 follow-up). Mirrors
+//! the JS `spreadAttrs` runtime and the Go/Perl/Python adapters'
+//! equivalents so SSR output stays byte-equal across every adapter --
+//! cross-adapter parity regressions surface here first.
+
+use barefootjs::num::JsValue;
+use barefootjs::runtime;
+use std::collections::BTreeMap;
+
+fn obj(pairs: &[(&str, JsValue)]) -> JsValue {
+    JsValue::Object(pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect::<BTreeMap<_, _>>())
+}
+
+fn s(v: &str) -> JsValue {
+    JsValue::from(v)
+}
+
+fn run(bag: &JsValue) -> String {
+    runtime::spread_attrs(bag)
+}
+
+#[test]
+fn basic_shapes() {
+    assert_eq!(run(&JsValue::Null), "");
+    assert_eq!(run(&obj(&[])), "");
+    assert_eq!(run(&s("not a hash")), "");
+    assert_eq!(run(&obj(&[("id", s("a"))])), "id=\"a\"");
+}
+
+#[test]
+fn alphabetic_key_order() {
+    assert_eq!(run(&obj(&[("id", s("a")), ("class", s("on"))])), "class=\"on\" id=\"a\"");
+}
+
+#[test]
+fn key_remapping() {
+    assert_eq!(run(&obj(&[("className", s("foo"))])), "class=\"foo\"");
+    assert_eq!(run(&obj(&[("htmlFor", s("x"))])), "for=\"x\"");
+    assert_eq!(run(&obj(&[("dataPriority", s("high"))])), "data-priority=\"high\"");
+    // SVG XML attrs are case-sensitive -- preserve verbatim.
+    assert_eq!(run(&obj(&[("viewBox", s("0 0 10 10"))])), "viewBox=\"0 0 10 10\"");
+    assert_eq!(run(&obj(&[("clipPathUnits", s("userSpaceOnUse"))])), "clipPathUnits=\"userSpaceOnUse\"");
+    // JS-reference parity (#1411): a leading uppercase letter emits a
+    // leading dash.
+    assert_eq!(run(&obj(&[("XData", s("x"))])), "-x-data=\"x\"");
+}
+
+#[test]
+fn event_handlers_js_predicate_parity() {
+    assert_eq!(run(&obj(&[("onClick", s("fn")), ("id", s("a"))])), "id=\"a\"");
+    assert_eq!(run(&obj(&[("on_custom", s("fn")), ("id", s("a"))])), "id=\"a\"");
+    assert_eq!(run(&obj(&[("on0", s("fn")), ("id", s("a"))])), "id=\"a\"");
+    assert_eq!(run(&obj(&[("oncology", s("x"))])), "oncology=\"x\"");
+}
+
+#[test]
+fn children_skipped_ref_passed_through() {
+    assert_eq!(run(&obj(&[("children", s("x")), ("id", s("a"))])), "id=\"a\"");
+    // JS `spreadAttrs` does NOT filter `ref` (`applyRestAttrs` does --
+    // that's a separate divergence).
+    assert_eq!(run(&obj(&[("ref", s("x")), ("id", s("a"))])), "id=\"a\" ref=\"x\"");
+}
+
+#[test]
+fn boolean_values() {
+    assert_eq!(run(&obj(&[("hidden", JsValue::Bool(true)), ("id", s("a"))])), "hidden id=\"a\"");
+    assert_eq!(run(&obj(&[("hidden", JsValue::Bool(false)), ("id", s("a"))])), "id=\"a\"");
+    // Plain numeric 0 renders as a value (matches `tabindex="0"`).
+    assert_eq!(run(&obj(&[("tabindex", JsValue::Number(0.0))])), "tabindex=\"0\"");
+}
+
+#[test]
+fn nullish_skip() {
+    assert_eq!(run(&obj(&[("a", JsValue::Null), ("b", s("x"))])), "b=\"x\"");
+}
+
+#[test]
+fn html_escape() {
+    assert_eq!(run(&obj(&[("title", s("<b>\"x\"</b>"))])), "title=\"&lt;b&gt;&#34;x&#34;&lt;/b&gt;\"");
+    assert_eq!(run(&obj(&[("alt", s("tom & jerry"))])), "alt=\"tom &amp; jerry\"");
+}
+
+#[test]
+fn style_object_lowering() {
+    assert_eq!(
+        run(&obj(&[("style", obj(&[("backgroundColor", s("red")), ("color", s("white"))]))])),
+        "style=\"background-color:red;color:white\""
+    );
+    assert_eq!(run(&obj(&[("style", s("color:red"))])), "style=\"color:red\"");
+}