barefoot_js 0.39.3 → 0.39.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a105aa386a05bd1cf0cc0fd24fd58516c1b65f7c83b25f448d6e2078af7d592b
-  data.tar.gz: 50010c52f3a90fd2f7f80d2860c7c41efa56f628b8c82309b09593ddae08e978
+  metadata.gz: 4c4ebbb9319c464c569e177922099bf053ac8a57173ca1dd51e72ac45e68b27b
+  data.tar.gz: f211b6e607b11d954e29967c6cca359aa459853ce61c2979b3e415fb685a0db7
 SHA512:
-  metadata.gz: 9447dbc63c3764e2963a3a3910468c4d63d4b0b2fb4c974648a0a693f61126ae4ca49cc677f547193618bc747f3db9638b13c529a5a2733c12159c362c420af6
-  data.tar.gz: 6f7b774ec12dc05959a0f5b230001edddc2328403733b715c686097a6dab970faca390e56144e1e6e72badb8a96f88736559e4808acc9f43d5e042b11e6935c7
+  metadata.gz: 56ad319dee5b7974e917321dce07fef04f435e1a9c1f96ba365930eb0671bc671ba60777bfafb58f128f306d6c6edce9e4b8cf08856f4a37ee7e371693eb1ac1
+  data.tar.gz: 4ac7bcb135489b27fa363d9549af7421c1e21108dbb30acbc6292730b6b2460bb7c9167c9d2b8342e91a5d9325da5434525dff64ec9d1143c9af93b52f8bc8bd

data/lib/barefoot_js/evaluator.rb

@@ -225,38 +225,67 @@ module BarefootJS
     end
     private_class_method :parse_numeric_string
 
-    # JS Number#toString. Integral finite values (however they arrived --
-    # Integer or an integral Float) render without a decimal point
-    # ("1.0" -> "1"); non-finite values use the JS spellings ("NaN" /
-    # "Infinity" / "-Infinity"), which Ruby's own Float#to_s does not use.
-    # Non-integral floats fall back to Ruby's shortest-round-trip Float#to_s
-    # (the same class of algorithm V8 uses), reformatted to JS's exponent
-    # style. This is not the full ECMA-262 Number::toString grammar (no
-    # attempt to match JS's exact exponential-notation thresholds), but it
-    # is exact for every value the golden vectors exercise.
+    # JS Number#toString. Integral finite values below 2**53 (however they
+    # arrived -- Integer or an integral Float) render exactly, without a
+    # decimal point ("1.0" -> "1"); non-finite values use the JS spellings
+    # ("NaN" / "Infinity" / "-Infinity"), which Ruby's own Float#to_s does
+    # not use. Everything else takes Ruby's shortest-round-trip Float#to_s
+    # digits (the same digits V8 picks) re-spelled with ECMA-262's notation
+    # rules: decimal within [1e-6, 1e21), otherwise an unpadded lower-case
+    # exponent (`1.23456789e-7`, `1.23456789e+21`) -- Ruby switches to an
+    # exponent below 1e-4 and pads it (`1.23456789e-06`) (#3380).
     def number_to_string(n)
       f = n.to_f
       return 'NaN' if f.nan?
       return f.negative? ? '-Infinity' : 'Infinity' if f.infinite?
       return '0' if f.zero?
-      return n.to_i.to_s if f == f.to_i && f.abs < 1e21
-
-      s = f.to_s
-      if s.include?('e')
-        mantissa, exp = s.split('e')
-        mantissa = mantissa.sub(/\.0\z/, '')
-        sign = exp.start_with?('-') ? '-' : '+'
-        digits = exp.sub(/\A[+-]/, '').sub(/\A0+(?=\d)/, '')
-        "#{mantissa}e#{sign}#{digits}"
-      else
-        s
-      end
+      return n.to_i.to_s if f == f.to_i && f.abs < 2**53
+
+      js_notation(f.to_s)
+    end
+
+    # Re-spell a shortest round-trip decimal (`[-]d[.ddd][e[+-]x]`) with the
+    # ECMA-262 Number::toString notation rules: `digits` holds the
+    # significant digits, `point` where the decimal point falls in them.
+    def js_notation(shortest)
+      sign = shortest.start_with?('-') ? '-' : ''
+      mantissa, exp = shortest.delete_prefix('-').downcase.split('e', 2)
+      int_part, frac_part = mantissa.split('.', 2)
+      raw = int_part + (frac_part || '')
+      point = int_part.length + (exp ? exp.to_i : 0)
+      digits = raw.sub(/\A0+/, '')
+      point -= raw.length - digits.length
+      digits = digits.sub(/0+\z/, '')
+      digits = '0' if digits.empty?
+      k = digits.length
+      out =
+        if k <= point && point <= 21
+          digits + ('0' * (point - k))
+        elsif point.positive? && point <= 21
+          "#{digits[0, point]}.#{digits[point..]}"
+        elsif point > -6 && point <= 0
+          "0.#{'0' * -point}#{digits}"
+        else
+          e = point - 1
+          "#{digits[0]}#{k > 1 ? ".#{digits[1..]}" : ''}e#{e >= 0 ? '+' : '-'}#{e.abs}"
+        end
+      sign + out
     end
+    private_class_method :js_notation
 
     # ---------------------------------------------------------------------
     # Operators
     # ---------------------------------------------------------------------
 
+    # JS `/`: both operands through `to_number` (JS `Number()`), then IEEE
+    # Float division, which already gives JS's division-by-zero results
+    # (`1 / 0` -> Infinity, `1 / -0` -> -Infinity, `0 / 0` -> NaN). Shared by
+    # callback-body evaluation (`binary`) and template-emitted division
+    # (`Context#div`), so both coerce and divide identically (#3328).
+    def divide(l, r)
+      to_number(l).to_f / to_number(r).to_f
+    end
+
     def binary(op, l, r)
       case op
       when '+'
@@ -267,19 +296,7 @@ module BarefootJS
         to_number(l) + to_number(r)
       when '-' then to_number(l) - to_number(r)
       when '*' then to_number(l) * to_number(r)
-      when '/'
-        ln = to_number(l).to_f
-        rn = to_number(r).to_f
-        if rn.zero?
-          # JS division by zero is finite-valued, not an error.
-          if ln.zero? || ln.nan?
-            Float::NAN
-          else
-            ln.positive? ? Float::INFINITY : -Float::INFINITY
-          end
-        else
-          ln / rn
-        end
+      when '/' then divide(l, r)
       when '%'
         rn = to_number(r).to_f
         rn.zero? ? Float::NAN : to_number(l).to_f.remainder(rn)

data/lib/barefoot_js.rb

@@ -521,6 +521,15 @@ module BarefootJS
       html_escape(string(value))
     end
 
+    # JS `/`: always a Number quotient. Ruby's `/` on two Integers is
+    # integer division (`1234567890 / 4` -> `308641972`, `-7 / 4` -> `-2`),
+    # so template-emitted division goes through the shared evaluator's JS
+    # division instead -- JS operand coercion, fractional quotient kept,
+    # division by zero yielding Infinity / -Infinity / NaN (#3328).
+    def div(left, right)
+      Evaluator.divide(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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: barefoot_js
 version: !ruby/object:Gem::Version
-  version: 0.39.3
+  version: 0.39.5
 platform: ruby
 authors:
 - kobaken
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tzinfo