barefoot_js 0.39.7 → 0.39.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2dee751fa656f2231c7d6cee7f3ab165f508ad988a58c0930419dbc3de1132e
-  data.tar.gz: 5ecd00ba7237eac6ef23a9172e53c9b7968077d6097080ba86c0759c8b9dfc64
+  metadata.gz: ca01f4cd2478ff3996932ab0ea7102c799e74c2602f63313ca3ea6ed1e3e7ef7
+  data.tar.gz: 546f0e92374f3947eae8965b2771a3ba6928526eddaa8b9f1e3ced6883deed1f
 SHA512:
-  metadata.gz: 8c781e4df474f753e1c58fe3c1e2e25ca7cf1af53fdae23909e98cc5382d3156103abac6ca4d97ce78a180d64213c52aec0e2674cc56f5e7250ced001843ef6f
-  data.tar.gz: 7e96d3a6a087381bce7afcb51f746f82bc6276b465cce68b57f8ac978dd32c960ada3b846fb0e11652a7c79c0511de41068fb5b831f229ba672fc0ae62f5a790
+  metadata.gz: de992621414ebaf15ae3237dc62c1190bab959f516ed0047026af8a64a1dc87db978d8d43c86e30278f3087c6e45953ff676c9ffb486d8499dc3eb010586cfa5
+  data.tar.gz: dc2aa7213b1e63646a13f0c9340377731ab62baf7731ffcbed0bb517a78ff79d866f08a3a7c985990f666f01532a79237be42c346791d7bff213fa1e83f3a5c6

data/lib/barefoot_js/evaluator.rb

@@ -286,6 +286,26 @@ module BarefootJS
       to_number(l).to_f / to_number(r).to_f
     end
 
+    # JS `%`: the truncated remainder, which takes the dividend's sign
+    # (`-7 % 2` -> -1) and keeps a fraction (`7.5 % 2` -> 1.5); Ruby's `%`
+    # floors instead (`-7 % 2` -> 1). A zero divisor, or a NaN / infinite
+    # dividend, gives NaN. Two Integer operands keep an Integer result, as
+    # Ruby's own `%` did, except for a zero remainder of a negative dividend:
+    # JS gives -0 there (`-4 % 2`), which only shows through later
+    # arithmetic (`1 / (-4 % 2)` is -Infinity), so it is the Float -0.0. An
+    # Array still takes it as index 0 and `number_to_string` spells it "0".
+    # Shared by callback-body evaluation (`binary`) and the template-emitted
+    # remainder (`Context#mod`, #3474).
+    def remainder(l, r)
+      ln = to_number(l)
+      rn = to_number(r)
+      return Float::NAN if rn.zero?
+      return ln.to_f.remainder(rn.to_f) unless ln.is_a?(Integer) && rn.is_a?(Integer)
+
+      m = ln.remainder(rn)
+      m.zero? && ln.negative? ? -0.0 : m
+    end
+
     def binary(op, l, r)
       case op
       when '+'
@@ -297,9 +317,7 @@ module BarefootJS
       when '-' then to_number(l) - to_number(r)
       when '*' then to_number(l) * to_number(r)
       when '/' then divide(l, r)
-      when '%'
-        rn = to_number(r).to_f
-        rn.zero? ? Float::NAN : to_number(l).to_f.remainder(rn)
+      when '%' then remainder(l, r)
       when '<', '<=', '>', '>=' then relational(op, l, r)
       when '===' then strict_eq(l, r)
       when '!==' then !strict_eq(l, r)

data/lib/barefoot_js.rb

@@ -530,6 +530,15 @@ module BarefootJS
       Evaluator.divide(left, right)
     end
 
+    # JS `%`: the truncated remainder, which takes the dividend's sign
+    # (`-7 % 2` -> -1). Ruby's `%` floors (`-7 % 2` -> 1), so
+    # template-emitted remainders go through the shared evaluator's JS
+    # remainder instead: a fraction is kept, and a zero divisor gives NaN
+    # rather than raising (#3474).
+    def mod(left, right)
+      Evaluator.remainder(left, right)
+    end
+
     # JS truthiness (falsy: false, nil, 0, NaN, ""). Delegates to the
     # shared evaluator so template-emitted conditionals
     # (`if bf.truthy?(x)`) and callback-body evaluation agree byte-for-byte.
@@ -1025,18 +1034,28 @@ module BarefootJS
     end
 
     # `Array.prototype.indexOf(x)` / `.lastIndexOf(x)` -- value-equality
-    # search. Non-array receivers return -1.
+    # search. A String receiver is `String.prototype.indexOf`, counted in
+    # UTF-16 code units like JS (#3613). Other receivers return -1.
     def index_of(recv, elem)
