@barefootjs/mojolicious 0.5.0 → 0.5.2

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

@@ -69,6 +69,16 @@ runAdapterConformanceTests({
     'toggle-shared',
     'reactive-props',
     'props-reactivity-comparison',
+    // #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
@@ -276,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"
@@ -958,3 +1002,251 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     })
   }
 })
+
+// =============================================================================
+// #1448 — `/* @client */` escape hatch for STILL-UNSUPPORTED methods
+// =============================================================================
+//
+// 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 —
+// 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.
+//
+// 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 */ ' : ''
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number; tags: string[] }[]>([])
+  const [name, setName] = createSignal("x")
+  return <div>{${marker}${expr}}</div>
+}
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    return { errors: adapter.errors ?? [], template }
+  }
+
+  function emitLoop(chain: string, client: boolean) {
+    const marker = client ? '/* @client */ ' : ''
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number }[]>([])
+  const myCmp = (a: { n: number }, b: { n: number }) => a.n - b.n
+  return <ul>{${marker}${chain}}</ul>
+}
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    return { errors: adapter.errors ?? [], template }
+  }
+
+  // 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, 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)
+    })
+  }
+
+  // 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}')
+  })
+
+  // 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
+  // client runtime repopulates it via the `bf-s` scope marker), so the
+  // contract here is: no errors + the comparator never lowers + no
+  // rendered `<li>` survives.
+  const unsupportedSort: Array<[string, string]> = [
+    ['function-reference comparator', `items().toSorted(myCmp).map(x => <li key={x.name}>{x.name}</li>)`],
+    ['localeCompare locale/options arg', `items().toSorted((a, b) => a.name.localeCompare(b.name, "ja", { numeric: true })).map(x => <li key={x.name}>{x.name}</li>)`],
+  ]
+  for (const [label, chain] of unsupportedSort) {
+    test(`sort follow-up (${label}): bare raises BF021, @client clears it`, () => {
+      const bare = compileJSX(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+export function C() {
+  const [items, setItems] = createSignal<{ name: string; n: number }[]>([])
+  const myCmp = (a: { n: number }, b: { n: number }) => a.n - b.n
+  return <ul>{${chain}}</ul>
+}
+`.trimStart(), 'test.tsx', { adapter: new MojoAdapter() })
+      expect(bare.errors?.some(e => e.code === 'BF021')).toBe(true)
+
+      const guarded = emitLoop(chain, true)
+      expect(guarded.errors).toEqual([])
+      // Empty client-only loop placeholder — no item rows emitted SSR.
+      expect(guarded.template).not.toContain('<li')
+      expect(guarded.template).not.toContain('localeCompare')
+    })
+  }
+
+  // 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>
+}
+`.trimStart(),
+        adapter: new MojoAdapter(),
+      })
+      expect(html).toContain('<!--bf-client:s0-->')
+    } catch (err) {
+      if (err instanceof PerlNotAvailableError) {
+        console.log('Skipping #1448 @client e2e: perl/Mojolicious not found')
+        return
+      }
+      throw err
+    }
+  })
+})
+
+// =============================================================================
+// #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}')
+  })
+})