json-repair 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef10e86ea82fb56d9666ad7470317cf751f00730ef51910094ce8b2ee876a53
-  data.tar.gz: 682f0cdacc02896687e6c39e534f92f0beda52110679da8b7b7f43721aa6c2a4
+  metadata.gz: 3e0898f751c91f7c3a026ccb107c319b983212296090031ba6b7a80713de18eb
+  data.tar.gz: 21028aa56a685b77ea42506333753deb1a903108b860843a877181b6af66b1a2
 SHA512:
-  metadata.gz: 572225e5c09ac6ab7795d21d179e9ac07bc2c3bffedb5f1df48afa5a33ab8a73923af90429730532a822f3a78004181f3a9d2d7a2bddf17b9b649819b169ec65
-  data.tar.gz: a62311d2002b538b81132f6efb8525e6c6801baaa5a8f9eac020abbc2726e5ed783ee2719aeed9dc77301492f869f79deb807b9eee74f3a56e0a37d4712b7279
+  metadata.gz: 05752fda1b0ff27c2dcde8b217099460bdecb57efa4a3ab73ce534f27dfecf51673f68683f3009c8d159079bfb7fee3f0892f2c86e3f15d0e86a58d4c497c8f0
+  data.tar.gz: 46a8a689d2a969c3c7ca1395dbd4a5555e191e304c0cfffd3bbaec44d22066b2a8527efc7323267c62c21738364c2dddf917d20af3388ae87cf993d872d014a0

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changes
 
+### 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:
+  `{"a": 1 # comment\n}` → `{"a":1}`, `{ # note\n "a": 1}` →
+  `{"a":1}`, `# lead\n{"a": 1}` → `{"a":1}`. Divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (v3.14.0
+  raises on all of these), commented at the site. Recognition is
+  context-aware so unquoted values starting with `#` keep repairing
+  into strings — `{"color": #ff0000}` → `{"color":"#ff0000"}`,
+  `{#tag: 1}` → `{"#tag":1}`, `#standalone` → `"#standalone"` — where
+  Python's `json_repair` silently loses them (`{"color": ""}`).
+  Where a value or key is expected, a `#` token reaching a structural
+  delimiter (`,` `}` `]` `:`) before any whitespace, or running to
+  end-of-input without a newline, stays a value; anything else is a
+  comment stripped to the end of the line. The tradeoff: a `#` token
+  followed by whitespace or a newline at a value position now reads
+  as a comment — `{"a": #b c}` → `{"a":null}` and `{"a": #tag\n}` →
+  `{"a":null}`, where 0.12.0 kept them as strings (Python drops them
+  too), and a comment-only document now raises like `// only a
+  comment` always has. Pinned in the spec suite as conscious
+  decisions.
+
 ### 2026-06-12 (0.12.0)
 
 * Repair the three known input families that raised `Internal error:

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.12.0'
+    VERSION = '0.14.0'
   end
 end

data/lib/json/repairer.rb

@@ -71,7 +71,7 @@ module JSON
       # repair redundant end quotes
       while [CLOSING_BRACE, CLOSING_BRACKET].include?(@json[@index])
         @index += 1
-        parse_whitespace_and_skip_comments
+        parse_whitespace_and_skip_comments(value_expected: false)
       end
 
       if @index >= @json.length
@@ -93,17 +93,17 @@ module JSON
                 parse_keywords ||
                 parse_unquoted_string(false) ||
                 parse_regex
-      parse_whitespace_and_skip_comments
+      parse_whitespace_and_skip_comments(value_expected: false)
 
       process
     end
 
-    def parse_whitespace_and_skip_comments(skip_newline: true)
+    def parse_whitespace_and_skip_comments(skip_newline: true, value_expected: true)
       start = @index
 
       changed = parse_whitespace(skip_newline: skip_newline)
       loop do
-        changed = parse_comment
+        changed = parse_comment(value_expected: value_expected)
         changed = parse_whitespace(skip_newline: skip_newline) if changed
         break unless changed
       end
@@ -131,7 +131,7 @@ module JSON
       false
     end
 
-    def parse_comment
+    def parse_comment(value_expected: true)
       if @json[@index] == '/' && @json[@index + 1] == '*'
         # Block comment
         @index += 2
@@ -143,11 +143,42 @@ module JSON
         @index += 2
         @index += 1 until @json[@index].nil? || @json[@index] == "\n"
         true
+      elsif @json[@index] == '#' && hash_comment?(value_expected)
+        # Hash line comment, like in Python, YAML, or Hjson (divergence
+        # from upstream, which raises on `#` as of v3.14.0)
+        @index += 1
+        @index += 1 until @json[@index].nil? || @json[@index] == "\n"
+        true
       else
         false
       end
     end
 
