barefoot_js 0.18.4 → 0.18.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75f8d84f1a06dd1e2dcd614cb73a94506f02a93cd0e36b2ec8f79c982f3886d9
-  data.tar.gz: c58250e3c14adb29e69fb0821ffbee94c02c1d24b72639ad9ec732d5984dd9c9
+  metadata.gz: 25b9687ad06be1cbb4af5cccab3d8caa83e038ed2b030ecb83dd4a7430f75175
+  data.tar.gz: cedfce0556b406f8b7c32d3cf936adcc50680006c123244315bb90fc1b1e8f05
 SHA512:
-  metadata.gz: 9d920d1a38684ec644876e05fec43b1624bdb0c000cdd6f1ca6c14f6f89323877422ad7c4dd0b23a7d08f17771def17c02090ac5c424128f951636be7c8629a5
-  data.tar.gz: 4aece46d06c426ef3f42eeabf79a559e623e815ea87b4d59880707845ecc21f380669e97c3657831a3d28960d6e3b8b0cba81f799c1cada4d6a2fe4071b04ba5
+  metadata.gz: 8048f1a7bafccb96cde14303b903d10f24e857999208bad02c1d429af4135921eebdeee6440606da524569727258096bce6d2c253b1b6ca0e1e4cd14d650b0d1
+  data.tar.gz: 7044ba378260461827af82e1632ab5ffc017800d4791d2e8765c16e5adbb7528565a66b3470ebfeb429ec2b8659b5706da3ac3f2031cb23e1e5c9e3a68fca4ef

data/lib/barefoot_js/backend/erb.rb

@@ -13,15 +13,25 @@ module BarefootJS
     # operations the runtime delegates to, targeting Ruby stdlib ERB:
     #
     #   encode_json(data)            -> JSON string (injectable encoder)
-    #   mark_raw(str)                -> identity (ERB has no "safe string"
-    #                                    wrapper type -- ERB's own `<%=` is
-    #                                    NOT auto-escaping, so the compiled
-    #                                    templates that need escaping call
-    #                                    `bf.h(...)` explicitly; `mark_raw`
-    #                                    only exists so runtime helpers that
-    #                                    already produce finished HTML --
-    #                                    e.g. spread_attrs -- share one
-    #                                    interface with the Kolon/EP ports)
+    #   mark_raw(str)                -> wraps in BarefootJS::SafeString --
+    #                                    ERB's own `<%=` is NOT auto-escaping,
+    #                                    so most compiled templates call
+    #                                    `bf.h(...)` explicitly instead of
+    #                                    relying on a safe-string bypass; the
+    #                                    wrapper exists for the one path that
+    #                                    DOES need one -- a named-slot /
+    #                                    children value captured in a parent
+    #                                    template and forwarded into a
+    #                                    child's vars Hash, where the child
+    #                                    reads it back through the generic
+    #                                    `bf.h(...)` text-expression path
+    #                                    (`Context#h` unwraps SafeString to
+    #                                    skip re-escaping) -- and so that
+    #                                    runtime helpers which already
+    #                                    produce finished HTML (e.g.
+    #                                    spread_attrs) share one
+    #                                    `backend.mark_raw(...)` interface
+    #                                    with the Kolon/EP ports
     #   materialize(value)           -> resolve a captured-children value
     #                                    to a string
     #   render_named(name, bf, vars) -> render `<name>.erb` with `bf` and
@@ -58,13 +68,12 @@ module BarefootJS
         @json_encoder.call(data)
       end
 
-      # ERB has no "already-safe" string wrapper the way Kolon's `mark_raw`
-      # or Mojo::ByteStream do -- stdlib ERB's `<%=` never auto-escapes, so
-      # there is nothing to opt out of. Identity, kept only so runtime
-      # helpers (`spread_attrs`) share one `backend.mark_raw(...)` call
-      # shape across every BarefootJS backend port.
+      # See the class docstring's `mark_raw` entry: wraps in
+      # `BarefootJS::SafeString` so `Context#h` recognises and skips
+      # re-escaping already-finished HTML forwarded across a
+      # parent/child template boundary.
       def mark_raw(str)
-        str
+        BarefootJS::SafeString.new(str.to_s)
       end
 
       # JSX children captured by the adapter's buffer-slice capture

data/lib/barefoot_js/evaluator.rb

