json-repair 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf5d06053ce264da6b60de4beef4a5718fd3482c81d295deea6dbf90fc63c098
-  data.tar.gz: 9d343f549cf34414e0de45618cb19bd4a9b58b12e53c2f52da0380fc73b4d95a
+  metadata.gz: fc8c6dfaa0c00f4f8dcf62be1f5bd925fe1af4b0649a7986bf4354f85f1d27bd
+  data.tar.gz: dd91d930dfe19c7796e02898202e51b9cd573b0af51c632c975689a2882e2851
 SHA512:
-  metadata.gz: 269f7de75ec6cadde857d2f7c10186b1d0c63a19aa3e863744957c95b98db8d0cef790deef8814d532ca62c0405d97cfc5f441c37be9f1c4e6c7f5cfe07eaa67
-  data.tar.gz: 9cbc099462defe41b8bf96f590833d61de90f79c8e5b0f2d8a7d0ae04ee72dcc7e512c6f3886f67cb0e700dfb1046abd143b2adbde560c502d25700035e69834
+  metadata.gz: 5db30ce96f442ae57ff311a93481f9c991be8b3b13e45042d9abdd6a9f0562e0a43ef2eafaf40095528104f59bee7e19753b03e4376ac170071d83f66fe1c2ca
+  data.tar.gz: 3a4129cc0b8faefa3ded17ea4f3440d623bcc7972444dd2cd2d0a2f0884fcb1059017059599962370b44e2677a45e2ad8862bdf7174cc99487ff9566745fd010

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changes
 
+### 2026-06-17 (0.15.0)
+
+* Repair elided empty array slots: `[1,,2]` → `[1,2]`, `[1,,,,2]` →
+  `[1,2]`, `[1, ,2]` → `[1,2]`, and `[,,1]` → `[1]`. A comma with no
+  value between it and the previous one (or the opening bracket) marks
+  an empty slot, which is dropped — uniformly extending the existing
+  single-leading-comma repair (`[,1]` → `[1]`) to repeated and interior
+  positions, and consistent with `dirty-json`. Divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair), which as of
+  v3.14.0 mangles `[1,,2]`/`[,,1]` into `[[1],2]`/`[[],1]` (its root
+  comma-sequence wrap misfires) and raises on `[1,,,,2]`; commented at
+  the site. Arrays only: an elided comma in an object
+  (`{"a":1,,"b":2}`) still raises rather than guessing a missing key —
+  there is no data to mangle, so the clean error is kept (and pinned in
+  the spec). Differential vs main over a comma grid: every change is an
+  array with elided commas going from mangle/raise to a correct drop,
+  with objects and all non-elided shapes unchanged. Benchmarks flat.
+
+### 2026-06-17 (0.14.0)
+
+* Repair a leading `+` on numbers, like in JSON5: `+1.23` → `1.23`,
+  `[+1]` → `[1]`, `{"a": +5}` → `{"a":5}`, `+.5` → `0.5`. The `+` is
+  consumed and dropped (JSON has no explicit plus), so a leading-zero
+  number is quoted exactly like its unsigned form (`+05` → `"05"`),
+  while a `+` inside an exponent is left untouched (`2e+5` →
+  `200000.0`). The `+` must be followed by a digit or a leading dot, so
+  a bare `+` (and `+abc`, `++1`, `+e5`) still raises — and requiring a
+  digit/dot keeps the 0.12.0 empty-mantissa exponent guard intact.
+  Divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (v3.14.0 leaves
+  `+1.23` unrepaired, raising "Unexpected end of json string"),
+  commented at the site. Mirrors the leading-dot number repair (0.9.0).
+
 ### 2026-06-12 (0.13.0)
 
 * Repair `#` hash line comments, like in Python, YAML, or Hjson:

data/CLAUDE.md