+      return utf16_index_of(recv, elem, false) if recv.is_a?(String)
+
       array_index_of(recv, elem, false)
     end
 
     def last_index_of(recv, elem)
+      return utf16_index_of(recv, elem, true) if recv.is_a?(String)
+
       array_index_of(recv, elem, true)
     end
 
     # `Array.prototype.at(i)` -- negative indices count from the end;
     # out-of-bounds -> nil (renders as '' via `h`, matching JS `undefined`).
+    # A String receiver is indexed in UTF-16 code units (#3613). Half of a
+    # surrogate pair, a lone surrogate in JS, comes back as U+FFFD: a
+    # UTF-8 Ruby String can't hold one, so the halves compare equal and
+    # don't rejoin (limitation `string-at-lone-surrogate`).
     def at(recv, i)
+      return utf16_at(recv, i) if recv.is_a?(String)
       return nil unless recv.is_a?(Array)
       return nil if i.nil?
 
@@ -1228,9 +1247,10 @@ module BarefootJS
     def starts_with(recv, prefix, position = nil)
       s = recv.nil? ? '' : string(recv)
       p = prefix.nil? ? '' : string(prefix)
+      # `position` counts UTF-16 code units, like JS (#3613).
       unless position.nil?
-        n = clamp_index(position.to_i, s.length)
-        s = s[n..] || ''
+        units = utf16_units(s)
+        return utf16_has_at?(units, utf16_units(p), clamp_index(to_integer_or_infinity(position), units.length))
       end
       s.start_with?(p)
     end
@@ -1239,9 +1259,11 @@ module BarefootJS
     def ends_with(recv, suffix, end_position = nil)
       s = recv.nil? ? '' : string(recv)
       x = suffix.nil? ? '' : string(suffix)
+      # `endPosition` counts UTF-16 code units, like JS (#3613).
       unless end_position.nil?
-        e = clamp_index(end_position.to_i, s.length)
-        s = s[0...e]
+        units = utf16_units(s)
+        needle = utf16_units(x)
+        return utf16_has_at?(units, needle, clamp_index(to_integer_or_infinity(end_position), units.length) - needle.length)
       end
       s.end_with?(x)
     end
@@ -1697,6 +1719,55 @@ module BarefootJS
       -1
     end
 
+    # `s` as JS sees it: an Array of UTF-16 code units. JS string positions
+    # (`indexOf`, `at`, `startsWith`'s position, ...) count these, so an
+    # astral character such as '😀' is two units (#3613).
+    def utf16_units(s)
+      s.to_s.encode('UTF-16LE', invalid: :replace, undef: :replace).unpack('v*')
+    end
+
+    MAX_SAFE_INDEX = 2**53
+
+    # JS `ToIntegerOrInfinity` for a string position or index (#3613): NaN
+    # -> 0, truncation toward zero, and +/-Infinity clamped to +/-2**53 so
+    # the caller's range check treats it as out of range instead of
+    # `Float#to_i` raising FloatDomainError.
+    def to_integer_or_infinity(value)
+      n = number(value)
+      return 0 if n.respond_to?(:nan?) && n.nan?
+      return MAX_SAFE_INDEX if n >= MAX_SAFE_INDEX
+      return -MAX_SAFE_INDEX if n <= -MAX_SAFE_INDEX
+
+      n.to_i
+    end
+
+    def utf16_has_at?(hay, needle, at)
+      return false if at.negative? || at + needle.length > hay.length
+
+      hay[at, needle.length] == needle
+    end
+
+    def utf16_index_of(recv, elem, reverse)
+      hay = utf16_units(recv)
+      needle = utf16_units(string(elem))
+      last = hay.length - needle.length
+      indices = reverse ? last.downto(0) : 0.upto(last)
+      indices.each { |i| return i if utf16_has_at?(hay, needle, i) }
+      -1
+    end
+
+    def utf16_at(recv, i)
+      return nil if i.nil?
+
+      units = utf16_units(recv)
+      idx = to_integer_or_infinity(i)
+      idx += units.length if idx.negative?
+      return nil if idx.negative? || idx >= units.length
+
+      u = units[idx]
+      (0xD800..0xDFFF).cover?(u) ? "\uFFFD" : [u].pack('U')
+    end
+
     def clamp_index(n, len)
       n = 0 if n.negative?
       n = len if n > len

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: barefoot_js
 version: !ruby/object:Gem::Version
-  version: 0.39.7
+  version: 0.39.9
 platform: ruby
 authors:
 - kobaken