@barefootjs/mojolicious 0.5.1 → 0.5.2

package/src/__tests__/mojo-adapter.test.ts

@@ -69,19 +69,16 @@ runAdapterConformanceTests({
     'toggle-shared',
     'reactive-props',
     'props-reactivity-comparison',
-    // #1665 whole-item loop conditional. The Mojo adapter correctly emits the
-    // per-item `<!--bf-loop-i:KEY-->` anchor, `data-key`, and the conditional
-    // markers (verified by template-structure tests), but the fixture's
-    // `sel() === t.id` string comparison lowers to Perl numeric `==`
-    // (`"b" == "a"` → `0 == 0` → true), so the perl-executed render renders
-    // every item's true branch instead of only the matching one. Selecting
-    // `eq` vs `==` from operand types is a separate pre-existing Mojo
-    // limitation (same family as the skipped `logical-or-jsx` /
-    // `nullish-coalescing-jsx` map shapes); the anchored SSR shape itself is
-    // covered cross-adapter by Hono + CSR conformance and the runtime
-    // hydration tests. Remove this skip once the Mojo limitation is fixed:
-    // https://github.com/piconic-ai/barefootjs/issues/1672
-    'loop-item-conditional',
+    // #1467 Phase 2a: first `site/ui` source-root fixture. Button
+    // compiles cleanly on the Mojo adapter (no diagnostic), but its
+    // variant/size class composition (`Record<…>[key]` indexed object
+    // literals) and `applyRestAttrs` spread haven't been validated for
+    // byte-parity against the Hono reference under Mojo's template
+    // semantics. Cross-adapter parity for the `site/ui` corpus is
+    // explicitly Phase 3 ("cross-adapter parity (Mojo/Go templates)"),
+    // so Button participates only in Hono SSR conformance + the
+    // fixture-hydrate runtime layer for now.
+    'button',
   ],
   // Per-fixture build-time contracts for shapes the Mojo adapter
   // intentionally refuses to lower. Owned by this adapter test file
@@ -289,6 +286,40 @@ export function List() {
     expect(result.template).toMatch(/bf->comment\("\/loop:[^"]+"\)/)
   })
 
+  test('compares string signals with Perl `eq`, not numeric `==` (#1672)', () => {
+    // `sel() === t.id` where `sel` is a string signal must lower to `eq`.
+    // Perl numeric `==` coerces non-numeric strings to 0, so `"b" == "a"` is
+    // true and every loop item would render its true branch.
+    const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function LoopItemConditional() {
+  const [items] = createSignal([{ id: "a" }, { id: "b" }, { id: "c" }])
+  const [sel] = createSignal("b")
+  return <ul>{items().map(t => sel() === t.id && <li key={t.id}>{t.id}</li>)}</ul>
+}
+`)
+    expect(result.template).toContain('$sel eq $t->{id}')
+    expect(result.template).not.toContain('$sel == $t->{id}')
+  })
+
+  test('compares number signals with Perl `==` (#1672)', () => {
+    // A numeric signal comparison must stay `==`, not flip to `eq`.
+    const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function L() {
+  const [items] = createSignal([{ n: 1 }, { n: 2 }])
+  const [sel] = createSignal(2)
+  return <ul>{items().map(t => sel() === t.n && <li key={t.n}>{t.n}</li>)}</ul>
+}
+`)
+    expect(result.template).toContain('$sel == $t->{n}')
+    expect(result.template).not.toContain('$sel eq $t->{n}')
+  })
+
   test('generates script registration for client components', () => {
     const result = compileAndGenerate(`
 "use client"
@@ -979,17 +1010,19 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
 // Mojo sibling of the Go block: #1448 documents `/* @client */` as the
 // universal workaround for any Array/String method the template
 // adapters can't lower. This pins that contract for the Mojo adapter —
-// wrapping the unsupported expression in the directive must clear the
-// BF021/BF101 build error the bare form raises and emit a client-only
-// placeholder so the Mojo SSR pass renders valid `.html.ep` that the
-// client runtime fills at hydration.
+// the BARE form must surface a BF021/BF101 build error, and wrapping
+// the expression in the directive must clear it and emit a client-only
+// placeholder so the Mojo SSR pass renders valid `.html.ep` the client
+// runtime fills at hydration.
 //
-// Same silent-footgun caveat as Go: the unsupported *string* methods
-// raise NO build diagnostic — bare `.startsWith` / `.repeat` / … lower
-// to a Perl hash-deref-and-call (`$name->{startsWith}('a')`) that
-// passes the adapter gate, then dies at render with
-// `Can't use string (...) as a HASH ref while "strict refs"`.
-// `/* @client */` is the only escape hatch, so these tests pin it.
+// History (#1448 follow-up): the unsupported *string* methods used to
+// raise NO build diagnostic — bare `.startsWith` / `.repeat` / … fell
+// into the regex pipeline and lowered to a Perl hash-deref-and-call
+// (`$name->{startsWith}('a')`) that passed the gate, then died at
+// render with `Can't use string (...) as a HASH ref while "strict
+// refs"`. They are now routed through the AST path in
+// `convertExpressionToPerl` so `isSupported`'s `UNSUPPORTED_METHODS`
+// gate fires BF101 — parity with the Go adapter. These tests pin it.
 describe('MojoAdapter - #1448 @client escape hatch (unsupported methods)', () => {
   function emit(expr: string, client: boolean) {
     const marker = client ? '/* @client */ ' : ''
@@ -1023,49 +1056,85 @@ export function C() {
     return { errors: adapter.errors ?? [], template }
   }
 
-  // Tier C array methods — bare form raises BF101 at build time.
-  const unsupportedArray: Array<[string, string]> = [
-    ['reduce', `items().reduce((a, b) => a + b.n, 0)`],
-    ['flatMap', `items().flatMap(i => i.tags)`],
-    ['flat', `items().flat()`],
+  // Unsupported methods that surface as BF101 at build time: Tier C
+  // array methods + Tier B/C string methods. `badEmit` is the invalid
+  // Perl fragment that must NOT survive into the template (the pre-fix
+  // silent-footgun output for the string rows).
+  const unsupported: Array<{ name: string; expr: string; badEmit: string }> = [
+    // Tier C array methods.
+    { name: 'reduce', expr: `items().reduce((a, b) => a + b.n, 0)`, badEmit: '->{reduce}' },
+    { name: 'flatMap', expr: `items().flatMap(i => i.tags)`, badEmit: '->{flatMap}' },
+    { name: 'flat', expr: `items().flat()`, badEmit: '->{flat}' },
+    // Tier B/C string methods — previously slipped through with no
+    // diagnostic; now routed through the AST / `isSupported` gate.
+    { name: 'split', expr: `name().split(",")`, badEmit: '->{split}' },
+    { name: 'startsWith', expr: `name().startsWith("a")`, badEmit: '->{startsWith}' },
+    { name: 'endsWith', expr: `name().endsWith("z")`, badEmit: '->{endsWith}' },
+    { name: 'replace', expr: `name().replace("a", "b")`, badEmit: '->{replace}' },
+    { name: 'repeat', expr: `name().repeat(3)`, badEmit: '->{repeat}' },
+    { name: 'padStart', expr: `name().padStart(5, "0")`, badEmit: '->{padStart}' },
+    { name: 'padEnd', expr: `name().padEnd(5, "0")`, badEmit: '->{padEnd}' },
+    { name: 'charAt', expr: `name().charAt(0)`, badEmit: '->{charAt}' },
   ]
-  for (const [name, expr] of unsupportedArray) {
-    test(`array .${name}: bare raises BF101, @client clears it + emits client placeholder`, () => {
+  for (const { name, expr, badEmit } of unsupported) {
+    test(`.${name}: bare raises BF101, @client clears it + emits client placeholder`, () => {
       const bare = emit(expr, false)
       expect(bare.errors.some(e => e.code === 'BF101')).toBe(true)
+      // The invalid deref-and-call must NOT leak into the template;
+      // the adapter degrades to a safe empty slot alongside the error.
+      expect(bare.template).not.toContain(badEmit)
 
       const guarded = emit(expr, true)
       expect(guarded.errors).toEqual([])
       // Client-only text slot → `<%== bf->comment("client:sN") %>`.
       expect(guarded.template).toMatch(/bf->comment\("client:s\d+"\)/)
+      expect(guarded.template).not.toContain(badEmit)
     })
   }
 
-  // Tier B/C string methods — bare form emits an INVALID Perl
-  // hash-deref-and-call with NO build error (the silent footgun).
-  const unsupportedString: Array<[string, string, string]> = [
-    ['split', `name().split(",")`, '->{split}'],
-    ['startsWith', `name().startsWith("a")`, '->{startsWith}'],
-    ['endsWith', `name().endsWith("z")`, '->{endsWith}'],
-    ['replace', `name().replace("a", "b")`, '->{replace}'],
-    ['repeat', `name().repeat(3)`, '->{repeat}'],
-    ['padStart', `name().padStart(5, "0")`, '->{padStart}'],
-    ['padEnd', `name().padEnd(5, "0")`, '->{padEnd}'],
-    ['charAt', `name().charAt(0)`, '->{charAt}'],
-  ]
-  for (const [name, expr, badEmit] of unsupportedString) {
-    test(`string .${name}: bare emits invalid Perl deref, @client emits client placeholder`, () => {
-      const bare = emit(expr, false)
-      // Documents the footgun: no BF101 guard, invalid template emitted.
-      expect(bare.errors.filter(e => e.code === 'BF101')).toEqual([])
-      expect(bare.template).toContain(badEmit)
+  // Routing guard regression: the unsupported-string-method regex is an
+  // unanchored substring test, and these names (`replace`, `split`, …)
+  // are ordinary words that also appear inside string literals. A
+  // SUPPORTED expression whose literal merely contains `.replace(` must
+  // NOT be diverted onto the AST path — doing so would bypass
+  // `rewriteTemplatePrimitives` and silently emit broken Perl
+  // (`$JSON->{stringify} + '.replace('`). The `isSupported` gate on the
+  // regex keeps such expressions on the normal pipeline.
+  test('string-method regex does not misroute a supported expr with a method name inside a literal', () => {
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C(props: { config: string }) {
+  return <div>{JSON.stringify(props.config) + ".replace("}</div>
+}
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    expect(adapter.errors ?? []).toEqual([])
+    // templatePrimitive lowering preserved...
+    expect(template).toContain('bf->json($config)')
+    // ...and the literal is NOT mangled into a hash-deref.
+    expect(template).not.toContain('$JSON->{stringify}')
+  })
 
-      const guarded = emit(expr, true)
-      expect(guarded.errors).toEqual([])
-      expect(guarded.template).toMatch(/bf->comment\("client:s\d+"\)/)
-      expect(guarded.template).not.toContain(badEmit)
-    })
-  }
+  // Predicate-level use of an unsupported string method also fails the
+  // build loudly (intended): a `.filter(t => t.name.startsWith("a"))`
+  // whose predicate calls one of the gated methods now refuses the whole
+  // loop with BF101 (via the shared `isSupported` predicate gate in
+  // jsx-to-ir) rather than lowering to a broken `->{startsWith}` inside
+  // the grep. Pinning this so the loud-failure contract can't silently
+  // regress back to the old emit-broken-template behaviour.
+  test('unsupported string method inside a .filter() predicate raises BF101', () => {
+    const result = compileJSX(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string }[]>([])
+  return <ul>{items().filter(t => t.name.startsWith("a")).map(t => <li key={t.name}>{t.name}</li>)}</ul>
+}
+`.trimStart(), 'test.tsx', { adapter: new MojoAdapter() })
+    expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+  })
 
   // Tier B `.sort` / `.toSorted` follow-ups still refused with BF021.
   // The Mojo client-only loop placeholder is an empty element (the
@@ -1097,23 +1166,25 @@ export function C() {
     })
   }
 
-  // End-to-end proof via perl + Mojolicious: the bare unsupported form
-  // crashes Mojo template execution, while the `@client` form renders a
-  // `<!--bf-client:sN-->` placeholder. Skipped on hosts without
-  // Mojolicious installed.
-  test('e2e: bare string method crashes perl render, @client renders placeholder', async () => {
-    const guarded = `
+  // End-to-end proof via perl + Mojolicious: the `@client` form renders
+  // a `<!--bf-client:sN-->` placeholder. The bare form is now caught at
+  // build with BF101 and degrades to an empty, render-safe slot (no
+  // more `HASH ref` crash), so we assert the build error rather than a
+  // render crash. Skipped on hosts without Mojolicious installed.
+  test('e2e: @client renders placeholder; bare is caught at build with BF101', async () => {
+    const bare = emit(`name().repeat(3)`, false)
+    expect(bare.errors.some(e => e.code === 'BF101')).toBe(true)
+
+    try {
+      const html = await renderMojoComponent({
+        source: `
 "use client"
 import { createSignal } from "@barefootjs/client"
 export function C() {
   const [name, setName] = createSignal("hello")
   return <div>{/* @client */ name().repeat(3)}</div>
 }
-`
-    const bareSrc = guarded.replace('/* @client */ ', '')
-    try {
-      const html = await renderMojoComponent({
-        source: guarded.trimStart(),
+`.trimStart(),
         adapter: new MojoAdapter(),
       })
       expect(html).toContain('<!--bf-client:s0-->')
@@ -1124,12 +1195,58 @@ export function C() {
       }
       throw err
     }
-    // Bare form must fail Mojo template execution (no @client guard).
-    await expect(
-      renderMojoComponent({
-        source: bareSrc.trimStart(),
-        adapter: new MojoAdapter(),
-      }),
-    ).rejects.toThrow(/HASH ref/)
+  })
+})
+
+// =============================================================================
+// #1682: parse-first expression lowering regressions
+// =============================================================================
+// The parse-first refactor routes every supported expression through the
+// AST emitter. These pin the four behaviours the Copilot review surfaced
+// so they can't silently regress.
+describe('MojoAdapter - #1682 parse-first lowering', () => {
+  function gen(inner: string) {
+    const adapter = new MojoAdapter()
+    const out = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [role, setRole] = createSignal("admin")
+  const [count, setCount] = createSignal(1)
+  const [obj, setObj] = createSignal({ a: 1 })
+  const [it, setIt] = createSignal("x")
+  return <div>{${inner}}</div>
+}
+`, adapter)
+    return { template: out.template ?? '', errors: adapter.errors ?? [] }
+  }
+
+  test('string === lowers to Perl eq with the literal on EITHER operand', () => {
+    // Reversed literal (`"admin" === role()`) must still use string `eq`,
+    // not numeric `==` (which coerces both sides to 0 in Perl).
+    const { template } = gen('"admin" === role() ? "A" : "B"')
+    expect(template).toContain("'admin' eq $role")
+    expect(template).not.toContain("'admin' ==")
+    expect(template).not.toContain("== 'admin'")
+  })
+
+  test('template literal with a complex expr lowers to Perl concatenation', () => {
+    // Double-quote interpolation would leave `+ 1` unevaluated; concat
+    // (with parens for precedence) evaluates the arithmetic.
+    const { template } = gen('`n=${count() + 1}`')
+    expect(template).toContain('"n=" . ($count + 1)')
+  })
+
+  test('static template-literal text escapes Perl $ and @ sigils', () => {
+    const { template } = gen('`Price: $${it()} @user`')
+    expect(template).toContain('\\$')
+    expect(template).toContain('\\@user')
+  })
+
+  test('wrong-arity templatePrimitive records BF101 and emits no hash-deref', () => {
+    const { template, errors } = gen('JSON.stringify(obj(), null)')
+    expect(errors.some(e => e.code === 'BF101')).toBe(true)
+    // The invalid `$JSON->{stringify}` hash-deref must NOT leak out.
+    expect(template).not.toContain('$JSON->{stringify}')
   })
 })