json-repair 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4892b62960d0c4d27976577c506585ea8df11bfbf14dc1a9b40952947ad1f20
-  data.tar.gz: fe26e3da464e5356bd33021e5b08a7a1f1ad938e125f0ef384777ff64b13f813
+  metadata.gz: fdf2958528b936eba0faf6c724a20d10a3a3e0b95329bc1866740c99432f6fe3
+  data.tar.gz: 33fa97d2c7689ea594723e5d0d412646cf57a2ebdbf79f3b62947d4928963f32
 SHA512:
-  metadata.gz: 4cf46eae9e05e718c978e7a503578bd867bacce1b71565764ec88af8b762f498ceceada6ce37d73663e6bcff56b85013746c7a82e84eda6eb55ed57e3535fe0d
-  data.tar.gz: f2fc802dd1bfbd26bb04f34ca2902189d11537d4bbbebc131d14ef7672bcd9f2dd01bcc2157182ba6801eea0f92693883086197013add4f86f69e6fcf32e5a3b
+  metadata.gz: 587323c57caac3e53af1da24cfeee47df18ff738516d8fd2862d37a547c6e864cf5653c8b43427ec58aa47be3f2e958c991208b36de098c5ffc9503f2c64a0a2
+  data.tar.gz: f5380cfdca6a4f60833ab57fc8465715b546415fa4f6ed5781b6bb24653ce324d2b6d928f9a5ff87b4deead145391303c1e805bf0fbff238b9ef1c7024a1f4aa

data/.rubocop.yml

@@ -19,6 +19,7 @@ Metrics/AbcSize:
 Metrics/MethodLength:
   Exclude:
     - lib/json/repairer.rb
+    - benchmark/**/*
 
 Metrics/CyclomaticComplexity:
   Exclude:

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changes
 