+    # Decide whether the `#` at @index starts a line comment or an
+    # unquoted value like {"color": #ff0000}, {#tag: 1}, or a root
+    # #hashtag (which Python's json_repair eats as comments, losing
+    # data). Where no value or key is expected an unquoted token would
+    # be junk anyway, so `#` is always a comment, exactly like `//`.
+    # Where one is expected, scan the rest of the line: a structural
+    # delimiter (`,` `}` `]` `:`) before any whitespace means the token
+    # reads as a value in context; whitespace (including the newline
+    # itself) first means comment prose; reaching EOF without a newline
+    # keeps the token a value, so truncated input like {"a": #tag is
+    # repaired, not dropped. Divergence from upstream, as above.
+    def hash_comment?(value_expected)
+      return true unless value_expected
+
+      i = @index + 1
+      while (char = @json[i])
+        return true if whitespace_or_special?(char)
+        return false if [COMMA, COLON, CLOSING_BRACE, CLOSING_BRACKET].include?(char)
+
+        i += 1
+      end
+
+      false
+    end
+
     # Find and skip over a Markdown fenced code block:
     #     ``` ... ```
     # or
@@ -268,7 +299,7 @@ module JSON
           break
         end
 
-        parse_whitespace_and_skip_comments
+        parse_whitespace_and_skip_comments(value_expected: false)
         processed_colon = parse_character(COLON)
         truncated_text = @index >= @json.length
         unless processed_colon
@@ -491,7 +522,7 @@ module JSON
           @index += 1
           @output << str
 
-          parse_whitespace_and_skip_comments(skip_newline: false)
+          parse_whitespace_and_skip_comments(skip_newline: false, value_expected: false)
 
           if stop_at_delimiter ||
              @index >= @json.length ||
@@ -710,6 +741,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?
@@ -771,7 +820,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/)
@@ -846,11 +897,11 @@ module JSON
     def parse_concatenated_string
       processed = false
 
-      parse_whitespace_and_skip_comments
+      parse_whitespace_and_skip_comments(value_expected: false)
       while @json[@index] == PLUS
         processed = true
         @index += 1
-        parse_whitespace_and_skip_comments
+        parse_whitespace_and_skip_comments(value_expected: false)
 
         # repair: remove the end quote of the first string
         @output = strip_last_occurrence(@output, '"', strip_remaining_text: true)
@@ -877,7 +928,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

@@ -37,7 +37,9 @@ module JSON
 
     def parse_whitespace: (?skip_newline: bool) -> bool
 
-    def parse_comment: () -> bool
+    def parse_comment: (?value_expected: bool) -> bool
+
+    def hash_comment?: (bool value_expected) -> bool
 
     # Find and skip over a Markdown fenced code block
     def parse_markdown_code_block: (::Array[::String] blocks) -> bool
@@ -87,7 +89,7 @@ module JSON
 
     def parse_character: (::String char) -> bool
 
-    def parse_whitespace_and_skip_comments: (?skip_newline: bool) -> bool
+    def parse_whitespace_and_skip_comments: (?skip_newline: bool, ?value_expected: bool) -> bool
 
     # Parse a number like 2.4 or 2.4e6
     def parse_number: () -> bool

metadata

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