@@ -188,7 +188,20 @@ module BarefootJS
       return Float::INFINITY if t == 'Infinity' || t == '+Infinity'
       return -Float::INFINITY if t == '-Infinity'
       return Integer(t, 16) if t =~ HEX_STRING_RE
-      return Float(t) if t =~ NUMERIC_STRING_RE
+
+      if t =~ NUMERIC_STRING_RE
+        # Ruby's Float() rejects a trailing decimal point ("5.", "5.e3"),
+        # while JS's Number() accepts it (treating the fractional part as
+        # empty). Strip a "." that isn't followed by a digit before
+        # converting, so the accepted grammar stays identical to JS but the
+        # conversion itself never raises.
+        normalized = t.sub(/\.(?=\z|[eE])/, '')
+        begin
+          return Float(normalized)
+        rescue ArgumentError, TypeError
+          return Float::NAN
+        end
+      end
 
       Float::NAN
     end

data/lib/barefoot_js.rb

@@ -25,6 +25,18 @@ require 'barefoot_js/search_params'
 # runtime carries -- a Ruby `true`/`false` IS a boolean, distinguishable
 # from `0`/`1` for free.
 module BarefootJS
+  # Marker wrapper for a string that is ALREADY finished HTML and must not
+  # be re-escaped by `Context#h` -- e.g. a named-slot / children capture
+  # (`renderComponent`'s output-buffer slice) forwarded from a parent
+  # template into a child's vars Hash. Stdlib ERB's `<%=` has no built-in
+  # "safe string" concept the way Twig's `Markup` or Kolon's `mark_raw`
+  # do, so the escape decision that elsewhere falls out of the template
+  # engine has to be carried on the VALUE itself here; see
+  # `Backend::Erb#mark_raw`, which is what actually wraps a string in this
+  # class.
+  class SafeString < String
+  end
+
   # Context is the `bf` object every compiled `.erb` template receives as a
   # local. One instance per render (root or child); `render_child` /
   # `register_components_from_manifest` construct a fresh child instance
@@ -391,8 +403,13 @@ module BarefootJS
     # HTML-escaping helper for text interpolation (`<%= bf.h(expr) %>` --
     # stdlib ERB does not auto-escape). JS-style stringification via
     # `string` (numbers per JS Number#toString, nil -> "", booleans ->
-    # "true"/"false"), then HTML-escaped.
+    # "true"/"false"), then HTML-escaped. A `SafeString` (already-finished
+    # HTML forwarded from a parent's capture -- see that class's docstring)
+    # passes through unescaped, matching Twig/Blade/Kolon's safe-string
+    # bypass on their own auto-escaping `{{ }}`/`<: :>` output tags.
     def h(value)
+      return value if value.is_a?(SafeString)
+
       html_escape(string(value))
     end
 
@@ -430,6 +447,34 @@ module BarefootJS
       finite_number?(n) ? (n + 0.5).floor : n
     end
 
+    # `Math.min(a, b)` / `Math.max(a, b)` -- two-arg forms only (#2168
+    # math-methods). JS returns NaN if either operand is NaN. `number()`
+    # may return a plain Integer (no `#nan?`), so guard like
+    # `finite_number?` above rather than calling `#nan?` unconditionally.
+    def min(a, b)
+      x = number(a)
+      y = number(b)
+      return x if nan_number?(x)
+      return y if nan_number?(y)
+
+      x < y ? x : y
+    end
+
+    def max(a, b)
+      x = number(a)
+      y = number(b)
+      return x if nan_number?(x)
+      return y if nan_number?(y)
+
+      x > y ? x : y
+    end
+
+    # `Math.abs()` (#2168 math-methods).
+    def abs(value)
+      n = number(value)
+      nan_number?(n) ? n : n.abs
+    end
+
     # -----------------------------------------------------------------
     # Array / String method helpers
     # -----------------------------------------------------------------
@@ -563,13 +608,22 @@ module BarefootJS
       out
     end
 
-    # `Array.prototype.slice(start, end?)`. Mirrors the Go/Perl `bf_slice` /
-    # `slice` arithmetic so adapter output stays symmetric.
+    # `Array.prototype.slice(start, end?)` AND `String.prototype.slice`
+    # (the `string-slice` divergence) -- the adapter emits the same
+    # `bf_slice` call for both receiver shapes (it can't disambiguate
+    # string vs. array at compile time), so this dispatches on Ruby
+    # class, mirroring `includes` above. Mirrors the Go/Perl `bf_slice`
+    # / `slice` arithmetic so adapter output stays symmetric.
+    # `String#length` / `#[]` already index by character (not byte) for
+    # a UTF-8-encoded string, matching JS except for astral-plane input
+    # (the same divergence boundary every other adapter's pad/trim
+    # helpers already accept).
     def slice(recv, start, end_ = nil)