+### 2026-05-12 (0.7.0)
+
+* `JSON.repair` now always returns canonical JSON via
+  `JSON.generate`. When the input is already valid JSON, stdlib
+  `JSON.parse` handles it directly; when it isn't, the repairer
+  produces an intermediate string that's then re-parsed and serialized
+  the same way. Both paths converge on the same output for any given
+  input, so `JSON.repair(json)` and
+  `JSON.repair(json, skip_json_loads: true)` agree on result and only
+  differ in how they got there.
+* **Breaking:** outputs are now canonical instead of preserving the
+  input's exact formatting. Whitespace is collapsed
+  (`'{"a": 1}'` → `'{"a":1}'`), numbers are normalized
+  (`2300e3` → `2300000.0`, `-0` → `0`), `\uXXXX` escapes are decoded
+  to their literal characters, `\/` is unescaped to `/`, and objects
+  with duplicate keys are collapsed to the last-write-wins form
+  (`{"a":1,"a":2}` → `{"a":2}`). Callers that need a parsed Ruby
+  value can opt out of the final `JSON.generate` step with
+  `return_objects: true`.
+* `skip_json_loads:` keyword argument added (default `false`,
+  mirroring Python's
+  [`json_repair`](https://github.com/mangiucugna/json_repair)
+  option). Passing `true` skips the stdlib `JSON.parse` fast attempt
+  and routes the input through the repairer first; the final output
+  is identical, so the option is purely a performance knob for
+  callers who know their input will need repair.
+
 ### 2026-05-12 (0.6.0)
 
 * `JSON.repair` accepts a `return_objects:` keyword argument. Pass

data/README.md

@@ -26,7 +26,7 @@ require 'json/repair'
 # Example of repairing a JSON string
 broken_json = '{name: Alice, "age": 25,}'
 repaired_json = JSON.repair(broken_json)
-puts repaired_json  # Outputs: {"name": "Alice", "age": 25}
+puts repaired_json  # Outputs: {"name":"Alice","age":25}
 ```
 
 The `repair` method takes a string containing JSON data and returns a corrected version of this string, ensuring it is valid JSON.
@@ -38,6 +38,21 @@ JSON.repair('{a: 1, b: [2, 3,]}', return_objects: true)
 # => {"a" => 1, "b" => [2, 3]}
 ```
 
+### Canonical output
+
+`JSON.repair` returns canonical JSON via `JSON.generate`. When the input is already valid, stdlib `JSON.parse` handles it; otherwise the repairer fixes it up and the result is re-serialized the same way. Either way, the output is the canonical form of the parsed value — whitespace is collapsed, numbers are normalized, `\uXXXX` escapes are decoded to literal characters, and objects with duplicate keys collapse to last-write-wins.
+
+```ruby
+JSON.repair('{"a": 1}')          # => '{"a":1}'
+JSON.repair('{a:1}')             # => '{"a":1}'
+JSON.repair('2300e3')            # => '2300000.0'
+JSON.repair('{"a":1,"a":2}')     # => '{"a":2}'
+```
+
+If you need the parsed Ruby value instead of a string, pass `return_objects: true` (covered above).
+
+`skip_json_loads: true` skips the stdlib `JSON.parse` attempt and routes the input straight through the repairer. The output is the same; the option is purely a performance knob for callers who know their input will need repair.
+
 ## Command line
 
 The gem ships a `json-repair` executable. It reads from stdin or a file and writes to stdout, `--output FILE`, or back over the input file with `--overwrite`.
@@ -57,6 +72,8 @@ Run `json-repair --help` for the full list of options.
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+Run `bundle exec rake bench` for a `benchmark-ips` regression baseline across four canned scenarios (valid mixed JSON, broken LLM-style output, a large array, deeply nested objects). The harness lives under `benchmark/` and is not shipped in the published gem.
+
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing

data/Rakefile

@@ -19,4 +19,9 @@ task :steep do
   sh 'bundle exec steep check'
 end
 
+desc 'Run benchmark/run.rb (regression baseline for JSON.repair)'
+task :bench do
+  ruby '-Ilib', 'benchmark/run.rb'
+end
+
 task default: %i[spec rubocop rbs steep]

data/lib/json/repair/cli.rb

@@ -75,8 +75,7 @@ module JSON
         elsif (output_path = @output_path)
           File.write(output_path, repaired)
         else
-          @stdout.write(repaired)
-          @stdout.write("\n") unless repaired.end_with?("\n")
+          @stdout.write(repaired, "\n")
         end
       end
 

data/lib/json/repair/version.rb

@@ -2,6 +2,6 @@
 
 module JSON
   module Repair
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
   end
 end

data/lib/json/repair.rb

@@ -15,8 +15,20 @@ module JSON
     end
   end
 
-  def self.repair(json, return_objects: false)
-    repaired = Repairer.new(json).repair
-    return_objects ? JSON.parse(repaired) : repaired
+  def self.repair(json, return_objects: false, skip_json_loads: false)
+    parsed = skip_json_loads ? repaired_parse(json) : tolerant_parse(json)
+    return_objects ? parsed : JSON.generate(parsed)
   end
+
+  def self.tolerant_parse(json)
+    JSON.parse(json)
+  rescue JSON::ParserError
+    repaired_parse(json)
+  end
+  private_class_method :tolerant_parse
+
+  def self.repaired_parse(json)
+    JSON.parse(Repairer.new(json).repair)
+  end
+  private_class_method :repaired_parse
 end

data/sig/json/repair.rbs

@@ -9,7 +9,13 @@ module JSON
     VERSION: ::String
   end
 
-  def self.repair: (::String json) -> ::String
-                 | (::String json, return_objects: false) -> ::String
-                 | (::String json, return_objects: true) -> untyped
+  def self.repair: (::String json, return_objects: false, ?skip_json_loads: bool) -> ::String
+                 | (::String json, return_objects: true, ?skip_json_loads: bool) -> untyped
+                 | (::String json, ?skip_json_loads: bool) -> ::String
+
+  private
+
+  def self.tolerant_parse: (::String json) -> untyped
+
+  def self.repaired_parse: (::String json) -> untyped
 end

metadata

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