json_mend 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dcc378c148dc0514753b966693e0afe286bf145c283d069f01c0b9c74f59a75
-  data.tar.gz: 37fa52116d57bc80b168c20feba1fd7b33edab73d1f157759bc71f4a3362802b
+  metadata.gz: 908b32104f5db7f667ee3d7f1273b43b5ae8d7e79193d40953a5d70c0e2c4afd
+  data.tar.gz: 8180522b11afd6b43414f67118361b6fc11b83d7afa0b8d8ef189d003a3995c2
 SHA512:
-  metadata.gz: c94ff3c9d0c2e3602b6a125e74fdc72896709b311221eeceeecd3fbf96b0aef8dc82edfed136512443b5ccc403d512d7beb3476c59732f1a04280a71bbf7de5b
-  data.tar.gz: f3603aa1d247686329ec0effe5d1819f4feec47cb43adbff520ed7695831cc30649fa99b4e21a51d4e460754af3d825480335cea10ffbb79feea773fabfa1cd9
+  metadata.gz: b70fe8447456214a9fe13d7f2129b3d667687b652c3a7513cfb2385c90b86cffd3e2082a0bb2355610721ec5e688a83ad2ed83a7dd281cd9a9ad034c5c5ca4b1
+  data.tar.gz: 88dc8bdc36dedd7869223e5270f3c9e6e7cdfb8359700711ae1e7329355326f220d16a39b919565a5c50f9ab885dc79684a9d0c8dfb110abb329a4a7375dfd4e

data/.rubocop.yml

@@ -1,9 +1,18 @@
+inherit_mode:
+  merge:
+    - Exclude
+
 plugins:
   - rubocop-performance
   - rubocop-rspec
+  - rubocop-rake
 
 AllCops:
   NewCops: enable
+  ParserEngine: parser_prism
+  CacheRootDirectory: .rubocop_cache
+  MaxFilesInCache: 8000
+  UseCache: false
   SuggestExtensions: false
 
 Metrics/AbcSize:

data/.tool-versions

@@ -1 +1 @@
-ruby 4.0.2
+ruby 4.0.7

data/benchmark_comparison.rb

@@ -33,6 +33,16 @@ TEST_CASES = {
     label: 'Valid Single JSON',
     input: json_object
   },