@@ -24,7 +24,7 @@ A few repair heuristics deliberately go **beyond** upstream (leading-dot numbers
 
 ### Entry point
 
-`JSON.repair(str)` in `lib/json/repair.rb` first tries stdlib `JSON.parse` (fast path; opt out with `skip_json_loads: true`), and falls back to `JSON::Repairer.new(str).repair` when that raises. Either way the result is re-serialized with `JSON.generate`, so **output is canonical** — whitespace collapsed, numbers normalized, duplicate keys last-write-wins — and both paths agree on it. A `REPAIR_REQUIRED_PATTERN` regex routes inputs containing comments or invalid escapes straight to the Repairer even though the bundled `json` gem would accept them. `return_objects: true` returns the parsed Ruby value instead of a string; `JSON.repair_file(path)` / `JSON.repair_io(io)` are convenience wrappers forwarding both options.
+`JSON.repair(str)` in `lib/json/repair.rb` first tries stdlib `JSON.parse` (fast path; opt out with `skip_json_loads: true`), and falls back to `JSON::Repairer.new(str).repair` when that raises. Either way the result is re-serialized with `JSON.generate`, so **output is canonical** — whitespace collapsed, numbers normalized, duplicate keys last-write-wins — and both paths agree on it. There is no pre-filter regex: the fast path simply runs `JSON.parse` and falls back to the Repairer on any `JSON::ParserError`. Comments are handled either way — the bundled `json` gem currently accepts `//` and `/*` comments (an implementation detail, not part of the `JSON.parse` contract) and `JSON.generate` drops them (`{} // c` → `{}`); were a future `json` release to reject them, they would simply raise and route to the Repairer, which strips comments too. Invalid escapes, NDJSON, Markdown fences, and trailing prose already make `JSON.parse` raise and so route to the Repairer. `return_objects: true` returns the parsed Ruby value instead of a string; `JSON.repair_file(path)` / `JSON.repair_io(io)` are convenience wrappers forwarding both options.
 
 `JSON::JSONRepairError` is the only error raised for unrecoverable inputs; it exposes the failure `#position`. If the Repairer ever emits a string stdlib cannot parse (a Repairer bug), the `JSON::ParserError` is wrapped in `JSONRepairError` rather than leaked.
 

data/lib/json/repair/version.rb

@@ -2,6 +2,6 @@
 
 module JSON
   module Repair
-    VERSION = '0.13.0'
+    VERSION = '0.15.0'
   end
 end

data/lib/json/repairer.rb

@@ -434,6 +434,24 @@ module JSON
       end
     end
 
+    # Repair elided empty array slots like [1,,2] or [1,,,,2]. Called both
+    # at the start of an array (leading commas) and right after a separator
+    # comma: skip every comma found here (each marks a slot with no value
+    # between it and the previous one or the opening bracket), so [1,,2] ->
+    # [1,2], [1,,,,2] -> [1,2], and [,,1] -> [1]. Dropping the slot — rather
+    # than inserting null — extends the single-leading-comma repair ([,1] ->
+    # [1]) uniformly. Divergence from upstream, which mangles [1,,2] into
+    # [[1],2] via its root comma-sequence wrap and raises on [1,,,,2] (as of
+    # v3.14.0).
+    def skip_elided_commas
+      loop do
+        parse_whitespace_and_skip_comments
+        break unless @json[@index] == COMMA
+
+        @index += 1
+      end
+    end
+
     # Parse a string enclosed by double quotes "...". Can contain escaped quotes
     # Repair strings enclosed in single quotes or special quotes
     # Repair an escaped string
@@ -741,6 +759,24 @@ module JSON
     # Parse a number like 2.4 or 2.4e6
     def parse_number
       start = @index
+
+      # Divergence from upstream: accept and discard a leading "+". JSON5
+      # permits an explicit plus; JSON does not, so "+1.23" -> "1.23" and
+      # "{"a": +5}" -> {"a":5}. The "+" must be followed by a digit or a
+      # leading dot (mirroring the "-" branch below); otherwise this is not
+      # a number and we backtrack to the "+" so a bare "+" still raises.
+      # `start` stays on the "+", so the reset paths restore @index cleanly
+      # and the @index > start exponent guard below still implies a digit
+      # was consumed; the two emission sites drop the leading "+" before
+      # quoting. Upstream leaves "+1.23" unrepaired.
+      if @json[@index] == PLUS
+        @index += 1
+        unless digit?(@json[@index]) || @json[@index] == DOT
+          @index = start
+          return false
+        end
+      end
+
       if @json[@index] == '-'
         @index += 1
         if at_end_of_number?
@@ -802,7 +838,9 @@ module JSON
 
       if @index > start
         # repair a number with leading zeros like "00789"
-        num = @json[start...@index]
+        # drop a leading "+" first (see the PLUS branch above), so "+05"
+        # quotes like "05" and "+1.23" emits as "1.23"
+        num = @json[start...@index].delete_prefix(PLUS)
         # the optional sign quotes "-05" like "05" (divergence from
         # upstream, whose unsigned check lets "-05" through unrepaired)
         has_invalid_leading_zero = num.match?(/^-?0\d/)
@@ -825,8 +863,9 @@ module JSON
         @index += 1
         parse_whitespace_and_skip_comments
 
-        # repair: skip leading comma like in [,1,2,3]
-        parse_whitespace_and_skip_comments if skip_character(COMMA)
+        # repair: skip leading commas (elided empty slots) like [,1,2,3]
+        # or [,,1] — the same drop applied after a separator comma below
+        skip_elided_commas
 
         initial = true
         while @index < @json.length && @json[@index] != CLOSING_BRACKET
@@ -837,6 +876,8 @@ module JSON
             processed_comma = parse_character(COMMA)
             # repair missing comma
             @output = insert_before_last_whitespace(@output, ',') unless processed_comma
+            # repair: drop elided empty slots like [1,,2] -> [1,2]
+            skip_elided_commas if processed_comma
           end
 
           skip_ellipsis
@@ -908,7 +949,8 @@ module JSON
       # repair numbers cut off at the end
       # this will only be called when we end after a '.', '-', or 'e' and does not
       # change the number more than it needs to make it valid JSON
-      num = "#{@json[start...@index]}0"
+      # delete_prefix drops a leading "+" (see the PLUS branch in parse_number)
+      num = "#{@json[start...@index]}0".delete_prefix(PLUS)
       # quote a padded token that has an invalid leading zero, like "05e" ->
       # "05e0", applying the same rule as the end of parse_number (divergence
       # from upstream, which emits the invalid number raw)

data/sig/json/repairer.rbs

@@ -66,6 +66,9 @@ module JSON
     # or a similar construct in objects.
     def skip_ellipsis: () -> void
 
+    # Drop elided empty array slots like [1,,2] -> [1,2].
+    def skip_elided_commas: () -> void
+
     # Parse a string enclosed by double quotes "...". Can contain escaped quotes
     # Repair strings enclosed in single quotes or special quotes
     # Repair an escaped string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-repair
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Aleksandr Zykov