@barefootjs/erb 0.18.4 → 0.18.5

package/src/adapter/erb-adapter.ts

@@ -91,7 +91,7 @@ import {
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr, isExplicitStringCall } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher, LoopBindingPathSegment } from '@barefootjs/jsx'
-import { BF_SLOT, BF_COND, BF_REGION } from '@barefootjs/shared'
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from '@barefootjs/shared'
 
 import type { ErbRenderCtx } from './lib/types.ts'
 import { ERB_PRIMITIVE_EMIT_MAP } from './lib/constants.ts'
@@ -177,6 +177,14 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   private options: Required<ErbAdapterOptions>
   private errors: CompilerError[] = []
   private inLoop: boolean = false
+  /**
+   * `IRLoop.depth` of the loop currently being rendered (save/restore
+   * around `renderChildren(loop.children)`, mirroring `inLoop` above).
+   * `renderAttributes` reads this to derive the `key` → `data-key`/
+   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
+   * re-derived here (#2168 nested-loop-outer-binding).
+   */
+  private currentLoopKeyDepth = 0
   /**
    * SolidJS-style props identifier (`function(props: P)`) and the
    * analyzer-extracted prop names. Stashed at `generate()` entry so the
@@ -499,7 +507,9 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
   }
 
   emitText(node: IRText): string {
-    return node.value
+    // IRText carries the entity-DECODED value (Phase 1 decodes JSX
+    // character references); re-escape for direct HTML emission.
+    return escapeHtml(node.value)
   }
 
   emitExpression(node: IRExpression): string {
@@ -896,17 +906,22 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
     // whole body (children + key + filter) so a same-named loop variable
     // isn't replaced by the const literal / a vars-Hash read. Ref-counted
     // for nested loops; released after the body lines are assembled below.
-    const loopBound = loop.iterationShape === 'keys'
-      ? [param]
-      : supportableDestructure
-        ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
-        : [param, loop.index ?? '_i']
+    const loopBound = loop.objectIteration === 'entries'
+      ? [param, loop.index ?? '_k']
+      : loop.objectIteration === 'keys' || loop.objectIteration === 'values' || loop.iterationShape === 'keys'
+        ? [param]
+        : supportableDestructure
+          ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
+          : [param, loop.index ?? '_i']
     for (const n of loopBound) {
       this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1)
     }
     const prevInLoop = this.inLoop
     this.inLoop = true
+    const prevLoopKeyDepth = this.currentLoopKeyDepth
+    this.currentLoopKeyDepth = loop.depth
     const renderedChildren = this.renderChildren(loop.children)
+    this.currentLoopKeyDepth = prevLoopKeyDepth
     this.inLoop = prevInLoop
 
     // Whole-item conditional: prepend an always-present
@@ -966,6 +981,21 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       }
       lines.push(`<%- ${sortedHoist} = ${sorted} -%>`)
     }
+    if (loop.objectIteration) {
+      // `objectIteration` (#2168 object-entries-map): Ruby's `Hash`
+      // preserves the source object's insertion order natively (unlike
+      // Go's `map`/Perl's hash), so this bypasses the index-range form
+      // above entirely and uses Ruby's own native block-param binding
+      // (`each_pair`/`each_key`/`each_value`) — no `array[index]` lookup
+      // needed, since the block directly yields the key/value.
+      const method = loop.objectIteration === 'entries'
+        ? 'each_pair'
+        : loop.objectIteration === 'keys' ? 'each_key' : 'each_value'
+      const blockParams = loop.objectIteration === 'entries'
+        ? `${rubyLocal(loop.index ?? param)}, ${rubyLocal(param)}`
+        : rubyLocal(param)
+      lines.push(`<%- ${array}.${method} do |${blockParams}| -%>`)
+    } else {
     lines.push(`<%- (0...${array}.length).each do |${indexVar}| -%>`)
     if (loop.iterationShape !== 'keys') {
       if (supportableDestructure) {
@@ -1004,6 +1034,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
         lines.push(`<%- ${rubyLocal(param)} = ${array}[${indexVar}] -%>`)
       }
     }
+    }
 
     // Handle filter().map() pattern by wrapping children in if-condition
     if (loop.filterPredicate) {
@@ -1095,10 +1126,46 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
 
   renderComponent(comp: IRComponent): string {
     const propParts: string[] = []
+    // Named JSX-valued props OTHER than the reserved `children`
+    // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) each get
+    // their own buffer-slice capture, prepended to the final returned
+    // string below — same mechanism as the reserved children capture,
+    // just keyed by the prop's own name instead of `children`. Unlike the
+    // reserved `children` value (which the child template reads back
+    // through a structural bypass, `isChildrenValueExpr`), a named slot
+    // is read by the child through the GENERIC `bf.h(v[:name])`
+    // text-expression path — there's no name to special-case there, since
+    // any prop name is possible. So the captured HTML is wrapped in
+    // `bf.backend.mark_raw(...)` here (`BarefootJS::SafeString`,
+    // `barefoot_js.rb`) and `Context#h` unwraps it to skip re-escaping —
+    // giving ERB the same "value carries its own safety" bypass Twig's
+    // `Markup` / Kolon's `mark_raw` get from their auto-escaping `{{ }}`.
+    const namedSlotCaptures: string[] = []
     for (const p of comp.props) {
       // Skip callback props (onXxx) and `ref` — both are client-only for
       // SSR (Hono renders neither; the client JS wires them at hydration).
       if ((p.name.match(/^on[A-Z]/) || p.name === 'ref') && p.value.kind === 'expression') continue
+      if (p.value.kind === 'jsx-children' && p.name !== 'children') {
+        const prevInLoop = this.inLoop
+        this.inLoop = false
+        const slotBody = this.renderChildren(p.value.children)
+        this.inLoop = prevInLoop
+        // Purely counter-based — NOT derived from `p.name` or `comp.slotId`.
+        // A JSX prop name can contain characters (`data-slot`) that aren't
+        // valid in a Ruby local variable name, and `comp.slotId` alone
+        // would collide across two named-slot props on the same component
+        // invocation (unlike the reserved children slot, there's only ever
+        // one of those per invocation).
+        const suffix = `${this.childrenCaptureCounter++}`
+        const lenVar = `__bf_len_${suffix}`
+        const rawVar = `__bf_praw_${suffix}`
+        const capVar = `__bf_prop_${suffix}`
+        namedSlotCaptures.push(
+          `<% ${lenVar} = _erbout.length %>${slotBody}<% ${rawVar} = _erbout.slice!(${lenVar}..); ${capVar} = bf.backend.mark_raw(${rawVar}) %>`,
+        )
+        propParts.push(`${rubySymbolKey(p.name)} ${capVar}`)
+        continue
+      }
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name)
       if (lowered) propParts.push(lowered)
     }
@@ -1138,10 +1205,10 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       const lenVar = `__bf_len_${suffix}`
       const capVar = `__bf_children_${suffix}`
       const propsHash = `{ ${[...propParts, `children: ${capVar}`].join(', ')} }`
-      return `<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash}) %>`
+      return `${namedSlotCaptures.join('')}<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash}) %>`
     }
     const propsHash = propParts.length > 0 ? `{ ${propParts.join(', ')} }` : '{}'
-    return `<%= bf.render_child('${tplName}', ${propsHash}) %>`
+    return `${namedSlotCaptures.join('')}<%= bf.render_child('${tplName}', ${propsHash}) %>`
   }
 
   private childrenCaptureCounter = 0
@@ -1227,7 +1294,7 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
    * Routed through the shared dispatcher.
    */
   private readonly elementAttrEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       // `style={{ … }}` object literal → a CSS string with dynamic values
       // interpolated, instead of refusing the bare object with BF101.
@@ -1450,7 +1517,10 @@ export class ErbAdapter extends BaseAdapter implements IRNodeEmitter<ErbRenderCt
       // attribute-emit time.
       let attrName: string
       if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') attrName = 'data-key'
+      else if (attr.name === 'key') {
+        const depth = this.currentLoopKeyDepth
+        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
+      }
       else attrName = attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)

package/src/adapter/expr/array-method.ts

@@ -125,6 +125,15 @@ export function renderArrayMethod(
       const recv = emit(object)
       return `bf.trim(${recv})`
     }
+    case 'trimStart':
+    case 'trimEnd': {
+      // `.trimStart()` / `.trimEnd()` — the one-sided siblings of
+      // `.trim()` (#2183 follow-up). Dedicated `bf.trim_start` /
+      // `bf.trim_end` helpers, not `bf.trim` with a flag.
+      const fn = method === 'trimStart' ? 'trim_start' : 'trim_end'
+      const recv = emit(object)
+      return `bf.${fn}(${recv})`
+    }
     case 'toFixed': {
       // `.toFixed(digits?)` — Number → fixed-decimal string. `bf.to_fixed`
       // mirrors JS rounding + zero-padding (default 0 digits).
@@ -178,6 +187,19 @@ export function renderArrayMethod(
       const newS = emit(args[1])
       return `bf.replace(${recv}, ${oldS}, ${newS})`
     }
+    case 'replaceAll': {
+      // `.replaceAll(old, new)` — string-pattern form, EVERY occurrence,
+      // via the dedicated `bf.replace_all` helper (NOT Ruby's `gsub`,
+      // which interprets `\1` / `\&` backreference syntax in the
+      // replacement even for a literal string pattern — that would
+      // diverge from `.replace`'s literal splice above). The
+      // regex-pattern form is refused upstream at the parser, same as
+      // `.replace`. See #2182.
+      const recv = emit(object)
+      const oldS = emit(args[0])
+      const newS = emit(args[1])
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`
+    }
     case 'repeat': {
       // `.repeat(n)` — string repeated `n` times. The `bf.repeat` helper
       // wraps Ruby's `*` string-repeat operator with the same

package/src/adapter/expr/emitters.ts

@@ -123,11 +123,19 @@ export class ErbFilterEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `.length` needs no special higher-order form here — see the file
     // docstring's simplification (2): `.select { ... }.length` just works
     // in Ruby, unlike Perl's anonymous-arrayref `scalar(@{...})` detour.
     if (property === 'length') return `${emit(object)}.length`
+    // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
+    // Ruby's own `nil[:key]` raises `NoMethodError` (unlike Hash#[] on a
+    // present Hash) — `&.` is Ruby's native safe-navigation operator, and
+    // `&.[](...)` is its explicit-method form for indexing rather than a
+    // dotted method call. Only guards the single written `?.` hop, not a
+    // JS-style whole-chain short-circuit — see the `ParsedExpr` `member`
+    // variant's docstring for the multi-hop caveat.
+    if (optional) return `${emit(object)}&.[](${rubySymbolLiteral(property)})`
     return `${emit(object)}[${rubySymbolLiteral(property)}]`
   }
 
@@ -323,7 +331,7 @@ export class ErbTopLevelEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `props.x` flattens to the `v[:x]` the ERB SSR caller seeds each prop
     // under (props arrive as vars-Hash entries, not a nested `props` Hash).
     if (object.kind === 'identifier' && object.name === 'props') {
@@ -339,6 +347,11 @@ export class ErbTopLevelEmitter implements ParsedExprEmitter {
     }
     const obj = emit(object)
     if (property === 'length') return `${obj}.length`
+    // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
+    // see `ErbFilterEmitter.member()`'s comment above for why `&.[](...)`
+    // (not a dotted `&.name`) is the right safe-nav form for a Hash-keyed
+    // prop, and for the single-hop caveat.
+    if (optional) return `${obj}&.[](${rubySymbolLiteral(property)})`
     return `${obj}[${rubySymbolLiteral(property)}]`
   }
 

package/src/adapter/lib/constants.ts

@@ -24,6 +24,9 @@ export const ERB_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
   'Math.round':     { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  'Math.min':       { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  'Math.max':       { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf.abs(${args[0]})` },
 }
 
 /**

package/src/conformance-pins.ts

@@ -103,9 +103,4 @@ export const conformancePins: ConformancePins = {
   // 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/render-divergences.ts

@@ -14,23 +14,4 @@
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
-export const renderDivergences: RenderDivergences = {
-  '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)',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  '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 const renderDivergences: RenderDivergences = {}