+  return_objects: {
+    label: 'Valid JSON (Return Ruby Objects)',
+    input: json_object,
+    return_objects: true
+  },
+  generator_error: {
+    label: 'Valid Syntax but Invalid UTF-8 (GeneratorError)',
+    input: "{\"status\": \"ok\", \"data\": \"bad\xFFbyte\"}",
+    return_objects: true
+  },
   concatenated: {
     label: 'Concatenated JSON (x10)',
     input: json_object * 10
@@ -116,13 +126,18 @@ TEST_CASES.each_value do |data|
   puts "\n\n🔸 Scenario: #{data[:label]}"
   puts '-' * 40
 
+  # Check if this specific test requires returning objects instead of a string
+  return_objs = data.fetch(:return_objects, false)
+
   Benchmark.ips do |x|
     x.config(time: 2, warmup: 1) # Short duration for quick checks
 
     # 1. JsonMend
-    if supported?(->(i) { JsonMend.repair(i) }, data[:input])
+    mend_proc = ->(i) { JsonMend.repair(i, return_objects: return_objs) }
+
+    if supported?(mend_proc, data[:input])
       x.report('JsonMend') do
-        JsonMend.repair(data[:input])
+        JsonMend.repair(data[:input], return_objects: return_objs)
       end
     else
       puts '   JsonMend: ❌ Not Supported'
@@ -130,9 +145,12 @@ TEST_CASES.each_value do |data|
 
     # 2. json-repair
     if defined?(JSON::Repair)
-      if supported?(->(i) { JSON.repair(i) }, data[:input])
+      # For a fair comparison, if return_objects is true, json-repair must also parse its own output
+      repair_proc = ->(i) { return_objs ? JSON.parse(JSON.repair(i)) : JSON.repair(i) }
+
+      if supported?(repair_proc, data[:input])
         x.report('json-repair') do
-          JSON.repair(data[:input])
+          return_objs ? JSON.parse(JSON.repair(data[:input])) : JSON.repair(data[:input])
         end
       else
         puts '   json-repair: ❌ Not Supported'

data/lib/json_mend/parser.rb

@@ -7,9 +7,9 @@ module JsonMend
   # The core parser that does the heavy lifting of fixing the JSON
   class Parser
     MAX_ALLOWED_DEPTH = 100
-    COMMENT_DELIMETERS = ['#', '/'].freeze
+    COMMENT_DELIMETERS = '#/'
     NUMBER_CHARS = Set.new('0123456789-.eE/,_'.chars).freeze
-    STRING_DELIMITERS = ['"', "'", '“', '”'].freeze
+    STRING_DELIMITERS = "\"'“”"
     SKIP_CHARS_REGEX_CACHE = {
       '"' => /"/,
       "'" => /'/,
@@ -29,12 +29,12 @@ module JsonMend
 
     # Optimized constants for performance (CollectionLiteralInLoop)
     TERMINATORS_ARRAY = [']', '}'].freeze
-    TERMINATORS_OBJECT_KEY = [':', '}'].freeze
-    TERMINATORS_OBJECT_VALUE = [',', '}'].freeze
+    TERMINATORS_OBJECT_KEY = ':}'
+    TERMINATORS_OBJECT_VALUE = ',}'
     TERMINATORS_ARRAY_ITEM = [',', ']'].freeze
-    TERMINATORS_STRING_GUESSED = ['{', '}', '[', ']', ':', ','].freeze
-    TERMINATORS_VALUE = [',', ']', '}'].freeze
-    STRING_OR_OBJECT_START = (STRING_DELIMITERS + ['{', '[']).freeze
+    TERMINATORS_STRING_GUESSED = '{}[],:'
+    TERMINATORS_VALUE = ',]}'
+    STRING_OR_OBJECT_START = "#{STRING_DELIMITERS}{[".freeze
     SKIPPED_KEYS = %i[merged_array stray_colon].freeze
     BOOLEAN_OR_NULL_CHARS = %w[t f n].freeze
     ESCAPE_START_CHARS = %w[t n r b \\].freeze
@@ -42,6 +42,7 @@ module JsonMend
     INVALID_NUMBER_TRAILERS = ['-', 'e', 'E', ','].freeze
 
     # Pre-compile regexes for performance
+    STRING_START_REGEX = /[\p{L}$_]/
     NUMBER_REGEX = /[#{Regexp.escape(NUMBER_CHARS.to_a.join)}]+/
     NUMBER_NO_COMMA_REGEX = /[#{Regexp.escape(NUMBER_CHARS.dup.tap { |s| s.delete(',') }.to_a.join)}]+/
     INVALID_NUMBER_TRAILERS_REGEX = /[#{Regexp.union(*INVALID_NUMBER_TRAILERS)}]+\z/
@@ -53,6 +54,8 @@ module JsonMend
     def initialize(json_string)
       @scanner = StringScanner.new(json_string)
       @context = []
+      @context_counts = Hash.new(0)
+      @current_context = nil
       @depth = 0
     end
 
@@ -138,12 +141,12 @@ module JsonMend
         when '['
           @scanner.getch # consume '['
           return parse_array
-        when *COMMENT_DELIMETERS
+        when '#', '/' # sync with COMMENT_DELIMETERS, not used *COMMENT_DELIMETERS for branch speed optimization
           # Avoid recursion: consume comment and continue loop
           parse_comment
         else
           if string_start?(char)
-            if @context.empty? && !STRING_DELIMITERS.include?(char)
+            if @context.empty? && char && !STRING_DELIMITERS.include?(char)
               # Top level unquoted string strictness:
               # Only allow literals (true/false/null), ignore other text as garbage
               val = parse_literal
@@ -161,7 +164,7 @@ module JsonMend
           else
             # Stop if we hit a terminator for the current context to avoid consuming it as garbage
             if (current_context?(:array) && char == ']') ||
-               (current_context?(:object_value) && TERMINATORS_OBJECT_VALUE.include?(char)) ||
+               (current_context?(:object_value) && char && TERMINATORS_OBJECT_VALUE.include?(char)) ||
                (current_context?(:object_key) && char == '}')
               return JSON_STOP_TOKEN
             end
@@ -178,14 +181,14 @@ module JsonMend
       with_depth_check do
         object = {}
 
-        @context.push(:object)
+        push_context(:object)
 
         loop do
           skip_whitespaces
 
           # Explicitly consume comments to ensure they don't hide separators (like commas)
           # or get parsed as part of the next key.
-          if COMMENT_DELIMETERS.include?(peek_char)
+          if peek_char && COMMENT_DELIMETERS.include?(peek_char)
             parse_comment
             next
           end
@@ -222,7 +225,7 @@ module JsonMend
           object[key] = value
         end
 
-        @context.pop
+        pop_context
 
         object
       end
@@ -250,17 +253,6 @@ module JsonMend
       # If we get an empty key and the next character is a closing brace, we're done.
       return [nil, nil, false] if key.empty? && (peek_char.nil? || peek_char == '}' || @scanner.pos == pos_before_key)
 
-      # Handle Duplicate Keys (Safer Method)
-      # This is a critical repair for lists of objects missing a comma separator.
-      if object.key?(key)
-        # Instead of rewriting the string, we safely rewind the scanner to the
-        # position before the duplicate key. This ends the parsing of the current
-        # object, allowing the top-level parser to see the duplicate key as the
-        # start of a new JSON object.
-        @scanner.pos = pos_before_key
-        return [nil, nil, false] # Signal to stop parsing this object.
-      end
-
       # Parse the Separator (:)
       skip_whitespaces
       colon_found = @scanner.skip(/:/) # Leniently skip the colon if it exists.
@@ -299,7 +291,7 @@ module JsonMend
       end
 
       # If no merge happened, proceed with standard key parsing.
-      @context.push(:object_key)
+      push_context(:object_key)
       is_bracketed = false
 
       if char == '['
@@ -310,7 +302,7 @@ module JsonMend
       else
         key = parse_string.to_s
       end
-      @context.pop
+      pop_context
 
       # If the key is empty, consume any stray characters to prevent infinite loops.
       @scanner.getch if key.empty? && !@scanner.check(/[:{\[}\]]/) && !@scanner.eos?
@@ -320,18 +312,18 @@ module JsonMend
 
     # Parses the value part of a key-value pair.
     def parse_object_value(colon_found: true)
-      @context.push(:object_value)
+      push_context(:object_value)
       skip_whitespaces
 
       # Handle cases where the value is missing (e.g. "key": } or "key": ,)
       if @scanner.eos? || @scanner.check(/[,}]/)
-        @context.pop
+        pop_context
         return colon_found ? '' : :inferred_true
       end
 
       # Delegate to the main JSON value parser.
       value = parse_json
-      @context.pop
+      pop_context
 
       # If parse_json returned JSON_STOP_TOKEN (nothing found due to garbage->terminator),
       # treat it as empty string for object values to be safe.
@@ -342,7 +334,7 @@ module JsonMend
     def try_to_merge_dangling_array(object)
       return false unless peek_char == '['
 
-      prev_key = object.keys.last
+      prev_key = object.keys[-1]
       return false unless prev_key && object[prev_key].is_a?(Array)
 
       @scanner.getch # Consume '['
@@ -365,7 +357,7 @@ module JsonMend
     def parse_array
       with_depth_check do
         arr = []
-        @context.push(:array)
+        push_context(:array)
         char = peek_char
         # Stop when you find the closing bracket or an invalid character like '}'
         while !@scanner.eos? && !TERMINATORS_ARRAY.include?(char)
@@ -373,14 +365,14 @@ module JsonMend
           char = peek_char
 
           # Check for comments explicitly inside array to avoid recursion or garbage consumption issues
-          if COMMENT_DELIMETERS.include?(char)
+          if char && COMMENT_DELIMETERS.include?(char)
             parse_comment
             char = peek_char
             next
           end
 
           value = ''
-          if STRING_DELIMITERS.include?(char)
+          if char && STRING_DELIMITERS.include?(char)
             # Sometimes it can happen that LLMs forget to start an object and then you think it's a string in an array
             # So we are going to check if this string is followed by a : or not
             # And either parse the string or parse the object
@@ -409,7 +401,7 @@ module JsonMend
         unless @scanner.scan(']')
           @scanner.scan('}') # Consume } if it was the closer
         end
-        @context.pop
+        pop_context
 
         arr
       end
@@ -422,7 +414,7 @@ module JsonMend
       char = peek_char
 
       # A valid string can only start with a valid quote or, in our case, with a literal
-      while !@scanner.eos? && !STRING_DELIMITERS.include?(char) && !char&.match?(/[\p{L}0-9$_-]/)
+      while !@scanner.eos? && char && !STRING_DELIMITERS.include?(char) && !char&.match?(/[\p{L}0-9$_-]/)
         return '' if TERMINATORS_STRING_GUESSED.include?(char)
 
         @scanner.getch
@@ -447,7 +439,7 @@ module JsonMend
 
       doubled_quotes = rest.first
 
-      string_parts = []
+      string_parts = +''
 
       # Here things get a bit hairy because a string missing the final quote can also be a key or a value in an object
       # In that case we need to use the ":|,|}" characters as terminators of the string
@@ -510,13 +502,13 @@ module JsonMend
       doubled_quotes = false
 
       # There is sometimes a weird case of doubled quotes, we manage this also later in the while loop
-      if STRING_DELIMITERS.include?(peek_char) && peek_char == lstring_delimiter
+      if peek_char && STRING_DELIMITERS.include?(peek_char) && peek_char == lstring_delimiter
         next_value = peek_char(1)
 
         if (
           current_context?(:object_key) && next_value == ':'
         ) || (
-          current_context?(:object_value) && TERMINATORS_OBJECT_VALUE.include?(next_value)
+          current_context?(:object_value) && next_value && TERMINATORS_OBJECT_VALUE.include?(next_value)
         )
           @scanner.getch
           return [true, '']
@@ -535,11 +527,13 @@ module JsonMend
           # Ok this is not a doubled quote, check if this is an empty string or not
           i = skip_whitespaces_at(start_idx: 1)
           next_c = peek_char(i)
-          if STRING_OR_OBJECT_START.include?(next_c)
-            @scanner.getch
-            return [true, '']
-          elsif !TERMINATORS_VALUE.include?(next_c)
-            @scanner.getch
+          if next_c
+            if STRING_OR_OBJECT_START.include?(next_c)
+              @scanner.getch
+              return [true, '']
+            elsif !TERMINATORS_VALUE.include?(next_c)
+              @scanner.getch
+            end
           end
         end
       end
@@ -576,12 +570,12 @@ module JsonMend
         end
 
         break if context_termination_reached?(
-          char:,
-          missing_quotes:
+          char,
+          missing_quotes
         )
 
-        if current_context?(:object_value) && TERMINATORS_OBJECT_VALUE.include?(char) &&
-           (string_parts.empty? || string_parts.last != rstring_delimiter)
+        if current_context?(:object_value) && char && TERMINATORS_OBJECT_VALUE.include?(char) &&
+           (string_parts.empty? || string_parts[-1] != rstring_delimiter)
 
           is_break = check_rstring_delimiter_missing(
             string_parts:,
@@ -592,7 +586,7 @@ module JsonMend
           break if is_break
         end
 
-        if char == ']' && context_contain?(:array) && string_parts.last != rstring_delimiter
+        if char == ']' && context_contain?(:array) && string_parts[-1] != rstring_delimiter
           i = skip_to_character(rstring_delimiter)
           # No delimiter found
           break unless peek_char(i)
@@ -610,7 +604,7 @@ module JsonMend
         @scanner.getch # Consume the character
         char = peek_char
 
-        if !@scanner.eos? && string_parts.last == '\\'
+        if !@scanner.eos? && string_parts[-1] == '\\'
           # This is a special case, if people use real strings this might happen
           is_next, string_parts, char = parse_escape_sequence(
             string_parts:,
@@ -629,7 +623,7 @@ module JsonMend
           break if is_break
         end
 
-        if char == rstring_delimiter && string_parts.last != '\\'
+        if char == rstring_delimiter && string_parts[-1] != '\\'
           if check_doubled_quotes(doubled_quotes, rstring_delimiter)
             # Consumed in helper
           elsif check_missing_quotes_in_object_value(missing_quotes, lstring_delimiter, rstring_delimiter)
@@ -710,7 +704,7 @@ module JsonMend
         check_comma_in_object_value = false if check_comma_in_object_value && next_c.match?(/\p{L}/)
 
         # If we are in an object context, let's check for the right delimiters
-        if (context_contain?(:object) && TERMINATORS_OBJECT_KEY.include?(next_c)) ||
+        if (context_contain?(:object) && next_c && TERMINATORS_OBJECT_KEY.include?(next_c)) ||
            (context_contain?(:array) && TERMINATORS_ARRAY_ITEM.include?(next_c)) ||
            (
              check_comma_in_object_value &&
@@ -735,7 +729,7 @@ module JsonMend
         i += 1
         i = skip_whitespaces_at(start_idx: i)
         next_c = peek_char(i)
-        return [true, false] if TERMINATORS_OBJECT_VALUE.include?(next_c)
+        return [true, false] if next_c && TERMINATORS_OBJECT_VALUE.include?(next_c)
       elsif next_c == rstring_delimiter && peek_char(i - 1) != '\\'
         # Check if self.index:self.index+i is only whitespaces
         return [false, false] if skip_whitespaces_at(start_idx: 1) >= i
@@ -781,7 +775,7 @@ module JsonMend
         prev_byte_idx = @scanner.pos - next_c.bytesize - 1
         is_escaped = prev_byte_idx >= 0 && @scanner.string.getbyte(prev_byte_idx) == 92 # 92 is backslash
 
-        break if TERMINATORS_VALUE.include?(next_c) || (next_c == rstring_delimiter && !is_escaped)
+        break if (next_c && TERMINATORS_VALUE.include?(next_c)) || (next_c == rstring_delimiter && !is_escaped)
 
         index += 1
       end
@@ -805,19 +799,7 @@ module JsonMend
 
       # Scan forward linearly
       while (c = @scanner.getch)
-        next if c != rstring_delimiter
-
-        # Check if escaped (count preceding backslashes)
-        bk = 1
-        slashes = 0
-        while (@scanner.pos - 1 - bk >= 0) &&
-              (char_code = @scanner.string.getbyte(@scanner.pos - 1 - bk)) &&
-              char_code == 92 # 92 is backslash
-          slashes += 1
-          bk += 1
-        end
-
-        if slashes.even?
+        if c == rstring_delimiter
           found_next = true
           break
         end
@@ -844,7 +826,11 @@ module JsonMend
         # Jump directly to the exact byte offset after the second quote!
         @scanner.pos = pos_after_second_quote
         @scanner.skip(/\s+/)
-        is_next_closer = TERMINATORS_VALUE.include?(@scanner.check(/./))
+
+        # Safely check the next character using the nil guard
+        next_char = @scanner.check(/./)
+        is_next_closer = next_char && TERMINATORS_VALUE.include?(next_char)
+
         @scanner.pos = saved_pos
       end
 
@@ -934,18 +920,18 @@ module JsonMend
       char:,
       rstring_delimiter:
     )
-      if !@scanner.eos? && string_parts.last == '\\'
+      if !@scanner.eos? && string_parts[-1] == '\\'
         # This is a special case, if people use real strings this might happen
         if char == rstring_delimiter || ESCAPE_START_CHARS.include?(char)
-          string_parts.pop
+          string_parts.chop!
           string_parts << ESCAPE_MAPPING.fetch(char, char)
 
           @scanner.getch # Consume the character
           char = peek_char
-          while !@scanner.eos? && string_parts.last == '\\' && (char == rstring_delimiter || char == '\\')
+          while !@scanner.eos? && string_parts[-1] == '\\' && (char == rstring_delimiter || char == '\\')
             # this is a bit of a special case, if I don't do this it will close the loop or create a train of \\
             # I don't love it though
-            string_parts.pop
+            string_parts.chop!
             string_parts << char
             @scanner.getch # Consume the character
             char = peek_char
@@ -959,7 +945,7 @@ module JsonMend
 
           # Validate valid hex digits
           if (hex_str = @scanner.scan(hex_regex))
-            string_parts.pop
+            string_parts.chop!
             hex_val = hex_str.to_i(16)
 
             if char == 'u' && hex_val.between?(0xD800, 0xDBFF)
@@ -985,11 +971,7 @@ module JsonMend
               string_parts << "\uFFFD"
             else
               # Regular code point or hex escape
-              begin
-                string_parts << hex_val.chr('UTF-8')
-              rescue RangeError
-                string_parts << "\uFFFD"
-              end
+              string_parts << hex_val.chr('UTF-8')
             end
 
             # Scanner is already advanced past digits
@@ -1000,7 +982,7 @@ module JsonMend
             @scanner.pos = entry_pos
           end
         elsif STRING_DELIMITERS.include?(char) && char != rstring_delimiter
-          string_parts.pop
+          string_parts.chop!
           string_parts << char
           @scanner.getch # Consume the character
           char = peek_char
@@ -1045,19 +1027,19 @@ module JsonMend
       # we need to update the index only if we had a closing quote
       if char == rstring_delimiter
         @scanner.getch
-      elsif missing_quotes && current_context?(:object_key) && string_parts.last == ','
-        string_parts.pop
+      elsif missing_quotes && current_context?(:object_key) && string_parts[-1] == ','
+        string_parts.chop!
       end
 
-      final_str = string_parts.join
+      final_str = string_parts
       final_str = final_str.rstrip if missing_quotes || final_str.end_with?("\n")
 
       final_str
     end
 
     def context_termination_reached?(
-      char:,
-      missing_quotes:
+      char,
+      missing_quotes
     )
       return false unless missing_quotes
 
@@ -1105,7 +1087,7 @@ module JsonMend
       end
 
       # Handle cases where the number ends with one or more invalid characters.
-      if !scanned_str.empty? && scanned_str.match?(INVALID_NUMBER_TRAILERS_REGEX)
+      if !scanned_str.empty? && scanned_str.end_with?(*INVALID_NUMBER_TRAILERS)
         # Do not rewind scanner, simply discard the invalid trailing chars (garbage)
         scanned_str.sub!(INVALID_NUMBER_TRAILERS_REGEX, '')
       end
@@ -1219,13 +1201,7 @@ module JsonMend
     # It quickly iterates to find a character, handling escaped characters, and
     # returns the index (offset) from the scanner
     def skip_to_character(characters, start_idx: 0)
-      pattern = SKIP_CHARS_REGEX_CACHE.fetch(characters, nil)
-      # :nocov:
-      if pattern.nil?
-        chars = Array(characters).map { |c| Regexp.escape(c.to_s) }
-        pattern = Regexp.new(chars.join('|'))
-      end
-      # :nocov:
+      pattern = SKIP_CHARS_REGEX_CACHE.fetch(characters)
 
       saved_pos = @scanner.pos
       # Skip start_idx
@@ -1302,12 +1278,13 @@ module JsonMend
     def peek_char(offset = 0)
       # Handle the common 0-offset case
       if offset.zero?
-        # peek(1) returns the next BYTE, not character
-        byte_str = @scanner.peek(1)
-        return nil if byte_str.empty?
+        pos = @scanner.pos
+        str = @scanner.string
+        return nil if pos >= str.bytesize
 
+        byte = str.getbyte(pos)
         # Fast path: If it's a standard ASCII char (0-127), return it directly.
-        return byte_str if byte_str.getbyte(0) < 128
+        return byte.chr if byte < 128
 
         # Slow path: If it's a multibyte char (e.g. “), use regex to match the full character.
         return @scanner.check(/./m)
@@ -1324,22 +1301,34 @@ module JsonMend
       res
     end
 
+    def push_context(value)
+      @context.push(value)
+      @context_counts[value] += 1
+      @current_context = value
+    end
+
+    def pop_context
+      popped_value = @context.pop
+      @context_counts[popped_value] -= 1
+      @current_context = @context.last
+    end
+
     def current_context?(value)
-      @context&.last == value
+      @current_context == value
     end
 
     def context_contain?(value)
-      @context.include?(value)
+      @context_counts[value].positive?
     end
 
     # Checks if the character signifies the start of a string or literal
     def string_start?(char)
-      STRING_DELIMITERS.include?(char) || char&.match?(/[\p{L}$_]/)
+      (char && STRING_DELIMITERS.include?(char)) || (char && STRING_START_REGEX.match?(char))
     end
 
     # Checks if the character signifies the start of a number
     def number_start?(char)
-      char&.match?(/\d/) || char == '-' || char == '.'
+      (char && char >= '0' && char <= '9') || char == '-' || char == '.'
     end
   end
 end

data/lib/json_mend/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonMend
-  VERSION = '0.3.5'
+  VERSION = '0.3.7'
 end

data/lib/json_mend.rb

@@ -15,21 +15,22 @@ module JsonMend
     # @return [Object, String] The repaired JSON object or string.
     def repair(json_string, return_objects: false)
       # First, attempt to parse the string with the standard library.
-      repaired_json = begin
+      begin
         parsed = JSON.parse(
           json_string,
           allow_trailing_comma: true,
           allow_control_characters: true
         )
 
-        # Verify the native parser didn't produce invalid UTF-8 (like unpaired surrogates)
-        # by ensuring it can safely dump its own output.
-        JSON.generate(parsed)
+        # If the user wants objects, return them immediately
+        return parsed if return_objects
 
-        parsed
+        # Otherwise, generate the string once. This acts as both the
+        # UTF-8 verification step AND the final string output.
+        return JSON.generate(parsed)
       rescue JSON::ParserError, JSON::GeneratorError
         parser = Parser.new(json_string)
-        parser.parse
+        repaired_json = parser.parse
       end
 
       # Avoids returning `null` for empty results, returns the object directly

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_mend
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Oleksii Vasyliev
@@ -77,14 +77,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Repair broken JSON
 test_files: []