json_mend 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab406c9f47e6e3f844c34b50f87396328ed8c050ab1173099fb2d0f07a86dfa7
-  data.tar.gz: 650ed3e990b93dbb53e609c7f247ecf2a275a6c58eed7998c96a2896d8a72e36
+  metadata.gz: 96e37cada4ab9945473f6a49b1d57a24c7822dceb0e6402847d129827686202a
+  data.tar.gz: b497489826f674239f601203e237ee7358c7305475a2f1a43d37e465d04ce875
 SHA512:
-  metadata.gz: 851479fd3d7315fb2ffb241618567ca471bff5a58abf66b23a41e8cf313cc355178ca1c052dbbc56aa8def7749aaec3660428ec4e303e34b56d69a62d9326618
-  data.tar.gz: da87b0f02f6538584cd2740e1cfd71cfb29781f44f10621a7c818c3c09f22f92754f109330333344098305956f9143e8cadedb27b422c3fa89cef5a572a2a23a
+  metadata.gz: 641ef79051d205ed61c16b9d6deb5f755d41bfb74f3958ac5b1910e2770ac3df2ccdf7e971ba6d44222e7a71de51078b3964da957b44bf70898db13a798ad239
+  data.tar.gz: 605ec12dc272c8b1ce7526c8dcf53748e148a58957e6eca9ebf13133ac7f56db46a56161db03227790ddf5c064a582440a3dc02d33bb117f808e536d910f55fe

data/.rubocop.yml

@@ -7,19 +7,19 @@ AllCops:
   SuggestExtensions: false
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 65
 
 Metrics/ClassLength:
-  Max: 800
+  Max: 820
 
 Metrics/CyclomaticComplexity:
-  Max: 30
+  Max: 35
 
 Metrics/MethodLength:
-  Max: 70
+  Max: 80
 
 Metrics/PerceivedComplexity:
-  Max: 32
+  Max: 35
 
 Metrics/BlockNesting:
   Max: 5

data/lib/json_mend/parser.rb

@@ -190,7 +190,7 @@ module JsonMend
       end
 
       # 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 == '}')
+      return [nil, nil, false] if key.empty? && (peek_char.nil? || peek_char == '}' || @scanner.pos == pos_before_key)
 
       # --- 2. Handle Duplicate Keys (Safer Method) ---
       # This is a critical repair for lists of objects missing a comma separator.
@@ -222,8 +222,10 @@ module JsonMend
     # Parses the key of an object, including the special logic for merging dangling arrays.
     # Returns [key, was_array_merged_flag]
     def parse_object_key(object)
+      char = peek_char
+
       # First, check for and handle the dangling array merge logic.
-      if try_to_merge_dangling_array(object)
+      if char == '[' && try_to_merge_dangling_array(object)
         return [nil, true, false] # Signal that an array was merged.
       end
 
@@ -231,7 +233,7 @@ module JsonMend
       @context.push(:object_key)
       is_bracketed = false
 
-      if peek_char == '['
+      if char == '['
         @scanner.getch # Consume '['
         arr = parse_array
         key = arr.first.to_s
@@ -242,7 +244,7 @@ module JsonMend
       @context.pop
 
       # If the key is empty, consume any stray characters to prevent infinite loops.
-      @scanner.getch if key.empty? && !@scanner.check(/[:}]/) && !@scanner.eos?
+      @scanner.getch if key.empty? && !@scanner.check(/[:{\[}\]]/) && !@scanner.eos?
 
       [key, false, is_bracketed] # Signal that a key was parsed.
     end
@@ -355,7 +357,7 @@ module JsonMend
       char = prepare_string_parsing
 
       # 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? && !STRING_DELIMITERS.include?(char) && !char.match?(/[\p{L}0-9$_-]/)
         return '' if TERMINATORS_STRING_GUESSED.include?(char)
 
         @scanner.getch
@@ -434,7 +436,7 @@ module JsonMend
       when '“'
         lstring_delimiter = '“'
         rstring_delimiter = '”'
-      when /[\p{L}0-9]/
+      when /[\p{L}0-9$_-]/
         # Could be a boolean/null, but not if it's an object key.
         if BOOLEAN_OR_NULL_CHARS.include?(char.downcase) && !current_context?(:object_key)
           # parse_literal is non-destructive if it fails to match.
@@ -509,6 +511,17 @@ module JsonMend
       unmatched_delimiter = false
       # --- Main Parsing Loop ---
       while !@scanner.eos? && char != rstring_delimiter
+        # Fast-path for unquoted keys (e.g. { key: val })
+        # consumes a chunk of valid identifier characters at once
+        if missing_quotes && current_context?(:object_key)
+          chunk = @scanner.scan(/[a-zA-Z0-9_$-]+/)
+          if chunk
+            string_parts << chunk
+            char = peek_char
+            next
+          end
+        end
+
         break if context_termination_reached?(
           char:,
           missing_quotes:
@@ -715,37 +728,52 @@ module JsonMend
     end
 
     def check_unmatched_in_array(rstring_delimiter:)
-      # Heuristic: Check if this quote is a closer or internal.
-      # 1. Find the NEXT delimiter (quote) index `j`.
-      j = 1
+      saved_pos = @scanner.pos
+      @scanner.getch # Skip the current char (the potential closer)
+
       found_next = false
-      while (c = peek_char(j))
-        if c == rstring_delimiter
-          # Check if escaped (count preceding backslashes)
-          bk = 1
-          slashes = 0
-          while j - bk >= 0 && peek_char(j - bk) == '\\'
-            slashes += 1
-            bk += 1
-          end
-          if slashes.even?
-            found_next = true
-            break
-          end
-        end
+      j = 1
+
+      # Scan forward linearly
+      while (c = @scanner.getch)
         j += 1
+        next if c != rstring_delimiter
+
+        # Check if escaped (count preceding backslashes)
+        # We need to look behind from the current scanner position
+        bk = 1
+        slashes = 0
+        # Look back in the string buffer directly for speed
+        while (char_code = @scanner.string.getbyte(@scanner.pos - 1 - bk)) && char_code == 92 # 92 is backslash
+          slashes += 1
+          bk += 1
+        end
+
+        if slashes.even?
+          found_next = true
+          break
+        end
       end
 
-      # 2. Check conditions to STOP (treat as closing quote):
-      #    a) Strictly whitespace between quotes: ["a" "b"]
-      is_whitespace = (1...j).all? { |k| peek_char(k).match?(/\s/) }
+      # Reset position immediately after scanning
+      @scanner.pos = saved_pos
+
+      # Check conditions to STOP (treat as closing quote):
+      # a) Strictly whitespace between quotes
+      # We can check this by examining the substring we just scanned
+      substring_between = @scanner.string.byteslice(saved_pos + 1, j - 2)
+      is_whitespace = substring_between&.match?(/\A\s*\z/)
 
-      #    b) Next quote is followed by a separator: ["val1" val2",]
+      # b) Next quote is followed by a separator
       is_next_closer = false
       if found_next
-        k = j + 1
-        k += 1 while peek_char(k)&.match?(/\s/) # skip whitespaces
-        is_next_closer = TERMINATORS_VALUE.include?(peek_char(k))
+        # We need to peek ahead from where we found the next quote.
+        # Since we reset the scanner, we can use peek_char with the calculated offset `j`
+        # OR better, temporarily move scanner to `saved_pos + j`
+        @scanner.pos = saved_pos + j
+        @scanner.skip(/\s+/)
+        is_next_closer = TERMINATORS_VALUE.include?(@scanner.check(/./))
+        @scanner.pos = saved_pos
       end
 
       return [true, true] unless is_whitespace || is_next_closer
@@ -1027,18 +1055,25 @@ module JsonMend
 
       # Check for a line comment `//...` or `#...`
       elsif @scanner.scan(%r{//|#})
-        # Determine valid line comment termination characters based on context.
-        termination_chars = ["\n", "\r"]
-        termination_chars << ']' if context_contain?(:array)
-        termination_chars << '}' if context_contain?(:object_value)
-        termination_chars << ':' if context_contain?(:object_key)
-
-        # Create a regex that will scan until it hits one of the terminators.
-        # The terminators are positive lookaheads, so they aren't consumed by the scan.
-        terminator_regex = Regexp.new("(?=#{termination_chars.map { |c| Regexp.escape(c) }.join('|')})")
-
-        # Scan until the end of the comment.
-        @scanner.scan_until(terminator_regex)
+        in_array = context_contain?(:array)
+        in_object = context_contain?(:object_value)
+
+        if context_contain?(:object_key)
+          # If parsing a key, we must stop at ':' and structural closers
+          @scanner.scan_until(/(?=[\n\r:}\]])/)
+        elsif in_array && in_object
+          # Nested ambiguity, stop at any closer
+          @scanner.scan_until(/(?=[\n\r}\]])/)
+        elsif in_array
+          # Inside array, stop at ']'
+          @scanner.scan_until(/(?=[\n\r\]])/)
+        elsif in_object
+          # Inside object value, stop at '}'
+          @scanner.scan_until(/(?=[\n\r}])/)
+        else
+          # Top level or neutral, stop at newline
+          @scanner.scan_until(/(?=[\n\r])/)
+        end
       else
         # The character at the current position (likely '/') is not the start of a
         # valid comment. To prevent an infinite loop in the calling parser, we must
@@ -1053,7 +1088,13 @@ 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 = characters.is_a?(Array) ? Regexp.union(characters) : characters
+      pattern = if characters.is_a?(Regexp)
+                  characters
+                else
+                  # Escape if it's a string, join if it's an array
+                  chars = Array(characters).map { |c| Regexp.escape(c.to_s) }
+                  Regexp.new(chars.join('|'))
+                end
 
       saved_pos = @scanner.pos
       # Skip start_idx
@@ -1142,16 +1183,29 @@ module JsonMend
 
     # Peeks the next character without advancing the scanner
     def peek_char(offset = 0)
-      return @scanner.check(/./m) if offset.zero?
+      # 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?
+
+        # Fast path: If it's a standard ASCII char (0-127), return it directly.
+        # This avoids the regex overhead for standard JSON characters ({, [, ", etc).
+        return byte_str if byte_str.getbyte(0) < 128
+
+        # Slow path: If it's a multibyte char (e.g. “), use regex to match the full character.
+        return @scanner.check(/./m)
+      end
 
+      # For offsets > 0, we must scan to skip correctly (as characters can be variable width)
       saved_pos = @scanner.pos
-      c = nil
+      res = nil
       (offset + 1).times do
-        c = @scanner.getch
-        break if c.nil?
+        res = @scanner.getch
+        break if res.nil?
       end
       @scanner.pos = saved_pos
-      c
+      res
     end
 
     def current_context?(value)
@@ -1164,7 +1218,7 @@ module JsonMend
 
     # Checks if the character signifies the start of a string or literal
     def string_start?(char)
-      STRING_DELIMITERS.include?(char) || char&.match?(/\p{L}/)
+      STRING_DELIMITERS.include?(char) || char&.match?(/[\p{L}$_]/)
     end
 
     # Checks if the character signifies the start of a number

data/lib/json_mend/version.rb

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

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: json_mend
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
-- Alexey Vasiliev
+- Oleksii Vasyliev
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -37,7 +37,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Repair broken JSON
+description: JsonMend is a robust Ruby gem designed to repair broken or malformed
+  JSON strings. It is specifically optimized to handle common errors found in JSON
+  generated by Large Language Models (LLMs), such as missing quotes, trailing commas,
+  unescaped characters, and stray comments
 email:
 - leopard.not.a@gmail.com
 executables: []