smarter_json 1.2.4 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bdfb87113872a6659af0063f196de84f9074b81eedc90ae63445fa6a9f86a0a
-  data.tar.gz: 1271826d3097455921c7f058710ea42651daa75a0de9438b0f0d581e7abc8b7a
+  metadata.gz: d7ded6a0b9872aaa577e5a8381ed69c5eeb89056a05eaa82a253228b1456c2b9
+  data.tar.gz: 5fb399f6c8ae40528d521182b02b4e156734c436b70e3cbd662b832ad339f245
 SHA512:
-  metadata.gz: 4885f735c132bea79affc74ddb82504c581b722a03f52fbbbaabe27fa818347715bf1753b2fc539fb86991448a3e7987719d679f18210aaab54afbe06ee1d021
-  data.tar.gz: c9fafa246a337eb025a089e3db4909c596d52b023b5b06291e7f3b8114f225c57ad4e48b4fd742ffd295db1c95e6cd9574e68adc6bba0d9f5a4c8695b0620649
+  metadata.gz: 0c87d064c656210698c3fd0307bd2673861105e1be998e0770a6833cc7c7bd9658c329b19c5866d87bb23db11fc2dec13a25b8007417fa634ed2fe6ab4d71624
+  data.tar.gz: 959b5022a439414a101285ee4d3480e8ca011c1d9293eac911024f9748b574bda1a108b280d529118b5e572fcd1dd633a9ef4ca89d0bea5e07823135868a5e2c

data/CHANGELOG.md

@@ -13,6 +13,22 @@
 > ⚠️ We discourage the use of `process(input).first` / `process(input)[0]` because it silently drops potential additional documents
 >    Please use `process_one` if you are expecting only one JSON doc, e.g. in API payloads, because it emits on_warning if it finds multiple docs.
 
+## 1.2.6 (2026-07-02)
+
+RSpec tests: 1,308 → 1,325
+
+### Bug Fixes
+
+  - **The `:number_overflow` warning now reports the sign of the collapsed value.** A negative number literal beyond Float range (e.g. `-1e400`) collapses to `-Infinity`, but the warning said "collapsed to Infinity" — always on the C path, and for top-level numbers on the pure-Ruby path. Both paths now report the actual collapsed value (`Infinity` or `-Infinity`) in every position, and the warning-parity suite locks them together.
+
+## 1.2.5 (2026-07-01)
+
+RSpec tests: 1,282 → 1,308
+
+### New Features
+
+  - **RFC 7464 JSON Text Sequences are now read natively.** The record separator (`0x1E`) that frames each record is a first-class document separator, so an RS-framed stream parses into its documents without a warning, and bare-scalar records (a number / keyword / string on its own) are read correctly.
+
 ## 1.2.4 (2026-07-01)
 
 RSpec tests: 1,268 → 1,282

data/ext/smarter_json/smarter_json.c

@@ -649,7 +649,11 @@ static FJ_ALWAYS_INLINE VALUE fj_float_from_parts(fj_state *st, uint64_t m10, in
      still returned). The Infinity/NaN keywords take separate paths and never get here.
      Gate isinf on a listening handler (matches the Ruby float_or_warn): no handler ->
      no point detecting, and it keeps the test off the hot number path. */
-  if (st->on_warning != Qnil && isinf(d)) fj_warn(st, fj_sym_number_overflow, "number literal out of Float range — collapsed to Infinity");
+  if (st->on_warning != Qnil && isinf(d)) {
+    fj_warn(st, fj_sym_number_overflow,
+            d > 0 ? "number literal out of Float range — collapsed to Infinity"
+                  : "number literal out of Float range — collapsed to -Infinity");
+  }
   return rb_float_new(d);
 }
 
@@ -1624,14 +1628,17 @@ static int fj_implicit_root_ahead(fj_state *st) {
   return result;
 }
 
-/* Between top-level documents, whitespace, comments, AND commas all separate
- * (commas collapse like the in-container lenient-comma rule). A space alone never
- * separates — that is handled inside the document by the quoteless run. Mirrors
- * the Ruby Parser#skip_document_separators. */
+/* Between top-level documents, whitespace, comments, commas, AND the RFC 7464
+ * record separator (0x1E) all separate (commas collapse like the in-container
+ * lenient-comma rule; 0x1E frames each JSON Text Sequence record). A space alone
+ * never separates — that is handled inside the document by the quoteless run.
+ * Mirrors the Ruby Parser#skip_document_separators. */
 static void fj_skip_document_separators(fj_state *st) {
   for (;;) {
+    int b;
     fj_skip_ws_comments(st);
-    if (fj_byte(st) != ',') break;
+    b = fj_byte(st);
+    if (b != ',' && b != 0x1E) break;
     fj_advance(st, 1);
   }
 }