-      return [] unless recv.is_a?(Array)
+      return [] unless recv.is_a?(Array) || recv.is_a?(String)
 
+      empty = recv.is_a?(String) ? '' : []
       len = recv.length
-      return [] if len.zero?
+      return empty if len.zero?
 
       s = start.nil? ? 0 : start.to_i
       s = len + s if s.negative?
@@ -581,7 +635,7 @@ module BarefootJS
       e = 0 if e.negative?
       e = len if e > len
 
-      return [] if s >= e
+      return empty if s >= e
 
       recv[s...e]
     end
@@ -663,6 +717,21 @@ module BarefootJS
       string(recv).gsub(/\A\p{Space}+|\p{Space}+\z/, '')
     end
 
+    # `String.prototype.trimStart()` / `.trimEnd()` -- the one-sided
+    # siblings of `trim` above (#2183 follow-up), same `\p{Space}` regex
+    # restricted to one side.
+    def trim_start(recv)
+      return '' if recv.nil? || recv.is_a?(Array) || recv.is_a?(Hash)
+
+      string(recv).sub(/\A\p{Space}+/, '')
+    end
+
+    def trim_end(recv)
+      return '' if recv.nil? || recv.is_a?(Array) || recv.is_a?(Hash)
+
+      string(recv).sub(/\p{Space}+\z/, '')
+    end
+
     # `Number.prototype.toFixed(digits)` -- fixed-decimal string with
     # zero-padding, rounding half toward +Infinity (matching `round`).
     def to_fixed(value, digits = 0)
@@ -741,6 +810,38 @@ module BarefootJS
       s[0...idx] + n + s[(idx + o.length)..]
     end
 
+    # `String.prototype.replaceAll(pattern, replacement)` -- string-pattern
+    # form only (#2182), replacing EVERY occurrence (the all-occurrences
+    # sibling of `replace` above). Deliberately NOT `String#gsub`: Ruby's
+    # `gsub` interprets `\1` / `\&` backreference syntax in the replacement
+    # even for a literal string pattern (`"abc".gsub("b", "\\1")` -> "ac",
+    # not the literal "\1"), which would diverge from `.replace`'s literal
+    # splice above and from the other backends' literal treatment. The
+    # index/splice loop keeps the replacement literal, matching `replace`.
+    # An empty pattern inserts at every boundary, including before the
+    # first and after the last character (`"abc".replaceAll("", "X")` ->
+    # "XaXbXcX"), matching JS.
+    def replace_all(recv, pattern, replacement)
+      s = recv.nil? ? '' : string(recv)
+      o = pattern.nil? ? '' : string(pattern)
+      n = replacement.nil? ? '' : string(replacement)
+      return ([''] + s.chars + ['']).join(n) if o.empty?
+
+      # `+''` (not the frozen `''` literal under frozen_string_literal)
+      # so `<<` can append in place instead of `+=` reallocating a new
+      # string each iteration (quadratic for long inputs / many matches).
+      out = +''
+      pos = 0
+      loop do
+        idx = s.index(o, pos)
+        break if idx.nil?
+
+        out << s[pos...idx] << n
+        pos = idx + o.length
+      end
+      out << s[pos..]
+    end
+
     # `queryHref(base, { ... })` (#2042) -- build "base?k=v&..." from a flat
     # list of (guard, key, value) triples. A pair is included iff its guard
     # is truthy AND its value is a non-empty string. A value may instead be
@@ -978,6 +1079,10 @@ module BarefootJS
       !(n.respond_to?(:nan?) && n.nan?) && !(n.respond_to?(:infinite?) && n.infinite?)
     end
 
+    def nan_number?(n)
+      n.respond_to?(:nan?) && n.nan?
+    end
+
     def html_escape(s)
       s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&#34;').gsub("'", '&#39;')
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barefoot_js
 version: !ruby/object:Gem::Version
-  version: 0.18.4
+  version: 0.18.7
 platform: ruby
 authors:
 - kobaken
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-07-13 00:00:00.000000000 Z
 dependencies: []
 description: Engine-agnostic BarefootJS server runtime targeting ERB, ported from
   packages/adapter-perl/lib/BarefootJS.pm.