@barefootjs/erb 0.18.0 → 0.18.2

package/README.md

@@ -0,0 +1,32 @@
+# barefoot_js
+
+Ruby runtime for [BarefootJS](https://barefootjs.dev/) marked templates, targeting ERB.
+
+[BarefootJS](https://github.com/piconic-ai/barefootjs) is a fine-grained reactive TSX compiler: you write components in TSX, and the compiler emits templates for your backend's template engine plus the client-side JS that hydrates them. This gem is the server half for Ruby — it renders the `.erb` templates produced by the `@barefootjs/erb` adapter.
+
+## Installation
+
+```sh
+gem install barefoot_js
+```
+
+## Usage
+
+Every compiled `.erb` template receives a `BarefootJS::Context` as the `bf` local. The context is engine-agnostic; everything that depends on how a template is rendered is delegated to a pluggable backend (`BarefootJS::Backend::Erb` is the ERB reference implementation):
+
+```ruby
+require 'barefoot_js'
+
+bf = BarefootJS::Context.new(backend)
+```
+
+Values are JSON-shaped Ruby data with symbol hash keys throughout (props, env hashes, array-of-hash records).
+
+## Documentation
+
+- [barefootjs.dev](https://barefootjs.dev/) — core documentation
+- [GitHub: piconic-ai/barefootjs](https://github.com/piconic-ai/barefootjs) — monorepo (this gem lives at `packages/adapter-erb`)
+
+## License
+
+MIT

package/dist/conformance-pins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eAsF7B,CAAA"}
+{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eAiG7B,CAAA"}

package/dist/index.d.ts

@@ -6,4 +6,5 @@
 export { ErbAdapter, erbAdapter } from './adapter/index.ts';
 export type { ErbAdapterOptions } from './adapter/index.ts';
 export { conformancePins } from './conformance-pins.ts';
+export { renderDivergences } from './render-divergences.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC3D,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC3D,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/index.js

@@ -189163,9 +189163,28 @@ var conformancePins = {
   "filter-nested-find-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
-  "array-map-function-reference": [{ code: "BF101", severity: "error" }]
+  "array-map-function-reference": [{ code: "BF101", severity: "error" }],
+  "dangerous-inner-html": [{ code: "BF101", severity: "error" }],
+  "string-replaceall": [{ code: "BF101", severity: "error" }]
+};
+// src/render-divergences.ts
+var renderDivergences = {
+  "falsy-text-values": '`{false}` renders "false" (Hono drops it); `{null}`/`{undefined}` render empty (Hono renders "null") — neither side matches JSX semantics',
+  "html-entity-text": "`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes",
+  "optional-chaining-prop": "`user?.name ?? …` on an object prop: the Ruby render exits 1 (optional chaining into a Hash prop has no lowering)",
+  "math-methods": "Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)",
+  "boolean-attr-literals": 'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
+  "camelcase-attributes": "`htmlFor` is not lowered to `for` (Hono maps it)",
+  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
+  "svg-icon": "SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case",
+  "object-entries-map": "`Object.entries(prop).map(([k, v]) => …)` renders but its loop item keys diverge from the reference serialisation",
+  "nested-loop-outer-binding": "nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`",
+  "jsx-element-prop": "a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped",
+  "string-slice": '`.slice()` on a STRING lowers through the array slice helper and renders "[]" instead of the substring',
+  "string-trim-sided": "`.trimStart()` / `.trimEnd()` render empty (no lowering; only both-sides `.trim` is wired)"
 };
 export {
+  renderDivergences,
   erbAdapter,
   conformancePins,
   ErbAdapter

package/dist/render-divergences.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Render-level divergences against the shared conformance corpus
+ * (Priority-12 edge-case sweep, #2168): fixtures that COMPILE clean on
+ * this adapter but whose rendered output diverges from the Hono
+ * reference on real Ruby erb (or fails at render time).
+ *
+ * Consumed by this package's conformance test (its `skipJsx` set is
+ * derived from these keys, so the skip list and this declaration can't
+ * drift) and by `packages/compat`, which publishes the entries in the
+ * fixture-divergences section of `ui/compat.lock.json` — surfaced on
+ * the docs compatibility-matrix page. Graduating an entry means fixing
+ * the adapter (or the shared compiler layer) and deleting the line.
+ */
+import type { RenderDivergences } from '@barefootjs/jsx';
+export declare const renderDivergences: RenderDivergences;
+//# sourceMappingURL=render-divergences.d.ts.map

package/dist/render-divergences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBA2B/B,CAAA"}

package/lib/barefoot_js.rb

@@ -324,7 +324,15 @@ module BarefootJS
           extra[name] = props.key?(name) ? props[name] : d[:value]
           next
         end
-        prop_name = d[:propName]
+        # `propName` rides in from the JSON manifest as a String -- JSON has
+        # no symbol type, and the manifest's `symbolize_names: true` parse
+        # only symbolizes hash KEYS, never string values. Runtime prop
+        # hashes, meanwhile, are symbol-keyed because compiled ERB templates
+        # pass `{ children: ... }` literals, so `props.key?(prop_name)` with
+        # the String would always miss, silently falling back to the static
+        # default for every manifest-registered child (e.g. `children`
+        # rendering empty) (#2157).
+        prop_name = d[:propName]&.to_sym
         extra[name] =
           if !prop_name.nil? && props.key?(prop_name) && !props[prop_name].nil?
             props[prop_name]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/erb",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "ERB (Embedded Ruby) adapter for BarefootJS — compiles IR to .erb templates and ships the Ruby rendering backend; runs under any Rack app (Sinatra, Rails)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,14 +54,14 @@
     "directory": "packages/adapter-erb"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.18.0"
+    "@barefootjs/shared": "0.18.2"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.0",
+    "@barefootjs/jsx": "0.18.2",
     "typescript": "^5.0.0"
   }
 }

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

@@ -26,11 +26,19 @@ import { ErbAdapter } from '../adapter'
 import { renderErbComponent, ErbNotAvailableError } from '../test-render'
 import { compileJSX, type ComponentIR } from '@barefootjs/jsx'
 import { conformancePins } from '../conformance-pins'
+import { renderDivergences } from '../render-divergences'
 
 runAdapterConformanceTests({
   name: 'erb',
   factory: () => new ErbAdapter(),
   render: renderErbComponent,
+  // Priority-12 edge-case sweep (炙り出し, #2168): render-level
+  // divergences are declared in `../render-divergences` (exported from the
+  // package index and published to `ui/compat.lock.json` / the docs
+  // compatibility-matrix page by `packages/compat`). Deriving the skip
+  // list from that object keeps the public declaration and these test
+  // skips from drifting; each entry's rationale lives there.
+  skipJsx: Object.keys(renderDivergences),
   // No JSX-render skips: every shared conformance fixture — including
   // the composed `site/ui` demo corpus (#1467 / #1897) — renders to
   // Hono parity on real Ruby `erb`. `data-table` came off via the

package/src/conformance-pins.ts

@@ -97,4 +97,15 @@ export const conformancePins: ConformancePins = {
   // with BF101 rather than emitting a broken template. Same pin as
   // mojo/xslate.
   'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
+  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
+  // deliberate raw-HTML (unescaped) output affordance in the target
+  // template language. No lowering exists yet, so the compiler refuses
+  // the shape loudly instead of emitting entity-escaped markup that
+  // silently renders tags as text.
+  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
+  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
+  // only first-occurrence `.replace` is wired to the runtime helpers.
+  // Refused with BF101 rather than reusing the first-only lowering,
+  // which would silently change semantics.
+  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
 }

package/src/index.ts

@@ -7,3 +7,4 @@
 export { ErbAdapter, erbAdapter } from './adapter/index.ts'
 export type { ErbAdapterOptions } from './adapter/index.ts'
 export { conformancePins } from './conformance-pins.ts'
+export { renderDivergences } from './render-divergences.ts'

package/src/render-divergences.ts

@@ -0,0 +1,44 @@
+/**
+ * Render-level divergences against the shared conformance corpus
+ * (Priority-12 edge-case sweep, #2168): fixtures that COMPILE clean on
+ * this adapter but whose rendered output diverges from the Hono
+ * reference on real Ruby erb (or fails at render time).
+ *
+ * Consumed by this package's conformance test (its `skipJsx` set is
+ * derived from these keys, so the skip list and this declaration can't
+ * drift) and by `packages/compat`, which publishes the entries in the
+ * fixture-divergences section of `ui/compat.lock.json` — surfaced on
+ * the docs compatibility-matrix page. Graduating an entry means fixing
+ * the adapter (or the shared compiler layer) and deleting the line.
+ */
+
+import type { RenderDivergences } from '@barefootjs/jsx'
+
+export const renderDivergences: RenderDivergences = {
+  'falsy-text-values':
+    '`{false}` renders "false" (Hono drops it); `{null}`/`{undefined}` render empty (Hono renders "null") — neither side matches JSX semantics',
+  'html-entity-text':
+    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
+  'optional-chaining-prop':
+    '`user?.name ?? …` on an object prop: the Ruby render exits 1 (optional chaining into a Hash prop has no lowering)',
+  'math-methods':
+    'Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)',
+  'boolean-attr-literals':
+    'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
+  'camelcase-attributes':
+    '`htmlFor` is not lowered to `for` (Hono maps it)',
+  'static-attr-escape':
+    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
+  'svg-icon':
+    'SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case',
+  'object-entries-map':
+    '`Object.entries(prop).map(([k, v]) => …)` renders but its loop item keys diverge from the reference serialisation',
+  'nested-loop-outer-binding':
+    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
+  'jsx-element-prop':
+    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
+  'string-slice':
+    '`.slice()` on a STRING lowers through the array slice helper and renders "[]" instead of the substring',
+  'string-trim-sided':
+    '`.trimStart()` / `.trimEnd()` render empty (no lowering; only both-sides `.trim` is wired)',
+}

package/src/test-render.ts

@@ -22,7 +22,18 @@
  * Child components are wired through the production
  * `BarefootJS::Context#register_child_renderer` so the child's `bf-s` scope
  * id derives from `<parentScope>_<slotId>` exactly as a real `bf build`
- * page would.
+ * page would. As of #2158, the child-vars seeding step also runs the exact
+ * production sequence — `BarefootJS::Context.derive_vars_from_defaults`,
+ * the same call `register_components_from_manifest` makes
+ * (`lib/barefoot_js.rb` ~lines 283-292) — instead of a harness-local
+ * `defaults.merge(child_props)` shortcut. That shortcut is why the #2157
+ * bug (a manifest `propName` riding in as a JSON String, looked up against
+ * symbol-keyed runtime prop Hashes, so `children` silently fell back to
+ * the static default and rendered empty) was invisible to this whole
+ * conformance corpus: the harness never exercised the code path the bug
+ * lived in. Now it does, so the same class of regression is caught by
+ * every fixture that renders a child component, not just a dedicated
+ * regression test.
  */
 
 import { compileJSX, extractSsrDefaults, importsSearchParams } from '@barefootjs/jsx'
@@ -255,12 +266,21 @@ export async function renderErbComponent(options: RenderOptions): Promise<string
     const rootScopeIdRaw = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
     const rootScopeId = rubyStringLiteral(rootScopeIdRaw)
 
-    // Static ssrDefaults per child, simplified to bare values (the
-    // caller's props always win — see `buildChildRenderersRuby`) and
-    // written as one JSON file keyed by snake_case template name.
-    const childDefaults: Record<string, Record<string, unknown>> = {}
+    // Static ssrDefaults per child, written VERBATIM — `propName` /
+    // `isRestProps` / `value` intact, exactly the shape the production
+    // build manifest embeds — and written as one JSON file keyed by
+    // snake_case template name. `buildChildRenderersRuby` below feeds this
+    // straight into `BarefootJS::Context.derive_vars_from_defaults`, the
+    // same call `register_components_from_manifest` makes in the published
+    // gem (#2158). A prior version of this harness simplified each entry
+    // to its bare `value` and did `defaults.merge(child_props)` directly —
+    // that sidestepped `derive_vars_from_defaults`'s `propName` lookup
+    // entirely, which is exactly why the #2157 String-vs-symbol `propName`
+    // bug (children rendering empty) was invisible to this whole
+    // conformance corpus.
+    const childDefaults: Record<string, Record<string, SsrDefault>> = {}
     for (const [childName, { ir: childIR }] of childTemplates) {
-      childDefaults[toSnakeCase(childName)] = simplifySsrDefaults(extractSsrDefaults(childIR.metadata) ?? {})
+      childDefaults[toSnakeCase(childName)] = extractSsrDefaults(childIR.metadata) ?? {}
     }
     if (childTemplates.size > 0) {
       await Bun.write(resolve(tempDir, 'child_defaults.json'), JSON.stringify(childDefaults))
@@ -343,10 +363,19 @@ function collectImportedComponentNames(ir: ComponentIR): string[] {
  * derives the child scope id from `<parentScope>_<slotId>` (the parent's
  * `bf.render_child('<name>', { …, _bf_slot: '<slotId>' })` passes
  * `_bf_slot`), seeds signal / memo / prop defaults from the child IR's
- * `ssrDefaults` (loaded once from `child_defaults.json`, caller props win
- * via `Hash#merge`), shares the parent's script list, and renders the
- * child `.erb` through the same backend. Loop children (no `_bf_slot`)
- * fall back to `<ComponentName>_<rand>` like the Perl harnesses.
+ * `ssrDefaults` (loaded once from `child_defaults.json`) THROUGH THE SAME
+ * `BarefootJS::Context.derive_vars_from_defaults` call
+ * `register_components_from_manifest` makes (lib/barefoot_js.rb ~lines
+ * 283-292) — not a harness-local re-derivation — so the propName /
+ * isRestProps resolution the published gem actually runs is exactly what
+ * this harness exercises (#2158; this is the fix for the #2157 class of
+ * bug, where a harness-local `defaults.merge(child_props)` shortcut never
+ * touched that code path and so never caught the String-vs-symbol
+ * `propName` mismatch). Caller props still win over static defaults —
+ * that's `derive_vars_from_defaults`'s own contract — shares the parent's
+ * script list, and renders the child `.erb` through the same backend.
+ * Loop children (no `_bf_slot`) fall back to `<ComponentName>_<rand>`
+ * like the Perl harnesses.
  */
 function buildChildRenderersRuby(
   childTemplates: Map<string, { template: string; ir: ComponentIR }>,
@@ -411,8 +440,16 @@ function buildChildRenderersRuby(
     lines.push(`  child_bf._child_renderers(bf._child_renderers)`)
     lines.push(`  child_bf._scripts(bf._scripts)`)
     lines.push(`  child_bf._script_seen(bf._script_seen)`)
-    // Seed template vars: static ssrDefaults first, caller's props win.
-    lines.push(`  vars = defaults_${snakeName}.merge(child_props)`)
+    // Seed template vars through the production sequence — the exact
+    // call `register_components_from_manifest` makes in the published gem
+    // (lib/barefoot_js.rb ~lines 283-292) — instead of a harness-local
+    // `defaults.merge(child_props)` shortcut. `derive_vars_from_defaults`
+    // resolves each entry's `propName` (symbolized) against the live
+    // `child_props`, falling back to the static `value`; `isRestProps`
+    // entries pass the rest bag through. Caller props still win overall
+    // via the final `merge`.
+    lines.push(`  extra = BarefootJS::Context.derive_vars_from_defaults(defaults_${snakeName}, child_props)`)
+    lines.push(`  vars = child_props.merge(extra)`)
     lines.push(`  rendered = backend.render_named(${rubyStringLiteral(snakeName)}, child_bf, vars)`)
     lines.push(`  rendered.chomp`)
     lines.push(`end)`)
@@ -430,23 +467,6 @@ function rubySymbol(name: string): string {
   return /^[A-Za-z_][A-Za-z0-9_]*[?!]?$/.test(name) ? `:${name}` : `:"${name.replace(/"/g, '\\"')}"`
 }
 
-/**
- * Simplify an `extractSsrDefaults` map to bare values for the child
- * defaults JSON file. Each entry is either a bare value or
- * `{ value, propName?, isRestProps? }`; the child renderer always merges
- * the caller's live `child_props` OVER these defaults (`Hash#merge`), so
- * only the static fallback `value` is needed here — the `propName`-aware
- * resolution the production manifest path does is redundant with that
- * merge.
- */
-function simplifySsrDefaults(defaults: Record<string, SsrDefault>): Record<string, unknown> {
-  const out: Record<string, unknown> = {}
-  for (const [name, d] of Object.entries(defaults)) {
-    out[name] = d.value
-  }
-  return out
-}
-
 /**
  * Convert PascalCase to snake_case for template naming (matches the
  * adapter's `toTemplateName`).