@@ -1640,8 +1647,9 @@ static int fj_is_hws(int b) { return b == ' ' || b == '\t' || b == 0x0B || b ==
 
 /* After a top-level value: a self-delimiting value (object / array / string) may be
  * followed by anything, but a bare scalar (number / keyword) must be followed by a
- * real separator — a newline, ',', a comment, or EOF. A space is NOT a separator, so
- * `1 2 3` and `42 "x" true` raise. Mirrors the Ruby Parser#enforce_scalar_boundary. */
+ * real separator — a newline, ',', the RFC 7464 record separator (0x1E), a comment,
+ * or EOF. A space is NOT a separator, so `1 2 3` and `42 "x" true` raise. Mirrors the
+ * Ruby Parser#enforce_scalar_boundary. */
 static void fj_enforce_scalar_boundary(fj_state *st, VALUE value) {
   int b, nx;
   if (RB_TYPE_P(value, T_STRING) || RB_TYPE_P(value, T_HASH) || RB_TYPE_P(value, T_ARRAY)) return;
@@ -1655,7 +1663,7 @@ static void fj_enforce_scalar_boundary(fj_state *st, VALUE value) {
     break;
   }
   b = fj_byte(st);
-  if (b == -1 || b == 0x0A || b == 0x0D || b == ',') return;
+  if (b == -1 || b == 0x0A || b == 0x0D || b == ',' || b == 0x1E) return;
   if (b == '#') return;
   if (b == '/') { nx = fj_byte_at(st, 1); if (nx == '/' || nx == '*') return; }
   fj_error(st, "a top-level number or keyword must be followed by a newline, ',', or end of input");

data/lib/smarter_json/parser.rb

@@ -384,6 +384,7 @@ module SmarterJSON
     TAB        = 0x09
     LF         = 0x0A
     CR         = 0x0D
+    RS         = 0x1E # RFC 7464 record separator — frames each JSON Text Sequence record
   end
 
   module Framer
@@ -1052,13 +1053,14 @@ module SmarterJSON
       parse_iter(implicit_root_object_ahead?)
     end
 
-    # Between top-level documents, whitespace, comments, AND commas all separate
-    # (commas collapse like the in-container lenient-comma rule). A space alone never
-    # separates — that is handled inside the document by the quoteless run, so
+    # Between top-level documents, whitespace, comments, commas, AND the RFC 7464
+    # record separator (0x1E) all separate (commas collapse like the in-container
+    # lenient-comma rule; 0x1E frames each JSON Text Sequence record). A space alone
+    # never separates — that is handled inside the document by the quoteless run, so
     # `1 2 3` is one document (the string "1 2 3") while `1, 2, 3` is three.
     def skip_document_separators
       skip_whitespace_and_comments
-      while byte == COMMA
+      while (b = byte) == COMMA || b == RS
         advance(1)
         skip_whitespace_and_comments
       end
@@ -1066,15 +1068,16 @@ module SmarterJSON
 
     # After a top-level value: a self-delimiting value (object / array / quoted string)
     # may be followed by anything (the next document self-delimits), but a bare scalar
-    # (number / keyword) must be followed by a real separator — a newline, ',', a
-    # comment, or EOF. A space is NOT a separator, so `1 2 3` and `42 "x" true` raise
-    # rather than silently splitting; bare top-level words raise in parse_value itself.
+    # (number / keyword) must be followed by a real separator — a newline, ',', the RFC
+    # 7464 record separator (0x1E), a comment, or EOF. A space is NOT a separator, so
+    # `1 2 3` and `42 "x" true` raise rather than silently splitting; bare top-level
+    # words raise in parse_value itself.
     def enforce_scalar_boundary(value)
       return if value.is_a?(String) || value.is_a?(Hash) || value.is_a?(Array)
 
       skip_horizontal_whitespace
       b = byte
-      return if b.nil? || b == LF || b == CR || b == COMMA
+      return if b.nil? || b == LF || b == CR || b == COMMA || b == RS
       return if b == HASH || (b == SLASH && ((c = byte_at(1)) == SLASH || c == STAR))
 
       raise error("a top-level number or keyword must be followed by a newline, ',', or end of input")
@@ -1922,6 +1925,7 @@ module SmarterJSON
     # --- numbers (top-level / strict positions) ---
 
     def parse_number
+      token_start = @pos
       negative = false
       signed = false
       if byte == MINUS
@@ -1942,7 +1946,6 @@ module SmarterJSON
         return Float::NAN
       end
 
-      int_start = @pos
       had_leading_zero = false
 
       if byte == ZERO
@@ -1998,9 +2001,13 @@ module SmarterJSON
         raise error("invalid number with a leading zero")
       end
 
-      slice = @input.byteslice(int_start, @pos - int_start).delete("_")
-      value = is_float ? decimal_value(slice) : slice.to_i
-      negative ? -value : value
+      # token_start sits BEFORE the sign, so the slice keeps it ("-1e400", not "1e400"):
+      # decimal_value -> float_or_warn sees the signed token, and a negative overflow
+      # warns "collapsed to -Infinity" — the same warning numeric_value produces for a
+      # member-position number. String#to_i, String#to_f, and BigDecimal() all parse
+      # the leading sign, so there is no negation step here.
+      slice = @input.byteslice(token_start, @pos - token_start).delete("_")
+      is_float ? decimal_value(slice) : slice.to_i
     end
 
     def hex_digit?(b)

data/lib/smarter_json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SmarterJSON
-  VERSION = "1.2.4"
+  VERSION = "1.2.6"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: smarter_json
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.6
 platform: ruby
 authors:
 - Tilo Sloboda
 bindir: exe
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal