json-repair 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17c6b285b495a3c053ae838e701205ec682f7648856cadb52d00da5d348f393c
+  data.tar.gz: 644acd7c8840e0a1edf4399297c1bbcc17739cdd13ab6ee9102880981a00bc84
+SHA512:
+  metadata.gz: 6bbe9f8d1e5558ab344987a867dc1aae6859c7e33b537cf20b78d97b5db4734c33388d7514b5db85decf8ca156d91efd4fe98d7cd8b42bc2c2fa81822a0ce9bd
+  data.tar.gz: '0175953daedfe95efb9dc1777d38c2e6034e1822b0463fe50cf52dc946a17cd5a363bab862bc776399bd2e34c249b682298c2989f5ce7fa959cd667c4845d013'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,42 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/ClassLength:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/AbcSize:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/MethodLength:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/BlockLength:
+  Exclude:
+    - lib/json/repair/repairer.rb
+    - spec/**/*
+
+Metrics/BlockNesting:
+  Exclude:
+    - lib/json/repair/repairer.rb
+
+Metrics/ModuleLength:
+  Exclude:
+    - lib/json/repair/string_utils.rb

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changes
+
+### 2024-05-23 (0.1.0)
+
+* Initial setup

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at alexandrz@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/LICENSE.txt

@@ -0,0 +1,7 @@
+The ISC License
+
+Copyright (c) 2024 by Aleksandr Zykov
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# JSON::Repair
+
+This is a Ruby gem designed to repair broken JSON strings. Inspired by the [jsonrepair js library](https://github.com/josdejong/jsonrepair/). It efficiently handles and corrects malformed JSON data, making it especially useful in scenarios where JSON output from LLMs might not strictly adhere to JSON standards. Whether it's missing quotes, misplaced commas, or unexpected characters, it ensures that the JSON data is valid and can be parsed correctly.
+
+## Installation
+
+Add this gem to your application's Gemfield by executing:
+
+```bash
+$ bundle add json-repair
+```
+
+Alternatively, if you are not using Bundler to manage your dependencies:
+
+```bash
+$ gem install json-repair
+```
+
+## Usage
+
+Using JSON::Repair is straightforward. Simply call the `repair` method with a JSON string as an argument:
+
+```ruby
+require 'json/repair'
+
+# Example of repairing a JSON string
+broken_json = '{name: Alice, "age": 25,}'
+repaired_json = JSON::Repair.repair(broken_json)
+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.
+
+## Development
+
+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.
+
+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
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sashazykov/json-repair-rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/sashazykov/json-repair-rb/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [ISC License](https://opensource.org/licenses/ISC).
+
+## Code of Conduct
+
+Everyone interacting in the JSON::Repair project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/sashazykov/json-repair-rb/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/json/repair/repairer.rb

@@ -0,0 +1,647 @@
+# frozen_string_literal: true
+
+require_relative 'string_utils'
+
+module JSON
+  module Repair
+    class Repairer
+      include StringUtils
+
+      CONTROL_CHARACTERS = {
+        "\b" => '\b',
+        "\f" => '\f',
+        "\n" => '\n',
+        "\r" => '\r',
+        "\t" => '\t'
+      }.freeze
+
+      ESCAPE_CHARACTERS = {
+        '"' => '"',
+        '\\' => '\\',
+        '/' => '/',
+        'b' => "\b",
+        'f' => "\f",
+        'n' => "\n",
+        'r' => "\r",
+        't' => "\t"
+      }.freeze
+
+      def initialize(json)
+        @json = json
+        @index = 0
+        @output = ''
+      end
+
+      def repair
+        processed = parse_value
+
+        throw_unexpected_end unless processed
+
+        processed_comma = parse_character(COMMA)
+        parse_whitespace_and_skip_comments if processed_comma
+
+        if start_of_value?(@json[@index]) && ends_with_comma_or_newline?(@output)
+          # start of a new value after end of the root level object: looks like
+          # newline delimited JSON -> turn into a root level array
+          unless processed_comma
+            # repair missing comma
+            @output = insert_before_last_whitespace(@output, ',')
+          end
+
+          parse_newline_delimited_json
+        elsif processed_comma
+          # repair: remove trailing comma
+          @output = strip_last_occurrence(@output, ',')
+        end
+
+        # repair redundant end quotes
+        while @json[@index] == CLOSING_BRACE || @json[@index] == CLOSING_BRACKET
+          @index += 1
+          parse_whitespace_and_skip_comments
+        end
+
+        if @index >= @json.length
+          # reached the end of the document properly
+          return @output
+        end
+
+        throw_unexpected_character
+      end
+
+      private
+
+      def parse_value
+        parse_whitespace_and_skip_comments
+        process = parse_object || parse_array || parse_string || parse_number || parse_keywords || parse_unquoted_string
+        parse_whitespace_and_skip_comments
+
+        process
+      end
+
+      def parse_whitespace
+        whitespace = ''
+        while @json[@index] && (whitespace?(@json[@index]) || special_whitespace?(@json[@index]))
+          whitespace += whitespace?(@json[@index]) ? @json[@index] : ' '
+
+          @index += 1
+        end
+
+        unless whitespace.empty?
+          @output += whitespace
+          return true
+        end
+
+        false
+      end
+
+      def parse_comment
+        if @json[@index] == '/' && @json[@index + 1] == '*'
+          # Block comment
+          @index += 2
+          @index += 1 until @json[@index].nil? || (@json[@index] == '*' && @json[@index + 1] == '/')
+          @index += 2
+          true
+        elsif @json[@index] == '/' && @json[@index + 1] == '/'
+          # Line comment
+          @index += 2
+          @index += 1 until @json[@index].nil? || @json[@index] == "\n"
+          true
+        else
+          false
+        end
+      end
+
+      # Parse an object like '{"key": "value"}'
+      def parse_object
+        return false unless @json[@index] == OPENING_BRACE
+
+        @output += '{'
+        @index += 1
+        parse_whitespace_and_skip_comments
+
+        # repair: skip leading comma like in {, message: "hi"}
+        parse_whitespace_and_skip_comments if skip_character(COMMA)
+
+        initial = true
+        while @index < @json.length && @json[@index] != CLOSING_BRACE
+          processed_comma = true
+          if initial
+            initial = false
+          else
+            processed_comma = parse_character(COMMA)
+            unless processed_comma
+              # repair missing comma
+              @output = insert_before_last_whitespace(@output, ',')
+            end
+            parse_whitespace_and_skip_comments
+          end
+
+          skip_ellipsis
+
+          processed_key = parse_string || parse_unquoted_string
+          unless processed_key
+            if @json[@index] == CLOSING_BRACE || @json[@index] == OPENING_BRACE ||
+               @json[@index] == CLOSING_BRACKET || @json[@index] == OPENING_BRACKET ||
+               @json[@index].nil?
+              # repair trailing comma
+              @output = strip_last_occurrence(@output, ',')
+            else
+              throw_object_key_expected
+            end
+            break
+          end
+
+          parse_whitespace_and_skip_comments
+          processed_colon = parse_character(COLON)
+          truncated_text = @index >= @json.length
+          unless processed_colon
+            if start_of_value?(@json[@index]) || truncated_text
+              # repair missing colon
+              @output = insert_before_last_whitespace(@output, ':')
+            else
+              throw_colon_expected
+            end
+          end
+
+          processed_value = parse_value
+          unless processed_value
+            if processed_colon || truncated_text
+              # repair missing object value
+              @output += 'null'
+            else
+              throw_colon_expected
+            end
+          end
+        end
+
+        if @json[@index] == CLOSING_BRACE
+          @output += '}'
+          @index += 1
+        else
+          # repair missing end bracket
+          @output = insert_before_last_whitespace(@output, '}')
+        end
+
+        true
+      end
+
+      def skip_character(char)
+        if @json[@index] == char
+          @index += 1
+          true
+        else
+          false
+        end
+      end
+
+      # Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
+      # or a similar construct in objects.
+      def skip_ellipsis
+        parse_whitespace_and_skip_comments
+
+        if @json[@index] == DOT &&
+           @json[@index + 1] == DOT &&
+           @json[@index + 2] == DOT
+          # repair: remove the ellipsis (three dots) and optionally a comma
+          @index += 3
+          parse_whitespace_and_skip_comments
+          skip_character(COMMA)
+        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
+      #
+      # The function can run in two stages:
+      # - First, it assumes the string has a valid end quote
+      # - If it turns out that the string does not have a valid end quote followed
+      #   by a delimiter (which should be the case), the function runs again in a
+      #   more conservative way, stopping the string at the first next delimiter
+      #   and fixing the string by inserting a quote there.
+      def parse_string(stop_at_delimiter: false)
+        if @json[@index] == BACKSLASH
+          # repair: remove the first escape character
+          @index += 1
+          skip_escape_chars = true
+        end
+
+        if quote?(@json[@index])
+          # double quotes are correct JSON,
+          # single quotes come from JavaScript for example, we assume it will have a correct single end quote too
+          # otherwise, we will match any double-quote-like start with a double-quote-like end,
+          # or any single-quote-like start with a single-quote-like end
+          is_end_quote = if double_quote?(@json[@index])
+                           method(:double_quote?)
+                         elsif single_quote?(@json[@index])
+                           method(:single_quote?)
+                         elsif single_quote_like?(@json[@index])
+                           method(:single_quote_like?)
+                         else
+                           method(:double_quote_like?)
+                         end
+
+          i_before = @index
+          o_before = @output.length
+
+          str = '"'
+          @index += 1
+
+          loop do
+            if @index >= @json.length
+              # end of text, we are missing an end quote
+
+              i_prev = prev_non_whitespace_index(@index - 1)
+              if !stop_at_delimiter && delimiter?(@json[i_prev])
+                # if the text ends with a delimiter, like ["hello],
+                # so the missing end quote should be inserted before this delimiter
+                # retry parsing the string, stopping at the first next delimiter
+                @index = i_before
+                @output = @output[0...o_before]
+
+                return parse_string(stop_at_delimiter: true)
+              end
+
+              # repair missing quote
+              str = insert_before_last_whitespace(str, '"')
+              @output += str
+
+              return true
+            elsif is_end_quote.call(@json[@index])
+              # end quote
+              i_quote = @index
+              o_quote = str.length
+              str += '"'
+              @index += 1
+              @output += str
+
+              parse_whitespace_and_skip_comments
+
+              if stop_at_delimiter ||
+                 @index >= @json.length ||
+                 delimiter?(@json[@index]) ||
+                 quote?(@json[@index]) ||
+                 digit?(@json[@index])
+                # The quote is followed by the end of the text, a delimiter, or a next value
+                parse_concatenated_string
+
+                return true
+              end
+
+              if delimiter?(@json[prev_non_whitespace_index(i_quote - 1)])
+                # This is not the right end quote: it is preceded by a delimiter,
+                # and NOT followed by a delimiter. So, there is an end quote missing
+                # parse the string again and then stop at the first next delimiter
+                @index = i_before
+                @output = @output[...o_before]
+
+                return parse_string(stop_at_delimiter: true)
+              end
+
+              # revert to right after the quote but before any whitespace, and continue parsing the string
+              @output = @output[...o_before]
+              @index = i_quote + 1
+
+              # repair unescaped quote
+              str = "#{str[...o_quote]}\\#{str[o_quote..]}"
+            elsif stop_at_delimiter && delimiter?(@json[@index])
+              # we're in the mode to stop the string at the first delimiter
+              # because there is an end quote missing
+
+              # repair missing quote
+              str = insert_before_last_whitespace(str, '"')
+              @output += str
+
+              parse_concatenated_string
+
+              return true
+            elsif @json[@index] == BACKSLASH
+              # handle escaped content like \n or \u2605
+              char = @json[@index + 1]
+              escape_char = ESCAPE_CHARACTERS[char]
+              if escape_char
+                str += @json[@index, 2]
+                @index += 2
+              elsif char == 'u'
+                j = 2
+                j += 1 while j < 6 && @json[@index + j] && hex?(@json[@index + j])
+                if j == 6
+                  str += @json[@index, 6]
+                  @index += 6
+                elsif @index + j >= @json.length
+                  # repair invalid or truncated unicode char at the end of the text
+                  # by removing the unicode char and ending the string here
+                  @index = @json.length
+                else
+                  throw_invalid_unicode_character
+                end
+              else
+                # repair invalid escape character: remove it
+                str += char
+                @index += 2
+              end
+            else
+              # handle regular characters
+              char = @json[@index]
+
+              if char == DOUBLE_QUOTE && @json[@index - 1] != BACKSLASH
+                # repair unescaped double quote
+                str += "\\#{char}"
+              elsif control_character?(char)
+                # unescaped control character
+                str += CONTROL_CHARACTERS[char]
+              else
+                throw_invalid_character(char) unless valid_string_character?(char)
+                str += char
+              end
+
+              @index += 1
+            end
+
+            if skip_escape_chars
+              # repair: skipped escape character (nothing to do)
+              skip_escape_character
+            end
+          end
+        end
+
+        false
+      end
+
+      # Repair an unquoted string by adding quotes around it
+      # Repair a MongoDB function call like NumberLong("2")
+      # Repair a JSONP function call like callback({...});
+      def parse_unquoted_string
+        start = @index
+        @index += 1 while @index < @json.length && !delimiter_except_slash?(@json[@index]) && !quote?(@json[@index])
+        return if @index <= start
+
+        if @json[@index] == '(' && function_name?(@json[start...@index].strip)
+          # Repair a MongoDB function call like NumberLong("2")
+          # Repair a JSONP function call like callback({...});
+          @index += 1
+
+          parse_value
+
+          if @json[@index] == ')'
+            # Repair: skip close bracket of function call
+            @index += 1
+            # Repair: skip semicolon after JSONP call
+            @index += 1 if @json[@index] == ';'
+          end
+        else
+          # Repair unquoted string
+          # Also, repair undefined into null
+
+          # First, go back to prevent getting trailing whitespaces in the string
+          @index -= 1 while whitespace?(@json[@index - 1]) && @index.positive?
+
+          symbol = @json[start...@index]
+          @output += symbol == 'undefined' ? 'null' : symbol.inspect
+
+          if @json[@index] == '"'
+            # We had a missing start quote, but now we encountered the end quote, so we can skip that one
+            @index += 1
+          end
+        end
+
+        true
+      end
+
+      def parse_character(char)
+        if @json[@index] == char
+          @output += @json[@index]
+          @index += 1
+          true
+        else
+          false
+        end
+      end
+
+      def parse_whitespace_and_skip_comments
+        start = @index
+
+        changed = parse_whitespace
+        loop do
+          changed = parse_comment
+          changed = parse_whitespace if changed
+          break unless changed
+        end
+
+        @index > start
+      end
+
+      # Parse a number like 2.4 or 2.4e6
+      def parse_number
+        start = @index
+        if @json[@index] == '-'
+          @index += 1
+          if at_end_of_number?
+            repair_number_ending_with_numeric_symbol(start)
+            return true
+          end
+          unless digit?(@json[@index])
+            @index = start
+            return false
+          end
+        end
+
+        # Note that in JSON leading zeros like "00789" are not allowed.
+        # We will allow all leading zeros here though and at the end of parse_number
+        # check against trailing zeros and repair that if needed.
+        # Leading zeros can have meaning, so we should not clear them.
+        @index += 1 while digit?(@json[@index])
+
+        if @json[@index] == '.'
+          @index += 1
+          if at_end_of_number?
+            repair_number_ending_with_numeric_symbol(start)
+            return true
+          end
+          unless digit?(@json[@index])
+            @index = start
+            return false
+          end
+          @index += 1 while digit?(@json[@index])
+        end
+
+        if @json[@index] && @json[@index].downcase == 'e'
+          @index += 1
+          @index += 1 if ['-', '+'].include?(@json[@index])
+          if at_end_of_number?
+            repair_number_ending_with_numeric_symbol(start)
+            return true
+          end
+          unless digit?(@json[@index])
+            @index = start
+            return false
+          end
+          @index += 1 while digit?(@json[@index])
+        end
+
+        # if we're not at the end of the number by this point, allow this to be parsed as another type
+        unless at_end_of_number?
+          @index = start
+          return false
+        end
+
+        if @index > start
+          # repair a number with leading zeros like "00789"
+          num = @json[start...@index]
+          has_invalid_leading_zero = num.match?(/^0\d/)
+
+          @output += has_invalid_leading_zero ? "\"#{num}\"" : num
+          return true
+        end
+
+        false
+      end
+
+      def at_end_of_number?
+        @index >= @json.length || delimiter?(@json[@index]) || whitespace?(@json[@index])
+      end
+
+      # Parse an array like '["item1", "item2", ...]'
+      def parse_array
+        if @json[@index] == OPENING_BRACKET
+          @output += '['
+          @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)
+
+          initial = true
+          while @index < @json.length && @json[@index] != CLOSING_BRACKET
+            if initial
+              initial = false
+            else
+              processed_comma = parse_character(COMMA)
+              # repair missing comma
+              @output = insert_before_last_whitespace(@output, ',') unless processed_comma
+            end
+
+            skip_ellipsis
+
+            processed_value = parse_value
+            next if processed_value
+
+            # repair trailing comma
+            @output = strip_last_occurrence(@output, ',')
+            break
+          end
+
+          if @json[@index] == CLOSING_BRACKET
+            @output += ']'
+            @index += 1
+          else
+            # repair missing closing array bracket
+            @output = insert_before_last_whitespace(@output, ']')
+          end
+
+          true
+        else
+          false
+        end
+      end
+
+      def prev_non_whitespace_index(start)
+        prev = start
+        prev -= 1 while prev.positive? && whitespace?(@json[prev])
+        prev
+      end
+
+      # Repair concatenated strings like "hello" + "world", change this into "helloworld"
+      def parse_concatenated_string
+        processed = false
+
+        parse_whitespace_and_skip_comments
+        while @json[@index] == PLUS
+          processed = true
+          @index += 1
+          parse_whitespace_and_skip_comments
+
+          # repair: remove the end quote of the first string
+          @output = strip_last_occurrence(@output, '"', strip_remaining_text: true)
+          start = @output.length
+          parsed_str = parse_string
+          @output = if parsed_str
+                      # repair: remove the start quote of the second string
+                      remove_at_index(@output, start, 1)
+                    else
+                      # repair: remove the '+' because it is not followed by a string
+                      insert_before_last_whitespace(@output, '"')
+                    end
+        end
+
+        processed
+      end
+
+      def repair_number_ending_with_numeric_symbol(start)
+        # 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
+        @output += "#{@json[start...@index]}0"
+      end
+
+      # Parse and repair Newline Delimited JSON (NDJSON):
+      # multiple JSON objects separated by a newline character
+      def parse_newline_delimited_json
+        # repair NDJSON
+        initial = true
+        processed_value = true
+        while processed_value
+          if initial
+            initial = false
+          else
+            # parse optional comma, insert when missing
+            processed_comma = parse_character(COMMA)
+            unless processed_comma
+              # repair: add missing comma
+              @output = insert_before_last_whitespace(@output, ',')
+            end
+          end
+
+          processed_value = parse_value
+        end
+
+        unless processed_value
+          # repair: remove trailing comma
+          @output = strip_last_occurrence(@output, ',')
+        end
+
+        # repair: wrap the output inside array brackets
+        @output = "[\n#{@output}\n]"
+      end
+
+      def skip_escape_character
+        skip_character(BACKSLASH)
+      end
+
+      def throw_invalid_character(char)
+        raise JSONRepairError, "Invalid character #{char.inspect} at index #{@index}"
+      end
+
+      def throw_unexpected_character
+        raise JSONRepairError, "Unexpected character #{@json[@index].inspect} at index #{@index}"
+      end
+
+      def throw_unexpected_end
+        raise JSONRepairError, 'Unexpected end of json string'
+      end
+
+      def throw_object_key_expected
+        raise JSONRepairError, 'Object key expected'
+      end
+
+      def throw_colon_expected
+        raise JSONRepairError, 'Colon expected'
+      end
+
+      def throw_invalid_unicode_character
+        chars = @json[@index, 6]
+        raise JSONRepairError, "Invalid unicode character #{chars.inspect} at index #{@index}"
+      end
+    end
+  end
+end

data/lib/json/repair/string_utils.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module JSON
+  module Repair
+    module StringUtils
+      # Constants for character chars
+      BACKSLASH = '\\' # 0x5c
+      SLASH = '/' # 0x2f
+      ASTERISK = '*' # 0x2a
+      OPENING_BRACE = '{' # 0x7b
+      CLOSING_BRACE = '}' # 0x7d
+      OPENING_BRACKET = '[' # 0x5b
+      CLOSING_BRACKET = ']' # 0x5d
+      OPEN_PARENTHESIS = '(' # 0x28
+      CLOSE_PARENTHESIS = ')' # 0x29
+      SPACE = ' ' # 0x20
+      NEWLINE = "\n" # 0xa
+      TAB = "\t" # 0x9
+      RETURN = "\r" # 0xd
+      BACKSPACE = "\b" # 0x08
+      FORM_FEED = "\f" # 0x0c
+      DOUBLE_QUOTE = '"' # 0x0022
+      PLUS = '+' # 0x2b
+      MINUS = '-' # 0x2d
+      QUOTE = "'" # 0x27
+      ZERO = '0' # 0x30
+      NINE = '9' # 0x39
+      COMMA = ',' # 0x2c
+      DOT = '.' # 0x2e
+      COLON = ':' # 0x3a
+      SEMICOLON = ';' # 0x3b
+      UPPERCASE_A = 'A' # 0x41
+      LOWERCASE_A = 'a' # 0x61
+      UPPERCASE_E = 'E' # 0x45
+      LOWERCASE_E = 'e' # 0x65
+      UPPERCASE_F = 'F' # 0x46
+      LOWERCASE_F = 'f' # 0x66
+      NON_BREAKING_SPACE = "\u00a0" # 0xa0
+      EN_QUAD = "\u2000" # 0x2000
+      HAIR_SPACE = "\u200a" # 0x200a
+      NARROW_NO_BREAK_SPACE = "\u202f" # 0x202f
+      MEDIUM_MATHEMATICAL_SPACE = "\u205f" # 0x205f
+      IDEOGRAPHIC_SPACE = "\u3000" # 0x3000
+      DOUBLE_QUOTE_LEFT = "\u201c" # 0x201c
+      DOUBLE_QUOTE_RIGHT = "\u201d" # 0x201d
+      QUOTE_LEFT = "\u2018" # 0x2018
+      QUOTE_RIGHT = "\u2019" # 0x2019
+      GRAVE_ACCENT = '`' # 0x0060
+      ACUTE_ACCENT = "\u00b4" # 0x00b4
+
+      REGEX_DELIMITER = %r{^[,:\[\]/{}()\n+]+$}
+      REGEX_START_OF_VALUE = /^[\[{\w-]$/
+
+      # Functions to check character chars
+      def hex?(char)
+        (char >= ZERO && char <= NINE) ||
+          (char >= UPPERCASE_A && char <= UPPERCASE_F) ||
+          (char >= LOWERCASE_A && char <= LOWERCASE_F)
+      end
+
+      def digit?(char)
+        char && char >= ZERO && char <= NINE
+      end
+
+      def valid_string_character?(char)
+        char.ord >= 0x20 && char.ord <= 0x10ffff
+      end
+
+      def delimiter?(char)
+        REGEX_DELIMITER.match?(char)
+      end
+
+      def delimiter_except_slash?(char)
+        delimiter?(char) && char != SLASH
+      end
+
+      def start_of_value?(char)
+        REGEX_START_OF_VALUE.match?(char) || (char && quote?(char))
+      end
+
+      def control_character?(char)
+        [NEWLINE, RETURN, TAB, BACKSPACE, FORM_FEED].include?(char)
+      end
+
+      def whitespace?(char)
+        [SPACE, NEWLINE, TAB, RETURN].include?(char)
+      end
+
+      def special_whitespace?(char)
+        [
+          NON_BREAKING_SPACE, NARROW_NO_BREAK_SPACE, MEDIUM_MATHEMATICAL_SPACE, IDEOGRAPHIC_SPACE
+        ].include?(char) ||
+          (char >= EN_QUAD && char <= HAIR_SPACE)
+      end
+
+      def quote?(char)
+        double_quote_like?(char) || single_quote_like?(char)
+      end
+
+      def double_quote?(char)
+        char == DOUBLE_QUOTE
+      end
+
+      def single_quote?(char)
+        char == QUOTE
+      end
+
+      def double_quote_like?(char)
+        [DOUBLE_QUOTE, DOUBLE_QUOTE_LEFT, DOUBLE_QUOTE_RIGHT].include?(char)
+      end
+
+      def single_quote_like?(char)
+        [QUOTE, QUOTE_LEFT, QUOTE_RIGHT, GRAVE_ACCENT, ACUTE_ACCENT].include?(char)
+      end
+
+      # Strip last occurrence of text_to_strip from text
+      def strip_last_occurrence(text, text_to_strip, strip_remaining_text: false)
+        index = text.rindex(text_to_strip)
+        return text unless index
+
+        remaining_text = strip_remaining_text ? '' : text[index + 1..]
+        text[0...index] + remaining_text
+      end
+
+      def insert_before_last_whitespace(text, text_to_insert)
+        index = text.length
+
+        return text + text_to_insert unless whitespace?(text[index - 1])
+
+        index -= 1 while whitespace?(text[index - 1])
+
+        text[0...index] + text_to_insert + text[index..]
+      end
+
+      # Parse keywords true, false, null
+      # Repair Python keywords True, False, None
+      # Repair Ruby keyword nil
+      def parse_keywords
+        parse_keyword('true', 'true') ||
+          parse_keyword('false', 'false') ||
+          parse_keyword('null', 'null') ||
+          # Repair Python keywords True, False, None
+          parse_keyword('True', 'true') ||
+          parse_keyword('False', 'false') ||
+          parse_keyword('None', 'null') ||
+          # Repair Ruby keyword nil
+          parse_keyword('nil', 'null')
+      end
+
+      def parse_keyword(name, value)
+        if @json[@index, name.length] == name
+          @output += value
+          @index += name.length
+          true
+        else
+          false
+        end
+      end
+
+      def remove_at_index(text, start, count)
+        text[0...start] + text[start + count..]
+      end
+
+      def function_name?(text)
+        /^\w+$/.match?(text)
+      end
+
+      def ends_with_comma_or_newline?(text)
+        /[,\n][ \t\r]*$/.match?(text)
+      end
+    end
+  end
+end

data/lib/json/repair/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JSON
+  module Repair
+    VERSION = '0.1.0'
+  end
+end

data/lib/json/repair.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'repair/version'
+require_relative 'repair/repairer'
+
+module JSON
+  module Repair
+    class JSONRepairError < StandardError; end
+
+    def self.repair(json)
+      Repairer.new(json).repair
+    end
+  end
+end

data/sig/json/repair.rbs

@@ -0,0 +1,7 @@
+module JSON
+  module Repair
+    VERSION: String
+
+    def self.repair(String) -> ?String
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: json-repair
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aleksandr Zykov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-05-24 00:00:00.000000000 Z
+dependencies: []
+description: This is a simple gem that repairs broken JSON strings.
+email:
+- alexandrz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/json/repair.rb
+- lib/json/repair/repairer.rb
+- lib/json/repair/string_utils.rb
+- lib/json/repair/version.rb
+- sig/json/repair.rbs
+homepage: https://github.com/sashazykov/json-repair-rb
+licenses:
+- ISC
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/sashazykov/json-repair-rb
+  source_code_uri: https://github.com/sashazykov/json-repair-rb
+  changelog_uri: https://github.com/sashazykov/json-repair-rb/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.10
+signing_key:
+specification_version: 4
+summary: Repairs broken JSON strings.
+test_files: []